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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.5.2"
+version = "0.5.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.5.2 → claude_code_generator-0.5.4/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.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
@@ -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.4}/src/claude_code_generator.egg-info/SOURCES.txt

@@ -99,6 +99,7 @@ tests/test_bench_fixture.py
 tests/test_bench_regression.py
 tests/test_changelog.py
 tests/test_claude_md.py
+tests/test_cli_io_logging.py
 tests/test_client_lifecycle.py
 tests/test_comments.py
 tests/test_commit_message.py

{claude_code_generator-0.5.2 → claude_code_generator-0.5.4}/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.4"

claude_code_generator-0.5.4/src/code_generator/cli.py

@@ -0,0 +1,93 @@
+"""Entry-point CLI for code-generator.
+
+Exposes a Typer application with --version and subcommands:
+init, status, generate, review.
+
+At import time we reconfigure stdout/stderr for line-buffered output (the
+in-process equivalent of ``PYTHONUNBUFFERED=1``) so phase progress shows up
+in the terminal in real time even when the CLI is invoked through buffering
+wrappers like ``conda run``.  The default log level is DEBUG, overridable
+via the ``LOGLEVEL`` env var (set ``LOGLEVEL=INFO`` for the quieter behaviour
+that earlier 0.4.x releases shipped with).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import sys
+from typing import Annotated
+
+import typer
+
+import code_generator
+from code_generator.commands.bench import bench_app
+from code_generator.commands.generate import generate_app
+from code_generator.commands.init import init_command
+from code_generator.commands.optimize import optimize_command
+from code_generator.commands.review import review_command
+from code_generator.commands.status import status_command
+
+
+def _configure_io_and_logging() -> None:
+    """Force line-buffered stdout/stderr and apply LOGLEVEL (default DEBUG).
+
+    Equivalent to running with ``PYTHONUNBUFFERED=1 LOGLEVEL=DEBUG`` from
+    the shell, but always-on so users don't have to remember the env vars.
+    Both can still be overridden externally — ``LOGLEVEL=INFO`` reverts to
+    the quieter default.
+
+    Idempotent: safe to call multiple times (the ``reconfigure`` call is a
+    no-op when line buffering is already on, and ``logging.basicConfig`` is
+    a no-op once root handlers exist).
+    """
+    # Line-buffered console I/O: each ``\n`` flushes immediately. The
+    # `contextlib.suppress` wrapper handles streams that are already buffered
+    # as needed or are non-seekable (e.g. piped to another process).
+    for stream in (sys.stdout, sys.stderr):
+        with contextlib.suppress(AttributeError, OSError):
+            stream.reconfigure(line_buffering=True)  # type: ignore[union-attr]
+
+    level_name = os.environ.get("LOGLEVEL", "DEBUG").upper()
+    level = getattr(logging, level_name, logging.DEBUG)
+    logging.getLogger("code_generator").setLevel(level)
+
+
+_configure_io_and_logging()
+
+app = typer.Typer(
+    name="code-generator",
+    help="Orchestrate Claude Code to generate whole projects from a requirements.md.",
+    no_args_is_help=True,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"code-generator {code_generator.__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def root(
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-V",
+            help="Show version and exit.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = None,
+) -> None:
+    """code-generator CLI root."""
+
+
+app.add_typer(bench_app, name="bench")
+app.add_typer(generate_app, name="generate")
+app.command(name="init")(init_command)
+app.command(name="status")(status_command)
+app.command(name="optimize")(optimize_command)
+app.command(name="review")(review_command)

{claude_code_generator-0.5.2 → claude_code_generator-0.5.4}/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.4}/src/code_generator/logging_setup.py

@@ -3,9 +3,14 @@
 Each phase gets its own log file under .code-generator/logs/ and a shared
 RichHandler for colour-coded console output. The setup is idempotent: calling
 setup_phase_logger() twice for the same phase does not duplicate handlers.
+
+The default console level is DEBUG, overridable via the ``LOGLEVEL`` env var
+(``LOGLEVEL=INFO`` for the quieter behaviour shipped in 0.4.x). The file
+handler always writes at DEBUG so post-mortem inspection retains everything.
 """
 
 import logging
+import os
 from pathlib import Path
 
 from rich.logging import RichHandler
@@ -13,11 +18,19 @@ from rich.logging import RichHandler
 _FILE_FORMATTER = logging.Formatter("%(asctime)s %(levelname)s %(message)s")
 
 
+def _resolve_level(default: int = logging.DEBUG) -> int:
+    """Read the ``LOGLEVEL`` env var, falling back to *default* on miss/typo."""
+    name = os.environ.get("LOGLEVEL", "").upper()
+    if not name:
+        return default
+    return getattr(logging, name, default)
+
+
 def setup_phase_logger(
     phase_name: str,
     project_dir: Path,
     *,
-    level: int = logging.INFO,
+    level: int | None = None,
 ) -> logging.Logger:
     """Configure and return a logger for a single orchestration phase.
 
@@ -29,21 +42,23 @@ def setup_phase_logger(
         phase_name: Short identifier for the phase (e.g. ``"planning"``).
         project_dir: Root directory of the user's project. Logs are written to
             ``project_dir / ".code-generator" / "logs" / f"{phase_name}.log"``.
-        level: Python logging level applied to the logger. Defaults to INFO.
+        level: Python logging level applied to the logger.  Defaults to the
+            value of the ``LOGLEVEL`` env var, or DEBUG if unset.
 
     Returns:
         Configured :class:`logging.Logger` instance.
     """
+    effective_level = level if level is not None else _resolve_level()
     logger = logging.getLogger(f"code_generator.phase.{phase_name}")
 
     if _already_configured(logger):
         return logger
 
-    logger.setLevel(level)
+    logger.setLevel(effective_level)
     logger.propagate = False
 
     _attach_file_handler(logger, project_dir, phase_name)
-    _attach_rich_handler(logger)
+    _attach_rich_handler(logger, effective_level)
 
     return logger
 
@@ -67,9 +82,9 @@ def _attach_file_handler(
     logger.addHandler(handler)
 
 
-def _attach_rich_handler(logger: logging.Logger) -> None:
+def _attach_rich_handler(logger: logging.Logger, level: int) -> None:
     handler = RichHandler(show_time=False, show_path=False)
-    handler.setLevel(logging.INFO)
+    handler.setLevel(level)
     logger.addHandler(handler)
 
 

claude_code_generator-0.5.4/tests/test_cli_io_logging.py

@@ -0,0 +1,73 @@
+"""Tests for ``cli._configure_io_and_logging``.
+
+The CLI applies two startup defaults so users don't need to set env vars
+manually: line-buffered stdout/stderr (PYTHONUNBUFFERED=1) and DEBUG-level
+console logging (LOGLEVEL=DEBUG).  Both are overridable via ``LOGLEVEL``.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from code_generator import cli
+
+if TYPE_CHECKING:
+    import pytest
+
+
+class TestConfigureIoAndLogging:
+    """``_configure_io_and_logging`` sets sane defaults at CLI startup."""
+
+    def test_default_loglevel_is_debug(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """When ``LOGLEVEL`` is unset, the code_generator namespace uses DEBUG."""
+        monkeypatch.delenv("LOGLEVEL", raising=False)
+        cli._configure_io_and_logging()
+
+        assert logging.getLogger("code_generator").level == logging.DEBUG
+
+    def test_loglevel_env_overrides_default(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """``LOGLEVEL=INFO`` reverts to the quieter 0.4.x default."""
+        monkeypatch.setenv("LOGLEVEL", "INFO")
+        cli._configure_io_and_logging()
+
+        assert logging.getLogger("code_generator").level == logging.INFO
+
+    def test_unknown_loglevel_falls_back_to_debug(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Typos like ``LOGLEVEL=NOPE`` fall back to DEBUG, not raise."""
+        monkeypatch.setenv("LOGLEVEL", "NOPE")
+        cli._configure_io_and_logging()
+
+        assert logging.getLogger("code_generator").level == logging.DEBUG
+
+    def test_idempotent_when_called_twice(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Calling twice in a row does not raise (e.g. on `--version` re-import)."""
+        monkeypatch.setenv("LOGLEVEL", "INFO")
+        cli._configure_io_and_logging()
+        cli._configure_io_and_logging()  # must not raise
+
+        assert logging.getLogger("code_generator").level == logging.INFO
+
+    def test_stdout_is_line_buffered_after_setup(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """sys.stdout / sys.stderr must report line buffering after setup.
+
+        On terminals where stdout is already line-buffered, this is a no-op;
+        when running through a pipe (default block buffering), the call
+        switches the stream to line buffering.
+        """
+        import sys
+
+        monkeypatch.delenv("LOGLEVEL", raising=False)
+        cli._configure_io_and_logging()
+
+        # `line_buffering` attribute exists on TextIOWrapper. After
+        # reconfigure(line_buffering=True), it must be True.  Streams that
+        # don't support the attribute (rare) are intentionally tolerated.
+        for stream in (sys.stdout, sys.stderr):
+            buffering = getattr(stream, "line_buffering", None)
+            if buffering is not None:
+                assert buffering is True, f"{stream} not line-buffered"