Mainline/docs/LEGACY_CODE_ANALYSIS.md

Legacy & Dead Code Analysis - Mainline Codebase

Executive Summary

The codebase contains 702 lines of clearly marked legacy code spread across 4 main modules, plus several candidate modules that may be unused. The legacy code primarily relates to the old rendering pipeline that has been superseded by the new Stage-based pipeline architecture.

---

1. MARKED DEPRECATED MODULES (Should Remove/Refactor)

1.1 engine/scroll.py (156 lines)

• Status: DEPRECATED - Marked with deprecation notice
• Why: Legacy rendering/orchestration code replaced by pipeline architecture
• Usage: Used by legacy demo mode via scroll.stream()
• Dependencies:
  • Imports: camera, display, layers, viewport, frame
  • Used by: scroll.py is only imported in tests and demo mode
• Risk: LOW - Clean deprecation boundary
• Recommendation: SAFE TO REMOVE
  • This is the main rendering loop orchestrator for the old system
  • All new code uses the Pipeline architecture
  • Demo mode is transitioning to pipeline presets
  • Consider keeping test_layers.py for testing layer functions

1.2 engine/render.py (274 lines)

• Status: DEPRECATED - Marked with deprecation notice
• Why: Legacy rendering code for font loading, text rasterization, gradient coloring
• Contains:
  • render_line() - Renders text to terminal half-blocks using PIL
  • big_wrap() - Word-wrap text fitting
  • lr_gradient() - Left-to-right color gradients
  • make_block() - Assembles headline blocks
• Usage:
  • layers.py imports: big_wrap, lr_gradient, lr_gradient_opposite
  • scroll.py conditionally imports make_block
  • adapters.py uses make_block
  • test_render.py tests these functions
• Risk: MEDIUM - Used by legacy adapters and layers
• Recommendation: KEEP FOR NOW
  • These functions are still used by adapters for legacy support
  • Could be moved to legacy submodule if cleanup needed
  • Consider marking functions individually as deprecated

1.3 engine/layers.py (272 lines)

• Status: DEPRECATED - Marked with deprecation notice
• Why: Legacy rendering layer logic for effects, overlays, firehose
• Contains:
  • render_ticker_zone() - Renders ticker content
  • render_firehose() - Renders firehose effect
  • render_message_overlay() - Renders messages
  • apply_glitch() - Applies glitch effect
  • process_effects() - Legacy effect chain
  • get_effect_chain() - Access to legacy effect chain
• Usage:
  • scroll.py imports multiple functions
  • effects/controller.py imports get_effect_chain as fallback
  • effects/init.py imports get_effect_chain as fallback
  • adapters.py imports render_firehose, render_ticker_zone
  • test_layers.py tests these functions
• Risk: MEDIUM - Used as fallback in effects system
• Recommendation: KEEP FOR NOW
  • Legacy effects system relies on this as fallback
  • Used by adapters for backwards compatibility
  • Mark individual functions as deprecated

1.4 engine/animation.py (340 lines)

• Status: UNDEPRECATED but largely UNUSED
• Why: Animation system with Clock, AnimationController, Preset classes
• Contains:
  • Clock - High-resolution timer
  • AnimationController - Manages timed events and parameters
  • Preset - Bundles pipeline config + animation
  • Helper functions: create_demo_preset(), create_pipeline_preset()
  • Easing functions: linear_ease, ease_in_out, ease_out_bounce
• Usage:
  • Documentation refers to it in pipeline.py docstrings
  • introspect_animation() method exists but generates no actual content
  • No actual imports of AnimationController found outside animation.py itself
  • Demo presets in animation.py are never called
  • PipelineParams dataclass is defined here but animation system never used
• Risk: LOW - Isolated module with no real callers
• Recommendation: CONSIDER REMOVING
  • This appears to be abandoned experimental code
  • The pipeline system doesn't actually use animation controllers
  • If animation is needed in future, should be redesigned
  • Safe to remove without affecting current functionality

---

2. COMPLETELY UNUSED MODULES (Safe to Remove)

2.1 engine/emitters.py (25 lines)

• Status: UNUSED - Protocol definitions only
• Contains: Three Protocol classes:
  • EventEmitter - Define subscribe/unsubscribe interface
  • Startable - Define start() interface
  • Stoppable - Define stop() interface
• Usage: ZERO references found in codebase
• Risk: NONE - Dead code
• Recommendation: SAFE TO REMOVE
  • Protocol definitions are not used anywhere
  • EventBus uses its own implementation, doesn't inherit from these

2.2 engine/beautiful_mermaid.py (4107 lines!)

• Status: UNUSED - Large ASCII renderer for Mermaid diagrams
• Why: Pure Python Mermaid → ASCII renderer (ported from TypeScript)
• Usage:
  • Only imported in pipeline_viz.py
  • pipeline_viz.py is not imported anywhere in codebase
  • Never called in production code
• Risk: NONE - Dead code
• Recommendation: SAFE TO REMOVE
  • Huge module (4000+ lines) with zero real usage
  • Only used by experimental pipeline_viz which itself is unused
  • Consider keeping as optional visualization tool if needed later

2.3 engine/pipeline_viz.py (364 lines)

• Status: UNUSED - Pipeline visualization module
• Contains: CameraLarge camera mode for pipeline visualization
• Usage:
  • Only referenced in pipeline.py's introspect_pipeline_viz() method
  • This introspection method generates no actual output
  • Never instantiated or called in real code
