claude-code-generator 0.5.0__tar.gz → 0.5.2__tar.gz

{claude_code_generator-0.5.0/src/claude_code_generator.egg-info → claude_code_generator-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.5.0
+Version: 0.5.2
 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.5.0 → claude_code_generator-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.5.0"
+version = "0.5.2"
 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.5.0 → claude_code_generator-0.5.2/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.5.0
+Version: 0.5.2
 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.5.0 → claude_code_generator-0.5.2}/src/code_generator/__init__.py

@@ -1,3 +1,3 @@
 """code-generator: orchestrator CLI for end-to-end project generation."""
 
-__version__ = "0.5.0"
+__version__ = "0.5.2"

{claude_code_generator-0.5.0 → claude_code_generator-0.5.2}/src/code_generator/commands/_dispatch.py

@@ -37,23 +37,67 @@ __all__ = ["dispatch_async", "dispatch_orchestrator"]
 _GRAPHIFY_TIMEOUT = int(os.environ.get("CODE_GENERATOR_GRAPHIFY_TIMEOUT", "600"))
 
 
+def _graphify_command(project_dir: Path) -> list[str]:
+    """Return the right graphify CLI invocation based on whether a prior graph exists.
+
+    Graphify's CLI parser treats the first positional arg as a *subcommand*
+    name (``install``, ``query``, ``update``, ...) and only falls through to
+    "build the graph for this directory" when the arg looks like a relative
+    path (``.``, ``./src``).  Passing an absolute path like
+    ``/Volumes/External SSD/optimizer`` makes graphify exit 1 with
+    ``error: unknown command '<path>'``.  We always pass ``.`` and rely on
+    ``subprocess.run(cwd=project_dir)`` to anchor it.
+
+    Graphify's ``--update`` flag *requires* an existing ``graph.json`` to
+    merge into ("re-extract only changed files, merge into existing graph").
+    On a virgin project tree it fails with exit 1.  We detect that case by
+    looking for ``graphify-out/graph.json`` and skipping ``--update`` on the
+    first run.
+
+    Args:
+        project_dir: Project root directory.
+
+    Returns:
+        The argv list to pass to ``subprocess.run``.
+    """
+    graph_json = project_dir / "graphify-out" / "graph.json"
+    base = ["graphify", ".", "--no-viz"]
+    if graph_json.exists():
+        base.append("--update")
+    return base
+
+
+def _decode_stderr(stderr: bytes | str | None) -> str:
+    """Decode subprocess stderr to a short single-line string for logging."""
+    if stderr is None:
+        return ""
+    text = stderr.decode("utf-8", errors="replace") if isinstance(stderr, bytes) else stderr
+    text = text.strip().replace("\n", " | ")
+    return text[:500]
+
+
 def _compute_and_persist_graph_report(project_dir: Path, log: logging.Logger) -> None:
     """Build the codebase graph via graphify and persist it to memories.
 
-    Invokes ``graphify <project_dir> --update --no-viz`` to (re)build
-    ``graphify-out/GRAPH_REPORT.md`` and copies the resulting markdown into
+    Invokes the ``graphify`` CLI to (re)build ``graphify-out/GRAPH_REPORT.md``
+    and copies the resulting markdown into
     ``.code-generator/memories/cycle-repo-map.md`` so Phases 0, 1, 2 can read
     it via :func:`code_generator.memory.read_cycle_repomap`.
 
-    Incremental builds rely on graphify's own SHA256-keyed cache in
-    ``graphify-out/cache/`` — the ``--update`` flag short-circuits unchanged
-    files, so repeated invocations on a clean tree are nearly free. We
-    deliberately do *not* call ``graphify check-update`` because it is an
-    undocumented subcommand (see graphify issue #277) and not part of the
-    stable CLI surface.
+    Two modes:
+
+    - **First run** (no ``graphify-out/graph.json``): full build via
+      ``graphify <path> --no-viz``.  ``--update`` is *not* added because it
+      requires a prior graph to merge into — passing it on a virgin tree
+      makes graphify exit 1.
+    - **Incremental** (graph.json exists): ``graphify <path> --update
+      --no-viz``.  Graphify's SHA256-keyed cache in ``graphify-out/cache/``
+      keeps subsequent runs cheap.
 
     Falls back to :data:`code_generator.memory.REPOMAP_FALLBACK` on any
     failure (binary missing, timeout, non-zero exit, missing report file).
+    Stderr from graphify is captured and logged at WARN level on failure so
+    the user can diagnose without re-running by hand.
 
     Auth: graphify inherits the parent process env (Claude Code OAuth
     subscription). Do **not** strip ``ANTHROPIC_*`` here — graphify is a
@@ -79,7 +123,7 @@ def _compute_and_persist_graph_report(project_dir: Path, log: logging.Logger) ->
         _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
         return
 
-    cmd = ["graphify", str(project_dir), "--update", "--no-viz"]
+    cmd = _graphify_command(project_dir)
     try:
         log.info("graph-report: building (cmd=%s)", " ".join(cmd))
         subprocess.run(  # noqa: S603
@@ -89,8 +133,20 @@ def _compute_and_persist_graph_report(project_dir: Path, log: logging.Logger) ->
             capture_output=True,
             check=True,
         )
-    except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
-        log.warning("graph-report: graphify subprocess failed (%s); using fallback", exc)
+    except subprocess.CalledProcessError as exc:
+        stderr = _decode_stderr(exc.stderr)
+        log.warning(
+            "graph-report: graphify exited %d; using fallback. stderr: %s",
+            exc.returncode,
+            stderr or "<empty>",
+        )
+        _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
+        return
+    except subprocess.TimeoutExpired as exc:
+        log.warning(
+            "graph-report: graphify timed out after %ss; using fallback",
+            exc.timeout,
+        )
         _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
         return
     except (FileNotFoundError, OSError) as exc:

{claude_code_generator-0.5.0 → claude_code_generator-0.5.2}/tests/test_dispatch_graph_report.py

@@ -4,18 +4,12 @@ The helper shells out to the ``graphify`` CLI to (re)build
 ``graphify-out/GRAPH_REPORT.md`` and copies the result into
 ``.code-generator/memories/cycle-repo-map.md``.
 
-Graphify's own SHA256-keyed cache makes repeated invocations cheap on
-unchanged source, so we always invoke ``graphify <path> --update --no-viz``
-and rely on the tool's internal incrementalism (no ``check-update`` call —
-that subcommand is undocumented; see graphify issue #277).
-
-These tests cover each branch:
-- happy path (writes the report into memories)
-- binary missing (writes fallback)
-- timeout (writes fallback)
-- non-zero exit (writes fallback)
-- missing report after a successful exit (writes fallback)
-- inherited-env: no env stripping (graphify uses parent OAuth)
+Two invocation modes:
+- **First run** (no ``graphify-out/graph.json``): ``graphify <path> --no-viz``
+- **Incremental** (graph.json exists): ``graphify <path> --update --no-viz``
+
+The ``--update`` flag merges into an existing graph and fails on a virgin
+tree, so we detect first-run via ``graph.json`` existence.
 """
 
 from __future__ import annotations
