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

{claude_code_generator-0.5.3/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.3
+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

{claude_code_generator-0.5.3 → 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.3"
+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.3 → 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.3
+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

{claude_code_generator-0.5.3 → 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.3 → 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.3"
+__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.3 → 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"

claude_code_generator-0.5.3/src/code_generator/cli.py

@@ -1,53 +0,0 @@
-"""Entry-point CLI for code-generator.
-
-Exposes a Typer application with --version and subcommands:
-init, status, generate, review.
-"""
-
-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
-
-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)