• Risk: NONE - Experimental dead code
• Recommendation: SAFE TO REMOVE
  • Depends on beautiful_mermaid which is also unused
  • Remove together with beautiful_mermaid

---

3. UNUSED DISPLAY BACKENDS (Lower Priority)

These backends are registered in DisplayRegistry but may not be actively used:

3.1 engine/display/backends/pygame.py (9185 bytes)

• Status: REGISTERED but potentially UNUSED
• Usage: Registered in DisplayRegistry
• Last used in: Demo mode (may have been replaced)
• Risk: LOW - Backend system is pluggable
• Recommendation: CHECK USAGE
  • Verify if any presets use "pygame" display
  • If not used, can remove
  • Otherwise keep as optional backend

3.2 engine/display/backends/kitty.py (5305 bytes)

• Status: REGISTERED but potentially UNUSED
• Usage: Registered in DisplayRegistry
• Last used in: Kitty terminal graphics protocol
• Risk: LOW - Backend system is pluggable
• Recommendation: CHECK USAGE
  • Verify if any presets use "kitty" display
  • If not used, can remove
  • Otherwise keep as optional backend

3.3 engine/display/backends/multi.py (1137 bytes)

• Status: REGISTERED and likely USED
• Usage: MultiDisplay for simultaneous output
• Risk: LOW - Simple wrapper
• Recommendation: KEEP

---

4. TEST FILES THAT MAY BE OBSOLETE

4.1 tests/test_emitters.py (2145 bytes)

• Status: ORPHANED
• Why: Tests for unused emitters protocols
• Recommendation: SAFE TO REMOVE
  • Remove with engine/emitters.py

4.2 tests/test_render.py (7628 bytes)

• Status: POTENTIALLY USEFUL
• Why: Tests for legacy render functions still used by adapters
• Recommendation: KEEP FOR NOW
  • Keep while render.py functions are used

4.3 tests/test_layers.py (3717 bytes)

• Status: POTENTIALLY USEFUL
• Why: Tests for legacy layer functions
• Recommendation: KEEP FOR NOW
  • Keep while layers.py functions are used

---

5. QUESTIONABLE PATTERNS & TECHNICAL DEBT

5.1 Legacy Effect Chain Fallback

Location: effects/controller.py, effects/__init__.py

# Fallback to legacy effect chain if no new effects available
try:
    from engine.layers import get_effect_chain as _chain
except ImportError:
    _chain = None

Issue: Dual effect system with implicit fallback Recommendation: Document or remove fallback path if not actually used

5.2 Deprecated ItemsStage Bootstrap

Location: pipeline/adapters.py line 356-365

@deprecated("ItemsStage is deprecated. Use DataSourceStage with a DataSource instead.")
class ItemsStage(Stage):
    """Deprecated bootstrap mechanism."""

Issue: Marked deprecated but still registered and potentially used Recommendation: Audit usage and remove if not needed

5.3 Legacy Tuple Conversion Methods

Location: engine/types.py

def to_legacy_tuple(self) -> tuple[list[tuple], int, int]:
    """Convert to legacy tuple format for backward compatibility."""

Issue: Backward compatibility layer that may not be needed Recommendation: Check if actually used by legacy code

5.4 Frame Module (Minimal Usage)

Location: engine/frame.py

Status: Appears minimal and possibly legacy Recommendation: Check what's actually using it

---

SUMMARY TABLE

Module	LOC	Status	Risk	Action
scroll.py	156	REMOVE	LOW	Delete - fully deprecated
emitters.py	25	REMOVE	NONE	Delete - zero usage
beautiful_mermaid.py	4107	REMOVE	NONE	Delete - zero usage
pipeline_viz.py	364	REMOVE	NONE	Delete - zero usage
animation.py	340	CONSIDER	LOW	Remove if not planned
render.py	274	KEEP	MEDIUM	Still used by adapters
layers.py	272	KEEP	MEDIUM	Still used by adapters
pygame backend	9185	AUDIT	LOW	Check if used
kitty backend	5305	AUDIT	LOW	Check if used
test_emitters.py	2145	REMOVE	NONE	Delete with emitters.py

---

RECOMMENDED CLEANUP STRATEGY

Phase 1: Safe Removals (No Dependencies)

1. Delete engine/emitters.py
2. Delete tests/test_emitters.py
3. Delete engine/beautiful_mermaid.py
4. Delete engine/pipeline_viz.py
5. Clean up related deprecation code in pipeline.py

Impact: ~4500 lines of dead code removed Risk: NONE - verified zero usage

Phase 2: Conditional Removals (Audit Required)

1. Verify pygame and kitty backends are not used in any preset
2. If unused, remove from DisplayRegistry and delete files
3. Consider removing engine/animation.py if animation features not planned

Phase 3: Legacy Module Migration (Future)

1. Move render.py functions to legacy submodule if scroll.py is removed
2. Consolidate layers.py with legacy effects
3. Keep test files until legacy adapters are phased out
4. Deprecate legacy adapters in favor of new pipeline stages

Phase 4: Documentation

1. Update AGENTS.md to document removal of legacy modules
2. Document which adapters are for backwards compatibility
3. Add migration guide for teams using old scroll API

---

KEY METRICS

• Total Dead Code Lines: ~9000+ lines
• Safe to Remove Immediately: ~4500 lines
• Conditional Removals: ~10000+ lines (if backends/animation unused)
• Legacy But Needed: ~700 lines (render.py + layers.py)
• Test Files for Dead Code: ~2100 lines