Add type annotations and unit tests.

[rebuild-123]

@codex
Analyze this legacy Python repository and produce a concrete execution plan.

Goal:

• Assess how to add type annotations, stdlib unittest coverage, and fix likely bugs safely.

Context:

• This is an older repository with uneven code quality.
• We want minimal-risk modernization, not a large rewrite.

Constraints:

• Do not modify code yet.
• Read the repo and AGENTS.md first.
• Identify package boundaries, entry points, risky modules, external dependencies, and current testability.
• Propose a phased plan grouped by package/module.
• Call out where type annotations are low-risk vs high-risk.
• Call out where unittest is feasible vs where refactoring is needed first.
• Identify likely bug-prone areas, but do not claim bugs without evidence.

Done when:

• You produce:
  1. a phased execution plan,
  2. a prioritized module list,
  3. expected commands for setup/test/type-check,
  4. key risks and blockers,
  5. the first recommended small PR scope.

[rebuild-123]

@codex

[chatgpt-codex-connector]

Summary

• Added a new planning document, MODERNIZATION_EXECUTION_PLAN.md, that delivers the requested PR follow-up: phased execution plan, prioritized module list, setup/test/type-check commands, key risks/blockers, and a recommended first small PR scope, all without modifying runtime code. MODERNIZATION_EXECUTION_PLAN.mdL1-L180
• The plan explicitly maps low/medium/high risk for type-annotation rollout, identifies where unittest is immediately feasible vs where refactoring should come first, and flags bug-prone zones as risk indicators (not confirmed defects). MODERNIZATION_EXECUTION_PLAN.mdL30-L79
• Committed on the current branch (e7a66d3) and created a follow-up PR via the make_pr tool with a title/body summarizing the delta on top of the original PR request. MODERNIZATION_EXECUTION_PLAN.mdL165-L180

Testing

• ✅ python -m compileall -q .
• ✅ rg --files
• ✅ rg --files -g 'pyproject.toml' -g 'setup.cfg' -g 'requirements*.txt' -g 'tox.ini' -g '.flake8' -g 'mypy.ini'

View task →

[rebuild-123]

@codex
Implement the plan

[chatgpt-codex-connector]

Summary

• Implemented the first execution-plan slice in the strategy package by making behavior fields explicitly optional, initializing them in Duck.__init__, and adding explicit runtime guards for unconfigured behavior calls (performFly / performQuack). strategy/Duck.pyL1-L37
• Updated concrete strategy ducks to call super().__init__() so base initialization is always applied before behavior wiring, reducing initialization risk while keeping runtime behavior unchanged for configured ducks. strategy/DecoyDuck.pyL6-L13 strategy/MallardDuck.pyL6-L13 strategy/ModelDuck.pyL6-L13 strategy/RubberDuck.pyL14-L20
• Added stdlib unittest coverage for the strategy module, including default behavior checks, runtime behavior swapping, dependency-injected behavior usage, and explicit failure behavior for unconfigured ducks (5 tests total). tests/test_strategy_unittest.pyL1-L75
• Committed the changes on branch work (118665d) and created a follow-up PR via the make_pr tool as requested.

Testing

• ✅ python -m unittest discover -s tests -p 'test_*.py'
• ✅ python -m compileall -q strategy tests

View task →

[rebuild-123]

/codex implement branch=codex/test

[github-actions]

Codex Plan

• Branch: codex/test
• Issue: Add type annotations and unit tests. #4

Goal
Safely modernize this legacy repo by adding targeted type annotations and unittest coverage, while minimizing behavior changes and isolating risky modules.

Affected Files

• Scope is phased by module groups, not whole-repo rewrite.
• Phase 0 (test harness/inventory): tests/** (new), plus minimal test bootstrapping for legacy import paths.
• Phase 1 (low risk, deterministic): state/gumball/**, factory/pizzas/**, builder/house/**.
• Phase 2 (medium risk): strategy/** (excluding strategy/challenge/PhotoWithPhone.py), observer/simple/**, observer/weather/**, decorator/starbuzz/**, decorator/starbuzzWithSizes/**.
• Phase 3 (higher risk): command/*WL/**, combining/**, singleton/**, iterator/*/AlternatingDinerMenuIterator.py, input/time/random-dependent modules.

Prioritized Module List

