agentic-dev-loop 1.0.0a4__tar.gz → 1.0.0a5__tar.gz

{agentic_dev_loop-1.0.0a4 → agentic_dev_loop-1.0.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a4
+Version: 1.0.0a5
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0

{agentic_dev_loop-1.0.0a4 → agentic_dev_loop-1.0.0a5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a4"
+version = "1.0.0a5"
 description = "Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase."
 readme = "README.md"
 requires-python = ">=3.12"

{agentic_dev_loop-1.0.0a4 → agentic_dev_loop-1.0.0a5}/src/agentic_dev_loop/cli.py

@@ -9,10 +9,10 @@ import importlib.metadata
 import sys
 from pathlib import Path
 
-from .config import load_config
+from .config import PipelineConfig, load_config
 from .dryrun import dry_run
 from .isolation import clean_stamps, isolation_state_dir
-from .registry import default_registry, load_extensions
+from .registry import Registry, default_registry, load_extensions
 
 
 def _version() -> str:
@@ -63,11 +63,21 @@ def _core_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def build_parser(cfg_path) -> argparse.ArgumentParser:
-    """The full parser for one pipeline: core flags + loader-contributed."""
+def _registry_for(cfg_path: Path) -> tuple[Registry, PipelineConfig]:
+    """Load the pipeline config and build ONE registry with its extensions.
+    The CLI loads extensions exactly once per process: the SDK tool registry
+    is process-global and BR-3 rejects a second registration of any tool
+    name, so the registry built here is passed down to the dry run and the
+    run path instead of being rebuilt."""
     cfg = load_config(cfg_path)
     registry = default_registry()
     load_extensions(cfg.extensions, registry)
+    return registry, cfg
+
+
+def build_parser(cfg_path) -> argparse.ArgumentParser:
+    """The full parser for one pipeline: core flags + loader-contributed."""
+    registry, _ = _registry_for(cfg_path)
     parser = _core_parser()
     for loader in registry.document_loaders:
         loader.add_cli_args(parser)
@@ -84,20 +94,23 @@ def main(argv: list[str] | None = None) -> int:
         # handles --help and the missing-positional error itself (both exit).
         _core_parser().parse_args(argv)
         return 2  # unreachable — parse_args exits first
-    args = build_parser(known.pipeline).parse_args(argv)
+    registry, cfg = _registry_for(known.pipeline)
+    parser = _core_parser()
+    for loader in registry.document_loaders:
+        loader.add_cli_args(parser)
+    args = parser.parse_args(argv)
     if args.clean_stamps:
-        cfg = load_config(args.pipeline)
         state = isolation_state_dir(cfg)
         removed = clean_stamps(state)
         print(f"Removed {removed} cached provision stamp(s) from "
               f"{state / 'stamps'}", flush=True)
         return 0
     if args.dry_run:
-        return dry_run(args.pipeline, args)
+        return dry_run(args.pipeline, args, registry)
     # The run path alone needs the heavy graph/SDK imports — defer so a
     # dry run, --clean-stamps, and --help stay side-effect free.
     from .graph import run_pipeline
-    success, _attempts = run_pipeline(args.pipeline, args)
+    success, _attempts = run_pipeline(args.pipeline, args, registry=registry)
     if not success:
         print("agentic-dev-loop: pipeline failed — exiting with code 1",
               file=sys.stderr)

{agentic_dev_loop-1.0.0a4 → agentic_dev_loop-1.0.0a5}/src/agentic_dev_loop/dryrun.py

@@ -101,16 +101,22 @@ def _print_summary(cfg_path: Path, cfg: PipelineConfig, subject: str,
     print("dry run complete — nothing executed")
 
 
-def dry_run(cfg_path, args) -> int:
+def dry_run(cfg_path, args, registry: Registry | None = None) -> int:
     """Validate a pipeline end-to-end without executing it, and print a
     summary plan. Returns 0 on a clean load; any load failure propagates as
-    the existing loud error (the CLI exits 1)."""
+    the existing loud error (the CLI exits 1).
+
+    `registry` carries extensions already loaded by the CLI (build_parser
+    loads them once for loader-contributed flags; a second load would
+    collide with the SDK's process-global tool registry). When absent —
+    programmatic calls — the registry is built here."""
     cfg_path = Path(cfg_path)
     cfg = load_config(cfg_path)
     base = cfg_path.resolve().parent
 
-    registry = default_registry()
-    load_extensions(cfg.extensions, registry)
+    if registry is None:
+        registry = default_registry()
+        load_extensions(cfg.extensions, registry)
 
     _validate_agents(cfg, base / cfg.agents_dir)
     _validate_actions(cfg, registry)

{agentic_dev_loop-1.0.0a4 → agentic_dev_loop-1.0.0a5}/src/agentic_dev_loop/graph.py

@@ -80,7 +80,8 @@ def build_graph(runtime: Runtime, checkpointer=None):
 
 
 
-def run_pipeline(cfg_path, args, *, viz_bus=None) -> tuple[bool, int]:
+def run_pipeline(cfg_path, args, *, viz_bus=None,
+                 registry: Registry | None = None) -> tuple[bool, int]:
     """Load a pipeline YAML, resolve docs via the selected document loader,
     and run the graph to completion. Returns (success, attempts) — the
     public API, yosk's `construct`/`resume_loop` equivalent.
@@ -95,14 +96,20 @@ def run_pipeline(cfg_path, args, *, viz_bus=None) -> tuple[bool, int]:
     events; the CLI path additionally serves the HTTP page and opens the
     browser, and the process exits as soon as the loop completes.
     Programmatic Namespaces without a ``no_viz`` attribute get no server —
-    default-on is a CLI-layer concern."""
+    default-on is a CLI-layer concern.
+
+    ``registry`` carries extensions already loaded by the CLI (it loads them
+    once, for loader-contributed flags; a second load would collide with the
+    SDK's process-global tool registry). When absent — programmatic calls —
+    the registry is built here."""
     cfg_path = Path(cfg_path)
     cfg = load_config(cfg_path)
     base = cfg_path.resolve().parent
     max_attempts = getattr(args, "max_attempts", None) or cfg.max_attempts
 
-    registry = default_registry()
-    load_extensions(cfg.extensions, registry)
+    if registry is None:
+        registry = default_registry()
+        load_extensions(cfg.extensions, registry)
 
     state_dir = Path(cfg.state_dir).expanduser()
     if not state_dir.is_absolute():

{agentic_dev_loop-1.0.0a4 → agentic_dev_loop-1.0.0a5}/src/agentic_dev_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a4
+Version: 1.0.0a5
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0

{agentic_dev_loop-1.0.0a4 → agentic_dev_loop-1.0.0a5}/tests/test_cli.py

@@ -361,3 +361,24 @@ class TestRefreshAndCleanStamps:
         assert main(["clean.yaml", "--clean-stamps"]) == 0
         assert not (state / "stamps" / "k1").exists()
         assert not (state / "stamps" / "k2").exists()
+
+    def test_clean_stamps_loads_config_once(self, repo, tmp_path, monkeypatch):
+        # --clean-stamps must reuse the config _registry_for already loaded;
+        # loading it twice is the pre-fix behaviour this guards against.
+        import agentic_dev_loop.cli as cli_mod
+
+        state = tmp_path / "iso-state"
+        yaml = CLEAN_YAML.format(iso_state_dir=str(state))
+        write_pipeline(repo, "clean.yaml", yaml)
+
+        real = cli_mod.load_config
+        calls = []
+
+        def counting(cfg_path):
+            calls.append(cfg_path)
+            return real(cfg_path)
+
+        monkeypatch.setattr(cli_mod, "load_config", counting)
+
+        assert cli_mod.main(["clean.yaml", "--clean-stamps"]) == 0
+        assert len(calls) == 1

{agentic_dev_loop-1.0.0a4 → agentic_dev_loop-1.0.0a5}/tests/test_dry_run.py

@@ -111,6 +111,17 @@ class TestDryRun:
         assert "test [command]" in out
         assert "network=True" in out
 
+    def test_tool_extension_loads_once(self, repo, capsys):
+        """A tool-registering extension must survive the CLI's two-phase load:
+        build_parser loads extensions once for loader-contributed flags, and
+        the dry run reuses that registry instead of loading again (a second
+        load collides with the SDK's process-global tool registry and BR-3
+        rejects it — the pre-fix double-load crash)."""
+        (repo / "tool.yaml").write_text(
+            "extensions:\n  - sample_ext:DryRunProbeExtension\n" + DRY_RUN_YAML)
+        assert main(["tool.yaml", "--dry-run", "--plan", "plan.md"]) == 0
+        assert "dry run complete" in capsys.readouterr().out
+
 
 class TestDryRunHelp:
     def test_help_documents_flag(self, repo, capsys):

{agentic_dev_loop-1.0.0a4 → agentic_dev_loop-1.0.0a5}/tests/test_graph.py

@@ -17,7 +17,7 @@ import pytest
 from agentic_dev_loop.config import load_config
 from agentic_dev_loop.graph import build_graph, run_pipeline
 from agentic_dev_loop.llm import build_llm
-from agentic_dev_loop.registry import default_registry, load_extensions
+from agentic_dev_loop.registry import Registry, default_registry, load_extensions
 from agentic_dev_loop.stages import Runtime
 from agentic_dev_loop.viz import VizBus
 
@@ -483,3 +483,15 @@ class TestSandboxLifecycle:
         with pytest.raises(KeyboardInterrupt):
             run_pipeline("pipeline.yaml", args())
         assert fake_sandbox.closed
+
+def test_run_pipeline_registry_param_typed():
+    """API-consistency guard: run_pipeline's registry kwarg must carry the
+    same Registry | None annotation as dry_run's — an untyped param is how
+    this drifted once already."""
+    import inspect
+    from typing import get_type_hints
+
+    sig = inspect.signature(run_pipeline)
+    ann = sig.parameters["registry"].annotation
+    assert ann is not inspect.Parameter.empty
+    assert get_type_hints(run_pipeline)["registry"] == Registry | None