@@ -44,10 +38,10 @@ def _read_persisted(project_dir: Path) -> str:
 class TestGraphReportBuild:
     """Behaviour of _compute_and_persist_graph_report under each branch."""
 
-    def test_happy_path_builds_and_persists_report(
+    def test_first_run_uses_full_build_without_update_flag(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
-        """Successful graphify run copies GRAPH_REPORT.md into memories/."""
+        """First run (no graph.json) invokes `graphify <path> --no-viz` (no --update)."""
         monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
 
         commands_seen: list[list[str]] = []
@@ -63,13 +57,47 @@ class TestGraphReportBuild:
 
         _dispatch._compute_and_persist_graph_report(tmp_path, _logger())
 
-        # Single invocation: no check-update, just the build.
         assert len(commands_seen) == 1
         assert commands_seen[0][0] == "graphify"
-        assert "--update" in commands_seen[0]
         assert "--no-viz" in commands_seen[0]
+        assert "--update" not in commands_seen[0], (
+            "first run must not pass --update — graphify exits 1 without an existing graph"
+        )
+        # Path arg must be relative '.', not absolute — graphify's CLI parser
+        # rejects absolute paths as 'unknown command' (verified on graphify 0.5.x).
+        assert "." in commands_seen[0], "must pass relative '.' so graphify accepts it"
+        assert str(tmp_path) not in commands_seen[0], (
+            "absolute path would trigger graphify's `unknown command` error"
+        )
         assert _read_persisted(tmp_path) == "# fresh report\n"
 
+    def test_incremental_run_uses_update_flag(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """When graph.json already exists, the run uses `--update --no-viz`."""
+        report_dir = tmp_path / "graphify-out"
+        report_dir.mkdir(parents=True)
+        (report_dir / "graph.json").write_text("{}", encoding="utf-8")
+        (report_dir / "GRAPH_REPORT.md").write_text("# old report\n", encoding="utf-8")
+
+        monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
+
+        commands_seen: list[list[str]] = []
+
+        def _fake_run(cmd: list[str], **_kwargs: object) -> subprocess.CompletedProcess[bytes]:
+            commands_seen.append(cmd)
+            (report_dir / "GRAPH_REPORT.md").write_text("# updated report\n", encoding="utf-8")
+            return subprocess.CompletedProcess(args=cmd, returncode=0, stdout=b"", stderr=b"")
+
+        monkeypatch.setattr(_dispatch.subprocess, "run", _fake_run)
+
+        _dispatch._compute_and_persist_graph_report(tmp_path, _logger())
+
+        assert len(commands_seen) == 1
+        assert "--update" in commands_seen[0]
+        assert "--no-viz" in commands_seen[0]
+        assert _read_persisted(tmp_path) == "# updated report\n"
+
     def test_binary_missing_writes_fallback(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
@@ -119,6 +147,27 @@ class TestGraphReportBuild:
 
         assert _read_persisted(tmp_path) == REPOMAP_FALLBACK
 
+    def test_failure_logs_graphify_stderr(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """On non-zero exit, graphify's stderr must appear in the log warning."""
+        monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
+
+        stderr_msg = b"Error: graph.json not found, cannot --update"
+
+        def _fake_run(cmd: list[str], **_kwargs: object) -> subprocess.CompletedProcess[bytes]:
+            raise subprocess.CalledProcessError(returncode=1, cmd=cmd, stderr=stderr_msg)
+
+        monkeypatch.setattr(_dispatch.subprocess, "run", _fake_run)
+
+        with caplog.at_level("WARNING"):
+            _dispatch._compute_and_persist_graph_report(tmp_path, _logger())
+
+        warnings = [r.getMessage() for r in caplog.records if r.levelname == "WARNING"]
+        assert any("graph.json not found" in w for w in warnings), (
+            f"stderr from graphify must be in the log warning. Got: {warnings}"
+        )
+
     def test_missing_report_after_success_writes_fallback(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None: