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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.5.2
+Version: 0.5.3
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT
@@ -55,17 +55,28 @@ cd code-generator && pip install -e ".[dev]"
 
 ### Optional: codebase graph (graphify)
 
-Phases 0, 1, and 2 inject a knowledge-graph report from [graphify](https://github.com/safishamsi/graphify) for richer code orientation. When the binary is missing, the orchestrator falls back to a sentinel string and continues.
+Phases 0, 1, and 2 inject a knowledge-graph report from [graphify](https://github.com/safishamsi/graphify) for richer code orientation. When the graph is missing, the orchestrator falls back to a sentinel string and continues — nothing breaks.
+
+**Install the CLI** (required to use graphify at all):
 
 ```bash
 pipx install graphifyy   # CLI binary is `graphify`
 ```
 
+**Seed the graph (one-time, per project)**: graphify's full LLM-driven build runs through the `/graphify` slash-command inside an AI assistant — *not* through the shell binary. From inside Claude Code (or any other graphify-supported assistant) run:
+
+```
+/graphify .
+```
+
+This produces `graphify-out/graph.json` and `graphify-out/GRAPH_REPORT.md`.
+
+**Subsequent code-generator runs** will automatically refresh the graph with `graphify update .` (AST-only, no LLM cost). Doc / paper / image changes still need a manual `/graphify .` re-run inside your assistant.
+
 Add to your project's `.gitignore`:
 
 ```
-graphify-out/manifest.json
-graphify-out/cost.json
+graphify-out/
 ```
 
 ## Authentication

{claude_code_generator-0.5.2 → claude_code_generator-0.5.3}/README.md

@@ -17,17 +17,28 @@ cd code-generator && pip install -e ".[dev]"
 
 ### Optional: codebase graph (graphify)
 
-Phases 0, 1, and 2 inject a knowledge-graph report from [graphify](https://github.com/safishamsi/graphify) for richer code orientation. When the binary is missing, the orchestrator falls back to a sentinel string and continues.
+Phases 0, 1, and 2 inject a knowledge-graph report from [graphify](https://github.com/safishamsi/graphify) for richer code orientation. When the graph is missing, the orchestrator falls back to a sentinel string and continues — nothing breaks.
+
+**Install the CLI** (required to use graphify at all):
 
 ```bash
 pipx install graphifyy   # CLI binary is `graphify`
 ```
 
+**Seed the graph (one-time, per project)**: graphify's full LLM-driven build runs through the `/graphify` slash-command inside an AI assistant — *not* through the shell binary. From inside Claude Code (or any other graphify-supported assistant) run:
+
+```
+/graphify .
+```
+
+This produces `graphify-out/graph.json` and `graphify-out/GRAPH_REPORT.md`.
+
+**Subsequent code-generator runs** will automatically refresh the graph with `graphify update .` (AST-only, no LLM cost). Doc / paper / image changes still need a manual `/graphify .` re-run inside your assistant.
+
 Add to your project's `.gitignore`:
 
 ```
-graphify-out/manifest.json
-graphify-out/cost.json
+graphify-out/
 ```
 
 ## Authentication

{claude_code_generator-0.5.2 → claude_code_generator-0.5.3}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.5.2
+Version: 0.5.3
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT
@@ -55,17 +55,28 @@ cd code-generator && pip install -e ".[dev]"
 
 ### Optional: codebase graph (graphify)
 
-Phases 0, 1, and 2 inject a knowledge-graph report from [graphify](https://github.com/safishamsi/graphify) for richer code orientation. When the binary is missing, the orchestrator falls back to a sentinel string and continues.
+Phases 0, 1, and 2 inject a knowledge-graph report from [graphify](https://github.com/safishamsi/graphify) for richer code orientation. When the graph is missing, the orchestrator falls back to a sentinel string and continues — nothing breaks.
+
+**Install the CLI** (required to use graphify at all):
 
 ```bash
 pipx install graphifyy   # CLI binary is `graphify`
 ```
 
+**Seed the graph (one-time, per project)**: graphify's full LLM-driven build runs through the `/graphify` slash-command inside an AI assistant — *not* through the shell binary. From inside Claude Code (or any other graphify-supported assistant) run:
+
+```
+/graphify .
+```
+
+This produces `graphify-out/graph.json` and `graphify-out/GRAPH_REPORT.md`.
+
+**Subsequent code-generator runs** will automatically refresh the graph with `graphify update .` (AST-only, no LLM cost). Doc / paper / image changes still need a manual `/graphify .` re-run inside your assistant.
+
 Add to your project's `.gitignore`:
 
 ```
-graphify-out/manifest.json
-graphify-out/cost.json
+graphify-out/
 ```
 
 ## Authentication

{claude_code_generator-0.5.2 → claude_code_generator-0.5.3}/src/code_generator/__init__.py

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

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

@@ -37,34 +37,12 @@ __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
+_SETUP_HINT = (
+    "graph-report: graphify-out/graph.json not found — run `/graphify .` once "
+    "inside Claude Code (or another graphify-compatible assistant) to seed the "
+    "knowledge graph. After that, code-generator will keep it fresh "
+    "automatically with `graphify update .`. Using fallback for now."
+)
 
 
 def _decode_stderr(stderr: bytes | str | None) -> str:
@@ -77,35 +55,37 @@ def _decode_stderr(stderr: bytes | str | None) -> str:
 
 
 def _compute_and_persist_graph_report(project_dir: Path, log: logging.Logger) -> None:
-    """Build the codebase graph via graphify and persist it to memories.
+    """Refresh the codebase graph via graphify and persist the report.
+
+    Graphify's shell CLI does **not** support a "build" subcommand — the full
+    LLM-driven build only happens through the ``/graphify`` slash-command
+    inside an AI assistant (Claude Code, Codex, Cursor, etc.).  The shell
+    binary only supports maintenance subcommands like ``update``, ``watch``,
+    ``query``.
 
-    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`.
+    Strategy:
 
-    Two modes:
+    1. If ``graphify-out/graph.json`` does **not** exist, the user has never
+       seeded the graph.  Log a one-time setup hint, write the fallback
+       sentinel, and return — do not call subprocess.  The user must run
+       ``/graphify .`` in their assistant once to seed it.
 
-    - **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.
+    2. If it exists, run ``graphify update .`` (cwd=project_dir).  This is
+       AST-only re-extraction, no LLM cost, fast on cached files.  It
+       refreshes ``graph.json`` and ``GRAPH_REPORT.md``.  Doc / paper /
+       image changes are *not* picked up — for those the user must run
+       ``/graphify .`` again in their assistant.
 
     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
-    user-facing dev tool that piggybacks on whichever assistant invoked it.
-    The startup ``env.assert_safe_environment()`` check (CLAUDE.md
-    non-negotiable #1) already guarantees no API-key vars are present in the
-    process environment when the orchestrator runs on the Anthropic Max
-    path, so passing the inherited env to graphify is safe.
+    Auth: graphify inherits the parent process env. ``graphify update`` is
+    AST-only and makes no LLM calls, so OAuth context is irrelevant on this
+    codepath — but we still don't strip ``ANTHROPIC_*`` because the startup
+    ``env.assert_safe_environment()`` check (CLAUDE.md non-negotiable #1)
+    already guarantees those vars are absent on the Anthropic Max path.
 
     Args:
         project_dir: Project root directory (graphify writes ``graphify-out/``
@@ -114,6 +94,7 @@ def _compute_and_persist_graph_report(project_dir: Path, log: logging.Logger) ->
     """
     memories_dir = project_dir / ".code-generator" / "memories"
     report_path = project_dir / "graphify-out" / "GRAPH_REPORT.md"
+    graph_json = project_dir / "graphify-out" / "graph.json"
 
     if shutil.which("graphify") is None:
         log.warning(
@@ -123,9 +104,14 @@ 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_command(project_dir)
+    if not graph_json.exists():
+        log.info(_SETUP_HINT)
+        _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
+        return
+
+    cmd = ["graphify", "update", "."]
     try:
-        log.info("graph-report: building (cmd=%s)", " ".join(cmd))
+        log.info("graph-report: refreshing (cmd=%s)", " ".join(cmd))
         subprocess.run(  # noqa: S603
             cmd,
             cwd=project_dir,

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

@@ -1,15 +1,14 @@
 """Tests for ``commands._dispatch._compute_and_persist_graph_report``.
 
-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``.
-
-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.
+Graphify's shell CLI only supports maintenance — the full LLM-driven build
+runs through the ``/graphify`` slash-command inside an AI assistant.  Our
+orchestrator therefore:
+
+- writes the fallback sentinel and emits a one-time setup hint when
+  ``graphify-out/graph.json`` does not exist (user must seed via the
+  slash-command first);
+- runs ``graphify update .`` (AST-only refresh, no LLM cost) when the
+  graph already exists.
 """
 
 from __future__ import annotations
@@ -35,46 +34,46 @@ def _read_persisted(project_dir: Path) -> str:
     return target.read_text(encoding="utf-8") if target.exists() else ""
 
 
+def _seed_graph(project_dir: Path) -> Path:
+    """Pre-create ``graphify-out/graph.json`` so subprocess paths run."""
+    graphify_out = project_dir / "graphify-out"
+    graphify_out.mkdir(parents=True, exist_ok=True)
+    (graphify_out / "graph.json").write_text("{}", encoding="utf-8")
+    (graphify_out / "GRAPH_REPORT.md").write_text("# seed report\n", encoding="utf-8")
+    return graphify_out
+
+
 class TestGraphReportBuild:
     """Behaviour of _compute_and_persist_graph_report under each branch."""
 
-    def test_first_run_uses_full_build_without_update_flag(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    def test_no_graph_seed_writes_fallback_and_emits_setup_hint(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
     ) -> None:
-        """First run (no graph.json) invokes `graphify <path> --no-viz` (no --update)."""
+        """When graph.json doesn't exist, write fallback + emit `/graphify .` hint, no subprocess."""
         monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
 
-        commands_seen: list[list[str]] = []
+        called: list[object] = []
 
-        def _fake_run(cmd: list[str], **_kwargs: object) -> subprocess.CompletedProcess[bytes]:
-            commands_seen.append(cmd)
-            report_dir = tmp_path / "graphify-out"
-            report_dir.mkdir(parents=True, exist_ok=True)
-            (report_dir / "GRAPH_REPORT.md").write_text("# fresh report\n", encoding="utf-8")
-            return subprocess.CompletedProcess(args=cmd, returncode=0, stdout=b"", stderr=b"")
+        def _fake_run(*a: object, **k: object) -> subprocess.CompletedProcess[bytes]:
+            called.append(a)
+            raise AssertionError("subprocess.run must not be called when graph.json is missing")
 
         monkeypatch.setattr(_dispatch.subprocess, "run", _fake_run)
 
-        _dispatch._compute_and_persist_graph_report(tmp_path, _logger())
+        with caplog.at_level("INFO"):
+            _dispatch._compute_and_persist_graph_report(tmp_path, _logger())
 
-        assert len(commands_seen) == 1
-        assert commands_seen[0][0] == "graphify"
-        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 called == []
+        assert _read_persisted(tmp_path) == REPOMAP_FALLBACK
+        messages = [r.getMessage() for r in caplog.records]
+        assert any("/graphify" in m for m in messages), (
+            "must emit a hint telling the user to seed via /graphify"
         )
-        assert _read_persisted(tmp_path) == "# fresh report\n"
 
-    def test_incremental_run_uses_update_flag(
+    def test_seeded_graph_runs_update_subcommand(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
-        """When graph.json already exists, the run uses `--update --no-viz`."""
+        """When graph.json exists, run `graphify update .` (AST-only refresh)."""
         report_dir = tmp_path / "graphify-out"
         report_dir.mkdir(parents=True)
         (report_dir / "graph.json").write_text("{}", encoding="utf-8")
@@ -93,9 +92,9 @@ class TestGraphReportBuild:
 
         _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 commands_seen == [["graphify", "update", "."]], (
+            f"expected `graphify update .`; got {commands_seen}"
+        )
         assert _read_persisted(tmp_path) == "# updated report\n"
 
     def test_binary_missing_writes_fallback(
@@ -120,7 +119,8 @@ class TestGraphReportBuild:
     def test_timeout_writes_fallback(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
-        """A `TimeoutExpired` from the build subprocess writes the fallback."""
+        """A `TimeoutExpired` from the update subprocess writes the fallback."""
+        _seed_graph(tmp_path)
         monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
 
         def _fake_run(cmd: list[str], **_kwargs: object) -> subprocess.CompletedProcess[bytes]:
@@ -135,7 +135,8 @@ class TestGraphReportBuild:
     def test_called_process_error_writes_fallback(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
-        """Non-zero exit from the build subprocess writes the fallback."""
+        """Non-zero exit from the update subprocess writes the fallback."""
+        _seed_graph(tmp_path)
         monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
 
         def _fake_run(cmd: list[str], **_kwargs: object) -> subprocess.CompletedProcess[bytes]:
@@ -151,9 +152,10 @@ class TestGraphReportBuild:
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
     ) -> None:
         """On non-zero exit, graphify's stderr must appear in the log warning."""
+        _seed_graph(tmp_path)
         monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
 
-        stderr_msg = b"Error: graph.json not found, cannot --update"
+        stderr_msg = b"Error: corrupted graph.json"
 
         def _fake_run(cmd: list[str], **_kwargs: object) -> subprocess.CompletedProcess[bytes]:
             raise subprocess.CalledProcessError(returncode=1, cmd=cmd, stderr=stderr_msg)
@@ -164,7 +166,7 @@ class TestGraphReportBuild:
             _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), (
+        assert any("corrupted graph.json" in w for w in warnings), (
             f"stderr from graphify must be in the log warning. Got: {warnings}"
         )
 
@@ -172,10 +174,14 @@ class TestGraphReportBuild:
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
         """If graphify exits 0 but the report file is missing, write fallback."""
+        graphify_out = _seed_graph(tmp_path)
+        # Remove the seed report so the read fails after success.
+        (graphify_out / "GRAPH_REPORT.md").unlink()
+
         monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
 
         def _fake_run(cmd: list[str], **_kwargs: object) -> subprocess.CompletedProcess[bytes]:
-            # Exit 0 but never create the report file.
+            # Exit 0 but don't (re)create the report file.
             return subprocess.CompletedProcess(args=cmd, returncode=0, stdout=b"", stderr=b"")
 
         monkeypatch.setattr(_dispatch.subprocess, "run", _fake_run)
@@ -187,20 +193,15 @@ class TestGraphReportBuild:
     def test_no_env_argument_passed_to_subprocess(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
-        """Graphify must inherit the parent env (no `env=` arg) for OAuth.
-
-        Documented in the function's docstring: stripping ANTHROPIC_* would
-        break graphify's LLM extraction. The startup env-safety check
-        guarantees no API-key vars are in the process env on the Max path.
-        """
+        """Graphify must inherit the parent env (no `env=` arg)."""
+        graphify_out = _seed_graph(tmp_path)
         monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
 
         captured_kwargs: dict[str, object] = {}
 
         def _fake_run(cmd: list[str], **kwargs: object) -> subprocess.CompletedProcess[bytes]:
             captured_kwargs.update(kwargs)
-            (tmp_path / "graphify-out").mkdir(parents=True, exist_ok=True)
-            (tmp_path / "graphify-out" / "GRAPH_REPORT.md").write_text("ok\n", encoding="utf-8")
+            (graphify_out / "GRAPH_REPORT.md").write_text("ok\n", encoding="utf-8")
             return subprocess.CompletedProcess(args=cmd, returncode=0, stdout=b"", stderr=b"")
 
         monkeypatch.setattr(_dispatch.subprocess, "run", _fake_run)
@@ -215,6 +216,7 @@ class TestGraphReportBuild:
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
     ) -> None:
         """An OSError from subprocess.run (e.g., permission denied) writes fallback."""
+        _seed_graph(tmp_path)
         monkeypatch.setattr(_dispatch.shutil, "which", lambda _name: "/usr/bin/graphify")
 
         def _fake_run(cmd: list[str], **_kwargs: object) -> subprocess.CompletedProcess[bytes]: