claude-code-generator 0.6.3__tar.gz → 0.6.4__tar.gz

{claude_code_generator-0.6.3/src/claude_code_generator.egg-info → claude_code_generator-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.6.3
+Version: 0.6.4
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.6.3 → claude_code_generator-0.6.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.6.3"
+version = "0.6.4"
 description = "Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file."
 readme = "README.md"
 license = { text = "MIT" }

{claude_code_generator-0.6.3 → claude_code_generator-0.6.4/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.6.3
+Version: 0.6.4
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.6.3 → claude_code_generator-0.6.4}/src/claude_code_generator.egg-info/SOURCES.txt

@@ -210,6 +210,7 @@ tests/test_phase5.py
 tests/test_phase5_precommit.py
 tests/test_phase6.py
 tests/test_phase65_budget.py
+tests/test_phase6_5_endpoint_source.py
 tests/test_phase6_5_integration.py
 tests/test_phase6_5_integration_cycle2.py
 tests/test_phase6_5_port_isolation.py
@@ -217,6 +218,7 @@ tests/test_phase6_5_prompt.py
 tests/test_phase6_5_prompt_snapshot.py
 tests/test_phase6_5_run.py
 tests/test_phase6_5_state.py
+tests/test_phase6_5_t4_timeout.py
 tests/test_phase6_5_tiers.py
 tests/test_phase7.py
 tests/test_phase8_access_control.py
@@ -268,5 +270,6 @@ tests/test_tier_selector.py
 tests/test_tier_t3.py
 tests/test_tier_t3_pass_rate.py
 tests/test_tier_t4.py
+tests/test_tier_t4_port_discovery.py
 tests/test_version.py
 tests/test_vigil.py

{claude_code_generator-0.6.3 → claude_code_generator-0.6.4}/src/code_generator/git_ops.py

@@ -91,6 +91,35 @@ def git_current_branch(cwd: Path) -> str:
     return result.stdout.strip()
 
 
+def git_default_branch(cwd: Path) -> str:
+    """Return the remote's default branch name (best effort).
+
+    Resolves ``refs/remotes/origin/HEAD`` (set by ``git clone`` /
+    ``git remote set-head``). Falls back to ``"main"`` when the symbolic
+    ref is absent — e.g. a freshly ``git init``-ed repo with no remote,
+    or a sentinel ``.git`` directory in tests. This function never
+    raises: callers use it only to decide whether the current branch is
+    the integration branch, and a wrong guess degrades to the safe
+    (status-quo) path.
+
+    Args:
+        cwd: Directory to run git in.
+
+    Returns:
+        Default branch name, or ``"main"`` when it cannot be determined.
+    """
+    result = _run(
+        ["git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+        cwd=cwd,
+        check=False,
+    )
+    ref = result.stdout.strip()
+    if result.returncode == 0 and ref:
+        # ``origin/main`` → ``main``
+        return ref.split("/", 1)[1] if ref.startswith("origin/") else ref
+    return "main"
+
+
 def git_has_staged(cwd: Path) -> bool:
     """Return ``True`` when the git index has staged changes.
 

{claude_code_generator-0.6.3 → claude_code_generator-0.6.4}/src/code_generator/orchestrator/phase6_5_verify.py

@@ -96,6 +96,17 @@ _POLL_INTERVAL_S = 0.5
 # emit, so ``_is_timeout`` can re-classify without false positives.
 _TIMEOUT_RETURNCODE = 124
 
+# T4 (container lifecycle) needs its own budget, NOT the per-probe
+# ``TierConfig.timeout_s`` (5.0s) that suits the fast T0/T1/T2 HTTP checks.
+# ``docker compose up -d --build`` of a real stack (image build + a
+# postgres healthcheck with ``interval: 10s`` and an api ``start-period:
+# 40s``) cannot finish in 5s — binding command_timeout_s to 5.0 made T4
+# fail by construction on every docker-shipping project even when the
+# container lifecycle was reproducibly green (~45s warm). These bound the
+# docker subprocess and the health wait respectively.
+_T4_COMMAND_TIMEOUT_S = 600.0  # cold `compose up --build` can take minutes
+_T4_BOOT_TIMEOUT_S = 180.0  # must exceed api start-period + db healthcheck
+
 
 class VerificationFailed(RuntimeError):
     """Raised when Phase 6.5 exhausts its repair budget with red tiers."""
@@ -700,14 +711,29 @@ async def run(
     # stable across the retry loop; re-checked per attempt by the guard (#2).
     verify_port = _alloc_free_port()
 
-    for attempt in range(max_retries):
+    # Loop runs max_retries+1 verifications and at most max_retries repair
+    # passes. The trailing verification re-probes the app *after* the final
+    # repair so an agent fix on the last attempt is actually counted —
+    # without it the loop discarded a green post-repair state and raised
+    # VerificationFailed against the pre-repair red state (0.6.4 incident).
+    for attempt in range(max_retries + 1):
         budget.check(turns_consumed=attempt, logger=logger)
         progress = _begin_attempt(target, progress, attempt)
         save_state(state_path, state)
         if attempt > 0:
             _soft_reset_for_repair(project_dir, attempt + 1)
 
-        verify_port = _ensure_verify_port(verify_port, logger=logger)
+        # Pre-flight squatter guard (#2) applies ONLY before the first
+        # attempt — at that point no repair-pass server exists, so an open
+        # port is a genuine foreign listener and rerolling protects the
+        # retry budget. On attempts >=1 the port is *expected* to be open:
+        # the repair agent boots the app and deliberately leaves it alive
+        # so the orchestrator's authoritative T2 re-probe hits it. Rerolling
+        # then would move the port out from under the agent's live server
+        # every attempt and guarantee a T2 miss (the actual 0.6.3 failure).
+        # The ephemeral port (#1) already eliminates the real collision.
+        if attempt == 0:
+            verify_port = _ensure_verify_port(verify_port, logger=logger)
         outcome = _run_tiers(
             project_dir,
             state,
@@ -729,6 +755,9 @@ async def run(
         event = detector.check()
         if event is not None:
             raise VerificationFailed(f"Phase 6.5 deviation: {event.detail}")
+        if attempt == max_retries:
+            # Repair budget exhausted; the trailing verify already ran above.
+            break
         await _run_repair_pass(
             failure_report=_format_failure_report(outcome, attempt + 1, max_retries),
             shared_client=shared_client,
@@ -805,13 +834,37 @@ def _run_tiers(
     _record_skips(target, progress, spec, attempt, logger=logger)
     save_state(state_path, state)
 
+    # When T1 actually skipped at runtime (no in-process listener) AND T4
+    # is enabled (docker present), T2's in-process probe is structurally
+    # doomed: no service binds the ephemeral verify port. Probing anyway
+    # yields an identical ConnectError every attempt and
+    # DeviationDetector.stuck_tier trips before the repair agent can stand
+    # up the container. T4 already replays the T2 contract against the
+    # published container port, so T2 is genuinely redundant on this
+    # codepath — skip it at runtime.
+    t4_enabled = any(t.tier_id == "T4" and t.enabled for t in spec.tiers)
+    t1_skipped_at_runtime = False
+
     for tier in spec.tiers:
         if not tier.enabled:
             continue
+        if tier.tier_id == "T2" and t1_skipped_at_runtime and t4_enabled:
+            _record_runtime_skip(
+                target,
+                progress,
+                tier_id="T2",
+                reason="T1 skipped (no in-process entry_cmd); T4 covers verification",
+                attempt=attempt,
+                logger=logger,
+            )
+            save_state(state_path, state)
+            continue
         runner = _tier_runner(tier, project_dir, env, base_url, endpoints)
         if runner is None:
             continue
         result = runner()
+        if tier.tier_id == "T1" and result.skipped:
+            t1_skipped_at_runtime = True
         _record_outcome(target, progress, tier.tier_id, result, attempt)
         if detector is not None and not result.skipped:
             detector.record(
@@ -850,6 +903,35 @@ def _persist_spec_for_attempt(project_dir: Path, requirements_path: Path, port:
     return spec
 
 
+def _record_runtime_skip(
+    target: Any,
+    progress: Phase65Progress,
+    *,
+    tier_id: str,
+    reason: str,
+    attempt: int,
+    logger: logging.Logger,
+) -> None:
+    """Mark *tier_id* as skipped at runtime and surface the reason on progress.
+
+    Mirrors :func:`_record_skips` for spec-declared skips, but for tiers
+    whose skip is decided dynamically (e.g. T2 when T1 has no entry_cmd).
+    """
+    if tier_id not in progress.tiers_skipped:
+        progress.tiers_skipped.append(tier_id)
+    progress.skip_reasons[tier_id] = reason
+    logger.warning("Phase 6.5: tier %s skipped at runtime — %s", tier_id, reason)
+    updated = Phase65Progress(
+        attempt=attempt,
+        last_tier=progress.last_tier,
+        tiers_passed=list(progress.tiers_passed),
+        tiers_failed=list(progress.tiers_failed),
+        tiers_skipped=list(progress.tiers_skipped),
+        skip_reasons=dict(progress.skip_reasons),
+    )
+    target.phase6_5 = updated
+
+
 def _record_skips(
     target: Any,
     progress: Phase65Progress,
@@ -914,15 +996,50 @@ def _tier_runner(
             env=env,
             base_url=base_url,
             endpoints=endpoints,
-            command_timeout_s=timeout_s,
+            command_timeout_s=_T4_COMMAND_TIMEOUT_S,
+            boot_timeout_s=_T4_BOOT_TIMEOUT_S,
         )
     return None
 
 
 def _load_endpoints(requirements_path: Path) -> list[Endpoint]:
+    """T2 endpoint set, sourced from the Oracle's T2-classified acceptance
+    criteria — NOT a whole-file scrape.
+
+    Whole-file ``extract_endpoints_from_requirements`` scrapes every
+    backticked ``/token`` from every ``- [ ]`` checkbox, including
+    implementation-task bullets. On the optimizer that promoted the
+    Angular routing line ``- [ ] Update routing to `/portfolio-builder` …``
+    to a backend GET probe, which 404s by design (it is a frontend page on
+    :4300, not a FastAPI route) and exhausted the Phase 6.5 retry budget on
+    a verifier false positive while the app was healthy.
+
+    The Oracle already scopes endpoint detection to the acceptance-criteria
+    sections and is the contract the prompt orders the *agent* to trust
+    ("do not re-classify by hand"); the orchestrator's programmatic T2 must
+    trust the same source. Zero T2 criteria → empty list → T2 is
+    health-only. Lazy import mirrors :func:`_load_oracle_report_text`
+    (criteria_oracle imports back into this module).
+    """
     if not requirements_path.exists():
         return []
-    return extract_endpoints_from_requirements(requirements_path.read_text(encoding="utf-8"))
+    from code_generator.orchestrator.criteria_oracle import build_oracle_report
+
+    report = build_oracle_report(requirements_path.read_text(encoding="utf-8"))
+    endpoints: list[Endpoint] = []
+    seen: set[tuple[str, str]] = set()
+    for criterion in (*report.global_criteria, *report.scope_criteria):
+        if criterion.tier != "T2":
+            continue
+        # Reconstruct the bullet exactly as criteria_oracle._has_endpoint
+        # does, so the orchestrator and Oracle agree byte-for-byte.
+        for endpoint in extract_endpoints_from_requirements(f"- [ ] {criterion.text}\n"):
+            key = (endpoint.method, endpoint.path)
+            if key in seen:
+                continue
+            seen.add(key)
+            endpoints.append(endpoint)
+    return endpoints
 
 
 def _record_outcome(

{claude_code_generator-0.6.3 → claude_code_generator-0.6.4}/src/code_generator/orchestrator/phase7_commit.py

@@ -143,18 +143,23 @@ class Phase7CommitMessageError(RuntimeError):
 def _synthesize_fallback(cycle_name: str, issues_closed: str) -> str:
     """Build a deterministic conventional-commit message from orchestrator metadata.
 
+    The closing footer emits one ``Closes #<n>`` line per issue — a
+    GitHub-recognized auto-close trailer.  ``Closes #1, #2`` would only close
+    ``#1``; the keyword must repeat on every line.
+
     Args:
         cycle_name: Name of the active cycle (empty string for single mode).
         issues_closed: Comma-separated issue refs (e.g. ``"#1, #2"``) or ``"none"``.
 
     Returns:
-        A valid conventional-commit string, optionally with a ``Closed issues`` footer.
+        A valid conventional-commit string, optionally with a ``Closes #<n>`` footer.
     """
     scope = f"({cycle_name})" if cycle_name else ""
     subject = f"chore{scope}: cycle complete"
     if issues_closed == "none":
         return subject
-    return f"{subject}\n\nClosed issues: {issues_closed}"
+    footer = "\n".join(f"Closes {ref}" for ref in issues_closed.split(", "))
+    return f"{subject}\n\n{footer}"
 
 
 def _validate_commit_message(msg: str) -> None:

{claude_code_generator-0.6.3 → claude_code_generator-0.6.4}/src/code_generator/orchestrator/phase8_finalization.py

@@ -11,7 +11,15 @@ After the Opus 4.7 confirmation prompt returns, the orchestrator:
 3. When ``state.repo`` is ``None`` (local-only dev), records
    ``ci_status="skipped"``, ticks ``professionalized``, and returns —
    single-repo development is not penalized for a missing remote.
-4. When the repo is configured, dispatches
+4. When the repo is configured but no workflow can fire for the working
+   branch (e.g. main-only triggers while the orchestrator works a
+   feature branch), the green-gate is structurally unobservable:
+   records ``ci_status="skipped"``, ticks ``professionalized``, and
+   returns — polling here would only spin until the circuit breaker
+   aborts an otherwise-complete run. Same philosophy as the no-remote
+   skip. The default branch is excluded from this guard so a genuine
+   misconfiguration on the integration branch still surfaces.
+5. Otherwise dispatches
    :func:`phase8_repair_loop.run_ci_green_gate`. On ``"green"``: the
    cycle-2 semver tag (if any) is relocated to the new HEAD via
    :func:`git_ops.git_tag_move`, and ``professionalized`` is ticked. On
@@ -36,6 +44,7 @@ from code_generator.git_ops import (
     git_add_all,
     git_commit,
     git_current_branch,
+    git_default_branch,
     git_pull_rebase,
     git_push,
     git_tag_list,
@@ -156,6 +165,41 @@ def _handle_skipped(
     _tick_professionalized_for_closed_issues(state, cycle, state_path, logger)
 
 
+def _handle_unobservable(
+    state: State,
+    cycle: CycleState | None,
+    state_path: Path,
+    logger: logging.Logger,
+) -> None:
+    """No workflow can fire for the working branch → skip the gate cleanly."""
+    logger.warning(
+        "Phase 8: no workflow triggers on push to the working branch "
+        "(default branch differs); CI green-gate is structurally unobservable "
+        "— recording skipped instead of polling until the circuit breaker "
+        "aborts an otherwise-complete run."
+    )
+    _tick_professionalized_for_closed_issues(state, cycle, state_path, logger)
+
+
+def _ci_green_gate_unobservable(project_dir: Path) -> bool:
+    """``True`` when no pushed workflow can fire for the working branch.
+
+    The green-gate polls GitHub for a workflow run on the just-pushed
+    branch SHA. When the repo's workflows only trigger on the default
+    branch (or PRs to it) and the orchestrator is working a feature
+    branch, *no run is ever created* — the old behaviour polled until the
+    circuit breaker opened and aborted an otherwise-complete pipeline.
+    Treat that as a structural skip (same philosophy as ``state.repo is
+    None``): the default branch itself is excluded so a genuine
+    misconfiguration on the integration branch still surfaces.
+    """
+    branch = git_current_branch(project_dir)
+    default = git_default_branch(project_dir)
+    if branch == default:
+        return False
+    return not phase8_workflow_gen.ref_has_triggerable_ci(project_dir, branch)
+
+
 async def _run_ci_green_gate(
     *,
     repo: RepoInfo,
@@ -221,22 +265,27 @@ async def run(
         _handle_skipped(state, cycle, state_path, logger)
     else:
         _commit_workflows(project_dir, logger)
-        outcome = await _run_ci_green_gate(
-            repo=state.repo,
-            project_dir=project_dir,
-            state_path=state_path,
-            state=state,
-            cycle=cycle,
-            runner_module=runner_module,
-            effective_model=effective_model,
-            logger=logger,
-        )
-        target.phase8.ci_status = outcome
-        _state.save_state(state_path, state)
-        if outcome == "green":
-            _handle_green(project_dir, state, cycle, state_path, logger)
+        if _ci_green_gate_unobservable(project_dir):
+            target.phase8.ci_status = "skipped"
+            _state.save_state(state_path, state)
+            _handle_unobservable(state, cycle, state_path, logger)
         else:
-            _handle_exhausted(logger)
+            outcome = await _run_ci_green_gate(
+                repo=state.repo,
+                project_dir=project_dir,
+                state_path=state_path,
+                state=state,
+                cycle=cycle,
+                runner_module=runner_module,
+                effective_model=effective_model,
+                logger=logger,
+            )
+            target.phase8.ci_status = outcome
+            _state.save_state(state_path, state)
+            if outcome == "green":
+                _handle_green(project_dir, state, cycle, state_path, logger)
+            else:
+                _handle_exhausted(logger)
 
     target.phase8.status = "ok"
     target.phase8.finished_at = utc_now_isoformat()

{claude_code_generator-0.6.3 → claude_code_generator-0.6.4}/src/code_generator/orchestrator/phase8_workflow_gen.py

@@ -97,6 +97,7 @@ name: ci
     branches: [main]
   pull_request:
     branches: [main]
+  workflow_dispatch: {}
 jobs:
   ci:
     runs-on: ubuntu-latest
@@ -117,6 +118,7 @@ name: ci
     branches: [main]
   pull_request:
     branches: [main]
+  workflow_dispatch: {}
 jobs:
   ci:
     runs-on: ubuntu-latest
@@ -137,6 +139,7 @@ name: ci
     branches: [main]
   pull_request:
     branches: [main]
+  workflow_dispatch: {}
 jobs:
   ci:
     runs-on: ubuntu-latest
@@ -229,6 +232,95 @@ def _build_workflow(project_dir: Path, rel_path: str, fresh_content: str) -> Wor
     return WorkflowFile(rel_path=rel_path, content=fresh_content)
 
 
+# ---------------------------------------------------------------------------
+# Trigger observability
+# ---------------------------------------------------------------------------
+
+_BRANCH_TOKEN = re.compile(r"[\"']?([A-Za-z0-9._/\-\*]+)[\"']?")
+
+
+def _push_branches(workflow_text: str) -> tuple[list[str], bool]:
+    """Return ``(branch_tokens, has_unfiltered_push)`` for a workflow body.
+
+    Heuristic (not a YAML parse — consistent with
+    :func:`scan_for_guardrail_violations`). ``has_unfiltered_push`` is
+    ``True`` when a ``push`` trigger exists with no ``branches:`` filter
+    (such a workflow fires on every branch).
+    """
+    if not re.search(r"^\s*push\s*:", workflow_text, re.MULTILINE) and not re.search(
+        r"^\s*\"?on\"?\s*:\s*push\s*$", workflow_text, re.MULTILINE
+    ):
+        return [], False
+
+    tokens: list[str] = []
+    # Inline form:  branches: [main, release/*]
+    for m in re.finditer(r"branches\s*:\s*\[([^\]]*)\]", workflow_text):
+        tokens += [t for t in _BRANCH_TOKEN.findall(m.group(1)) if t]
+    # Block form:
+    #   branches:
+    #     - main
+    for block in re.finditer(
+        r"branches\s*:\s*\n((?:\s*-\s*[^\n]+\n?)+)", workflow_text
+    ):
+        for line in block.group(1).splitlines():
+            mt = re.match(r"\s*-\s*[\"']?([A-Za-z0-9._/\-\*]+)[\"']?", line)
+            if mt:
+                tokens.append(mt.group(1))
+
+    has_branches_filter = "branches" in workflow_text or "tags" in workflow_text
+    bare_push = bool(re.search(r"^\s*\"?on\"?\s*:\s*push\s*$", workflow_text, re.MULTILINE))
+    unfiltered = bare_push or not has_branches_filter
+    return tokens, unfiltered
+
+
+def _branch_matches(token: str, branch: str) -> bool:
+    """``True`` when a workflow branch *token* would select *branch*."""
+    if token in ("*", "**"):
+        return True
+    if token == branch:
+        return True
+    return token.endswith("/*") and branch.startswith(token[:-1])
+
+
+def ref_has_triggerable_ci(project_dir: Path, branch: str) -> bool:
+    """Return ``True`` when **a push to** *branch* will produce a run.
+
+    Scans ``.github/workflows/*.y{a,}ml``. A workflow counts when it has
+    an unfiltered ``push`` trigger or a ``push`` branch filter that
+    selects *branch* (exact, ``*``/``**``, or ``prefix/*``).
+
+    ``workflow_dispatch`` deliberately does **not** count: it only makes
+    a workflow *manually* invocable, it does not auto-create a run when
+    the orchestrator pushes the branch. Phase 8's green-gate pushes then
+    polls for a run on that SHA, so a dispatch-only workflow is just as
+    unobservable as a main-only one.
+
+    Returns ``False`` when the workflows directory is absent or empty, or
+    when no workflow fires on a push to *branch*. Phase 8 uses this to
+    detect a structurally unobservable CI green-gate (e.g. main-only
+    triggers while the orchestrator works a feature branch) and degrade
+    to ``ci_status="skipped"`` instead of polling until the circuit
+    breaker aborts an otherwise-complete run.
+    """
+    wf_dir = project_dir / ".github" / "workflows"
+    if not wf_dir.is_dir():
+        return False
+    files = sorted(p for p in wf_dir.iterdir() if p.suffix in (".yml", ".yaml"))
+    if not files:
+        return False
+    for path in files:
+        try:
+            text = path.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        tokens, unfiltered = _push_branches(text)
+        if unfiltered:
+            return True
+        if any(_branch_matches(tok, branch) for tok in tokens):
+            return True
+    return False
+
+
 # ---------------------------------------------------------------------------
 # Guardrail scanner
 # ---------------------------------------------------------------------------