1. state/gumball (deterministic state machine, good first unit-test target).
2. factory/pizzas (simple factory behavior, deterministic).
3. builder/house (object assembly flows, deterministic).
4. decorator/starbuzz and decorator/starbuzzWithSizes.
5. observer/simple then observer/weather.
6. strategy core ducks (exclude interactive challenge first).
7. command/simpleremote and command/remote (non-WL first).
8. singleton/* (threading semantics and global state).
9. combining/* (shared counters/observer state; cross-test coupling risk).
10. command/*WL and interactive/time-based modules last.

Milestones

1. Baseline and harness:

• Confirm baseline: python -m unittest discover -v currently exits with NO TESTS RAN (code 5).
• Add tests/ structure and import-path strategy for legacy same-directory imports.
• Define per-package test convention and naming.

2. Low-risk PR wave:

• Add/complete annotations in state/gumball, factory/pizzas, builder/house where missing.
• Add unittest suites focused on behavior/state transitions, not print text formatting unless needed.

3. Medium-risk PR wave:

• Extend tests and type hints to observer/strategy/decorator modules.
• Introduce deterministic test seams where needed (stdout capture, fixed inputs).

4. High-risk PR wave:

• Tackle singleton, combining, command/*WL, and time/random/input-dependent modules.
• Add minimal refactors only where required for testability.

5. Final consolidation:

• Run full unittest discovery and agreed type-check command.
• Document coverage map and remaining intentional gaps.

Expected Commands (Setup/Test/Type-Check)

• Setup:

1. python --version
2. python -m unittest discover -v

• Smallest-first testing:

1. python -m unittest -v tests.state.test_gumball_machine
2. python -m unittest -v tests.factory.pizzas.test_simple_pizza_factory
3. python -m unittest discover -s tests -p 'test_*.py' -v

• Type-check (after dev-tool approval):

1. python -m mypy state/gumball factory/pizzas builder/house
2. python -m mypy . (final pass)

Low-Risk vs High-Risk Type Annotation Areas

• Low-risk:
• Pure domain classes with deterministic logic and existing partial hints (builder, factory/pizzas, state/gumball, bridge, flyweight).
• High-risk:
• Dynamic/decorator-style callables (command/*WL/Command.py).
• Global/shared mutable state (combining/*/QuackCounter.py counters).
• Threaded singleton patterns (singleton/threadsafe, singleton/dcl, singleton/subclass).
• Input/time/random logic (templatemethod/barista/*WithHook.py, strategy/challenge/PhotoWithPhone.py, alternating iterators, winner state).

Unittest Feasibility

• Feasible now:
• Deterministic modules returning stable state/values, even if print-heavy (stdout capture).
• Refactor likely needed first:
• Modules requiring input() or current time/random at construction/runtime, and modules tightly coupled to global mutable state.

Risks

• Legacy import style (from X import Y) with no __init__.py packages can make test imports brittle.
• High print/side-effect density makes assertions noisy unless captured/isolated.
• Shared class-level mutable state can cause order-dependent tests.
• Thread-related singleton behavior can create flaky tests if tested concurrently.

Validation Steps

1. Run one new test module at a time (smallest relevant first).
2. Run package-local test subset.
3. Run full tests/ discovery.
4. Run agreed type-check on changed modules only.
5. Report all failures explicitly with module-level triage.

Rollback Strategy

• Keep changes in small PRs per package.
• If regressions appear, revert only the latest package PR (tests + annotations for that package), leaving prior stable PRs intact.
• Avoid cross-package refactors to keep rollback surgical.

Out-of-Scope Items

• Converting repo into a fully packaged/installable distribution.
• Large architectural refactors or redesign of pattern implementations.
• Adding runtime dependencies beyond an agreed dev-only type checker.
• Rewriting all 510 Python files in one pass.

First Recommended Small PR Scope

• state/gumball only:
• Add focused unittest for state transitions/refill behavior.
• Fill only missing annotations and tighten obvious type clarity, no logic rewrite.
• Initial targets: state/gumball/GumballMachine.py, plus new tests/state/test_gumball_machine.py.

[github-actions]

Codex Implementation

• Branch: codex/test
• Issue: Add type annotations and unit tests. #4
• Changes pushed: yes

Implemented the first approved small PR scope from .artifacts/codex-plan.md (state/gumball only), with minimal diff and no logic refactor.

Changes made

• Added missing type annotations in GumballMachine.py:
  • StringBuffer.__init__ -> None and self.ls: list[str]
  • GumballMachine.__repr__ -> str at line 104
• Added unittest bootstrap files:
  • tests/init.py
  • tests/state/init.py
• Added focused tests in test_gumball_machine.py:
  • initial states (with/without inventory)
  • vend transition after insert+turn
  • sold-out transition on last gumball
  • eject-quarter behavior
  • refill behavior

Validation run (smallest-first)

1. python -m unittest -v tests.state.test_gumball_machine
   • Result: Ran 6 tests ... OK
2. python -m unittest discover -s tests -p 'test_*.py' -v
   • Result: Ran 6 tests ... OK

No test failures occurred.