agentic-dev-loop 0.10.4__tar.gz → 0.11.0__tar.gz

{agentic_dev_loop-0.10.4/src/agentic_dev_loop.egg-info → agentic_dev_loop-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 0.10.4
+Version: 0.11.0
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -492,8 +492,10 @@ before.
 `agentic-dev-loop doctor --fast` is the per-run gate the trigger runs first.
 Hard failures abort the run (engine pin mismatch, engine runtime availability,
 API version, git repo, `.env*` files); warnings print and continue. `doctor
---json` emits the same results mechanically. The trigger repairs a pin/install
-mismatch exactly once, then fails hard.
+--json` emits the same results mechanically. On a hard failure the trigger
+runs `agentic-dev-loop upgrade` exactly once: it installs the latest release
+with pipx and rewrites `.engine-version` to match, then the run fails hard if
+doctor still fails.
 
 A consumer repo needs a pipeline file and the agent files it names, both
 committed before the first run (the host-boundary check refuses dirty tooling,

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.11.0}/README.md

@@ -448,8 +448,10 @@ before.
 `agentic-dev-loop doctor --fast` is the per-run gate the trigger runs first.
 Hard failures abort the run (engine pin mismatch, engine runtime availability,
 API version, git repo, `.env*` files); warnings print and continue. `doctor
---json` emits the same results mechanically. The trigger repairs a pin/install
-mismatch exactly once, then fails hard.
+--json` emits the same results mechanically. On a hard failure the trigger
+runs `agentic-dev-loop upgrade` exactly once: it installs the latest release
+with pipx and rewrites `.engine-version` to match, then the run fails hard if
+doctor still fails.
 
 A consumer repo needs a pipeline file and the agent files it names, both
 committed before the first run (the host-boundary check refuses dirty tooling,

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.11.0}/pyproject.toml

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

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.11.0}/src/agentic_dev_loop/core/profiles/__init__.py

@@ -81,18 +81,16 @@ def parse_version(text: str) -> tuple[int, int, int, int, int]:
     return (int(major), int(minor), int(patch), _RANK[pre], int(num))
 
 
-def check_engine_min(engine_min: str, installed: str,
-                     latest: str | None = None) -> None:
+def check_engine_min(engine_min: str, installed: str) -> None:
     """Raise unless ``installed`` satisfies ``engine_min``.
 
-    ``latest`` is substituted into the fix line by the caller (doctor); when
-    omitted the floor itself is used.
+    The fix line names the upgrade command: it installs the latest release,
+    which always satisfies the floor.
     """
     if parse_version(installed) < parse_version(engine_min):
-        target = latest or engine_min
         raise ProfileError(
             f"profile requires engine >= {engine_min}; installed {installed}. "
-            f'Upgrade: pipx install --force "agentic-dev-loop=={target}"')
+            "Upgrade: run agentic-dev-loop upgrade")
 
 
 def _data_dir():

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.11.0}/src/agentic_dev_loop/engine/cli.py

@@ -171,6 +171,9 @@ def main(argv: list[str] | None = None) -> int:
     if argv and argv[0] == "doctor":
         from .onboarding.doctor import run_doctor
         return run_doctor(argv[1:])
+    if argv and argv[0] == "upgrade":
+        from .onboarding.upgrade import run_upgrade
+        return run_upgrade(argv[1:])
     probe = argparse.ArgumentParser(add_help=False)
     probe.add_argument("pipeline", type=Path, nargs="?")
     _add_version_flag(probe)

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.11.0}/src/agentic_dev_loop/engine/graph.py

@@ -275,13 +275,15 @@ def _run_pipeline(cfg, base, registry, state_dir, max_attempts, args, viz_bus,
         if bus is None and not getattr(args, "no_viz", True):
             start_state = initial if initial is not None \
                 else graph.get_state(config).values
-            topology, nodes = viz.topology_mermaid(cfg)
+            topology = viz.topology_graph(cfg)
             bus = viz.VizBus()
             if args.viz_port:
                 kill_listeners_on_port(args.viz_port, match="agentic-dev-loop",
                                        cwd=runtime.workspace)
             httpd, _thread = viz.serve_viz(
-                bus, topology, start_state["subject"], args.viz_port, nodes)
+                bus, topology["mermaid"], start_state["subject"],
+                args.viz_port, topology["nodes"], topology["flow"],
+                topology["edges"])
             bound = httpd.server_address[1]
             url = f"http://127.0.0.1:{bound}"
             if args.viz_port and bound != args.viz_port:

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.11.0}/src/agentic_dev_loop/engine/onboarding/checks.py

@@ -25,6 +25,7 @@ __all__ = ["Check", "HostProbes", "collect_checks"]
 ENV_WHITELIST = frozenset({".env.example", ".env.template", ".env.sample"})
 MIN_API = (1, 43)
 PYPI_URL = "https://pypi.org/pypi/agentic-dev-loop/json"
+FIX_UPGRADE = "run agentic-dev-loop upgrade"
 
 
 @dataclass(frozen=True)
@@ -171,12 +172,12 @@ def collect_checks(profile: Profile | None, pipeline, installed: str,
     if pin is None:
         checks.append(_hard(
             "pin", False, f"no engine pin file at {pin_path}",
-            "run agentic-dev-loop init (or write agentic-dev-loop/.engine-version)"))
+            FIX_UPGRADE))
     else:
         checks.append(_hard(
             "pin", pin == installed,
             f"installed {installed}, pin {pin}",
-            f'pipx install --force "agentic-dev-loop=={pin}"'))
+            FIX_UPGRADE))
         latest = probes.latest_release()
         if latest is None:
             checks.append(_hard("pin-latest", True,
@@ -189,7 +190,7 @@ def collect_checks(profile: Profile | None, pipeline, installed: str,
             checks.append(_hard(
                 "pin-latest", not behind,
                 f"pin {pin} is behind latest release {latest}",
-                f'pipx install --force "agentic-dev-loop=={latest}"'))
+                FIX_UPGRADE))
 
     present = probes.docker_present()
     checks.append(_hard(

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.11.0}/src/agentic_dev_loop/engine/onboarding/templates/trigger-agentic-dev-loop.sh

@@ -5,7 +5,6 @@ ROOT="$(cd "$(dirname "$0")" && pwd)"
 cd "$ROOT"
 
 PIPELINE="$ROOT/agentic-dev-loop/pipeline.yaml"
-PIN_FILE="$ROOT/agentic-dev-loop/.engine-version"
 
 # Optional host environment file. The default lives outside the workspace so
 # secrets never enter the repo; set AGENTIC_DEV_LOOP_ENV_FILE to override.
@@ -25,24 +24,17 @@ if ! command -v agentic-dev-loop >/dev/null 2>&1; then
   exit 1
 fi
 
-if [[ ! -f "$PIN_FILE" ]]; then
-  echo "error: missing engine pin file: $PIN_FILE" >&2
-  echo "       run 'agentic-dev-loop init' in this repo to write it" >&2
-  exit 1
-fi
-PIN="$(cat "$PIN_FILE")"
-
 # doctor --fast is the per-run gate: hard failures abort, warnings continue.
-# A pin/install mismatch is repaired exactly once, then the run fails hard.
+# A failing gate is repaired exactly once by upgrading to the latest engine
+# release (which also rewrites the project pin), then the run fails hard.
 if ! agentic-dev-loop doctor --fast; then
-  echo "error: doctor --fast failed - repairing the engine pin $PIN once" >&2
-  if ! pipx install --force "agentic-dev-loop==$PIN"; then
-    echo "error: could not install agentic-dev-loop==$PIN" >&2
-    echo "       the install may not be pipx-managed, or the index is unreachable" >&2
+  echo "doctor --fast failed - upgrading to the latest engine release" >&2
+  if ! agentic-dev-loop upgrade; then
+    echo "error: agentic-dev-loop upgrade failed" >&2
     exit 1
   fi
   if ! agentic-dev-loop doctor --fast; then
-    echo "error: doctor --fast still fails after repairing the engine pin" >&2
+    echo "error: doctor --fast still fails after upgrading the engine" >&2
     exit 1
   fi
 fi

agentic_dev_loop-0.11.0/src/agentic_dev_loop/engine/onboarding/upgrade.py

@@ -0,0 +1,76 @@
+"""``agentic-dev-loop upgrade``: install the latest engine and sync the pin.
+
+Installs the latest release with pipx and rewrites
+``agentic-dev-loop/.engine-version`` to the installed version, so the host
+install and the committed pin converge in one action.
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from agentic_dev_loop.core.profiles import ProfileError, parse_version
+
+__all__ = ["run_upgrade"]
+
+
+def _resolve(name: str, env: dict | None) -> str | None:
+    if env is not None:
+        return shutil.which(name, path=env.get("PATH", ""))
+    return shutil.which(name)
+
+
+def run_upgrade(argv: list[str], *, workspace: Path | None = None,
+                env: dict | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="agentic-dev-loop upgrade",
+        description="Install the latest engine release and rewrite the "
+                    "project pin file to match.")
+    parser.parse_args(argv)
+
+    root = Path(workspace or Path.cwd()).resolve()
+    pipx = _resolve("pipx", env)
+    if pipx is None:
+        print("error: pipx is not on PATH; the engine install must be "
+              "pipx-managed", file=sys.stderr)
+        return 1
+
+    result = subprocess.run(
+        [pipx, "install", "--force", "agentic-dev-loop"],
+        capture_output=True, text=True, check=False, env=env)
+    if result.returncode != 0:
+        detail = (result.stderr or "unknown error").strip()
+        print(f"error: pipx install failed: {detail}", file=sys.stderr)
+        return 1
+
+    cli = _resolve("agentic-dev-loop", env)
+    if cli is None:
+        print("error: agentic-dev-loop is not on PATH", file=sys.stderr)
+        return 1
+    version_result = subprocess.run(
+        [cli, "--version"], capture_output=True, text=True,
+        check=False, env=env)
+    if version_result.returncode != 0:
+        detail = (version_result.stderr or "unknown error").strip()
+        print(f"error: could not read the installed version: {detail}",
+              file=sys.stderr)
+        return 1
+
+    tokens = version_result.stdout.split()
+    version = tokens[-1] if tokens else ""
+    try:
+        parse_version(version)
+    except ProfileError:
+        print("error: unreadable version from --version output: "
+              f"{version_result.stdout.strip()!r}", file=sys.stderr)
+        return 1
+
+    out = root / "agentic-dev-loop"
+    out.mkdir(parents=True, exist_ok=True)
+    (out / ".engine-version").write_text(version + "\n", encoding="utf-8")
+    print(f"upgraded agentic-dev-loop to {version}; .engine-version updated")
+    return 0

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.11.0}/src/agentic_dev_loop/viz/__init__.py

@@ -4,10 +4,10 @@ import time  # noqa: F401 - re-exported so tests can pin NodeWatch's clock
 
 from .server import (MAX_LINE, PAGE, ConsoleCapture, HeartbeatThread,
                      NodeWatch, VizBus, _ReuseSafeServer, _Tee,
-                     _handler_class, serve_viz, topology_mermaid, translate)
+                     _handler_class, serve_viz, topology_graph, topology_mermaid, translate)
 
 __all__ = [
     "MAX_LINE", "PAGE", "ConsoleCapture", "HeartbeatThread", "NodeWatch",
     "VizBus", "_ReuseSafeServer", "_Tee", "_handler_class", "serve_viz",
-    "topology_mermaid", "translate",
+    "topology_graph", "topology_mermaid", "translate",
 ]

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.11.0}/src/agentic_dev_loop/viz/__main__.py

@@ -8,7 +8,7 @@ import sys
 
 from agentic_dev_loop.core.config import load_config
 
-from . import VizBus, serve_viz, topology_mermaid
+from . import VizBus, serve_viz, topology_graph
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -23,9 +23,11 @@ def main(argv: list[str] | None = None) -> int:
     args = parser.parse_args(argv)
 
     cfg = load_config(args.pipeline)
-    topology, nodes = topology_mermaid(cfg)
+    topology = topology_graph(cfg)
     bus = VizBus()
-    httpd, _thread = serve_viz(bus, topology, cfg.name, args.port, nodes)
+    httpd, _thread = serve_viz(bus, topology["mermaid"], cfg.name, args.port,
+                               topology["nodes"], topology["flow"],
+                               topology["edges"])
     bound = httpd.server_address[1]
     url = f"http://127.0.0.1:{bound}"
     print(f"Live graph viz: {url}", flush=True)

agentic_dev_loop-0.11.0/src/agentic_dev_loop/viz/layout.py

@@ -0,0 +1,233 @@
+"""Pure-Python port of the viz pipeline layout algorithm.
+
+Mirrors ``planning-docs/design/pipeline-layout.js`` one-to-one (contract in
+its header and in the unit-9 business-logic model): no DOM, no I/O, same
+input/output shapes and the same crossing-free ordering rules. The reference
+ES5 implementation remains the browser-side copy; this port is the tested
+source of truth (decision Q3=A).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+NW = 112
+NH = 76
+GAP = 24
+STEP = NW + GAP
+LANE = 18
+LANE_TOP = 14
+LANE_PAD = 16
+CH = 12
+
+METRICS = {"NW": NW, "NH": NH, "GAP": GAP, "STEP": STEP, "LANE": LANE}
+
+
+class _Edge:
+    """Mutable routing record, mirroring the JS object the reference mutates."""
+
+    __slots__ = ("src", "dst", "label", "kind", "si", "ti", "rs", "rt",
+                 "lane_s", "lane_t", "j", "k", "xe")
+
+    def __init__(self, src: str, dst: str, label: str | None, kind: str):
+        self.src = src
+        self.dst = dst
+        self.label = label
+        self.kind = kind
+        self.si = 0
+        self.ti = 0
+        self.rs = 0
+        self.rt = 0
+        self.lane_s = 0
+        self.lane_t = 0
+        self.j = 0
+        self.k = 0
+        self.xe = 0
+
+
+def _plan(names: list[str], routed: list[_Edge], idx: dict[str, int], r: int) -> dict[str, Any]:
+    n = len(names)
+    per = max(1, (n + r - 1) // r)
+    rows = max(1, (n + per - 1) // per)
+    pos = [{"r": i // per, "c": i % per} for i in range(n)]
+    edges = []
+    for e in routed:
+        rec = _Edge(e.src, e.dst, e.label, e.kind)
+        rec.si = idx[e.src]
+        rec.ti = idx[e.dst]
+        rec.rs = pos[rec.si]["r"]
+        rec.rt = pos[rec.ti]["r"]
+        edges.append(rec)
+    same = sorted((e for e in edges if e.rs == e.rt),
+                  key=lambda e: abs(e.si - e.ti))
+    back = sorted((e for e in edges if e.rs > e.rt),
+                  key=lambda e: (e.rs, e.si))
+    forward = sorted((e for e in edges if e.rs < e.rt),
+                     key=lambda e: (e.rt, -e.si))
+    for j, e in enumerate(back):
+        e.j = j
+    for k, e in enumerate(forward):
+        e.k = k
+    multi = rows > 1
+    left = CH + CH * len(back) + 8 if multi else 0
+    core = per * STEP - GAP
+    right = (14 if multi else 0) + (8 + CH * len(forward) if forward else 0)
+    return {"per": per, "rows": rows, "pos": pos, "U": same, "C": back,
+            "F": forward, "O": left, "core": core, "width": left + core + right}
+
+
+def layout_pipeline(opts: dict[str, Any]) -> dict[str, Any]:
+    """Lay out stations and routes for ``opts`` (contract: FD section 1.1)."""
+    names = list(opts.get("nodes") or [])
+    n = len(names)
+    status = opts.get("status") or {}
+    avail = max(0, opts.get("availWidth") or 0)
+    flow = opts.get("flow") or []
+    cond_edges = opts.get("edges") or []
+    idx = {name: i for i, name in enumerate(names)}
+
+    def reached(name: str) -> bool:
+        return (status.get(name) or "pending") != "pending"
+
+    def failed(name: str) -> bool:
+        state = status.get(name) or "pending"
+        return state == "fail" or state == "fatal"
+
+    rails: list[dict[str, Any]] = []
+    extra_flow: list[_Edge] = []
+    for f in flow:
+        if f["src"] not in idx or f["dst"] not in idx:
+            continue
+        if idx[f["dst"]] == idx[f["src"]] + 1:
+            rails.append(f)
+        else:
+            extra_flow.append(_Edge(f["src"], f["dst"], None, "flow"))
+    routed = [
+        _Edge(e["src"], e["dst"], e.get("label") or None, "back")
+        for e in cond_edges
+        if e["src"] in idx and e["dst"] in idx
+    ] + extra_flow
+
+    layout = _plan(names, routed, idx, 1)
+    r = 2
+    while layout["width"] > avail and layout["per"] > 2:
+        layout = _plan(names, routed, idx, r)
+        r += 1
+    offset = layout["O"]
+
+    gutters: list[dict[str, int]] = []
+    for g in range(layout["rows"]):
+        items = 0
+
+        def take() -> int:
+            nonlocal items
+            value = items
+            items += 1
+            return value
+
+        for e in layout["U"]:
+            if e.rt == g:
+                e.lane_s = take()
+        for e in sorted((e for e in layout["C"] if e.rt == g),
+                        key=lambda e: -e.j):
+            e.lane_t = take()
+        for e in layout["F"]:
+            if e.rt == g:
+                e.lane_t = take()
+        for e in sorted((e for e in layout["C"] if e.rs == g),
+                        key=lambda e: e.si):
+            e.lane_s = take()
+        for e in layout["F"]:
+            if e.rs == g:
+                e.lane_s = take()
+        wrap = take() if g < layout["rows"] - 1 else -1
+        gutters.append({"n": items, "wrapLane": wrap})
+
+    row_y = [0]
+    for g, gutter in enumerate(gutters):
+        gutter["h"] = (LANE_TOP + (gutter["n"] - 1) * LANE + LANE_PAD
+                       if gutter["n"] else 4)
+        row_y.append(row_y[g] + NH + gutter["h"])
+
+    def lane_y(g: int, lane: int) -> int:
+        return row_y[g] + NH + LANE_TOP + lane * LANE
+
+    def node_x(i: int) -> int:
+        return offset + layout["pos"][i]["c"] * STEP
+
+    def node_y(i: int) -> int:
+        return row_y[layout["pos"][i]["r"]]
+
+    entry_count: dict[int, int] = {}
+    for e in layout["U"] + layout["C"] + layout["F"]:
+        m = entry_count.get(e.ti, 0)
+        entry_count[e.ti] = m + 1
+        e.xe = max(node_x(e.ti) + 8, node_x(e.ti) + NW - 14 - m * 14)
+
+    lines: list[dict[str, Any]] = []
+    arrows: list[dict[str, Any]] = []
+    labels: list[dict[str, Any]] = []
+
+    def horizontal(x1: int, x2: int, y: int, kind: str, on: bool = False) -> None:
+        lines.append({"x": min(x1, x2), "y": y, "w": abs(x2 - x1), "h": 0,
+                      "dir": "h", "kind": kind, "on": bool(on)})
+
+    def vertical(x: int, y1: int, y2: int, kind: str, on: bool = False) -> None:
+        lines.append({"x": x, "y": min(y1, y2), "w": 0, "h": abs(y2 - y1),
+                      "dir": "v", "kind": kind, "on": bool(on)})
+
+    for f in rails:
+        i = idx[f["src"]]
+        on = reached(f["dst"])
+        if layout["pos"][i + 1]["r"] == layout["pos"][i]["r"]:
+            horizontal(node_x(i) + NW, node_x(i + 1), node_y(i) + 37, "flow", on)
+            arrows.append({"x": node_x(i + 1) - 6, "y": node_y(i) + 33,
+                           "dir": "right", "kind": "flow", "on": on})
+        else:
+            r = layout["pos"][i]["r"]
+            xr = node_x(i) + NW + 12
+            yw = lane_y(r, gutters[r]["wrapLane"])
+            yn = node_y(i + 1) + 37
+            horizontal(node_x(i) + NW, xr + 2, node_y(i) + 37, "flow", on)
+            vertical(xr, node_y(i) + 37, yw, "flow", on)
+            horizontal(offset - 12, xr + 2, yw - 1, "flow", on)
+            vertical(offset - 12, yw - 1, yn + 2, "flow", on)
+            horizontal(offset - 12, offset, yn, "flow", on)
+            arrows.append({"x": offset - 6, "y": yn - 4, "dir": "right",
+                           "kind": "flow", "on": on})
+
+    for e in layout["U"] + layout["C"] + layout["F"]:
+        xs = node_x(e.si) + NW // 2
+        top = node_y(e.ti) + NH
+        y1 = lane_y(e.rs, e.lane_s)
+        on = e.kind == "back" and failed(e.src)
+        vertical(xs, node_y(e.si) + NH, y1, e.kind, on)
+        if e.rs == e.rt:
+            horizontal(e.xe, xs, y1, e.kind, on)
+            vertical(e.xe, top + 6, y1, e.kind, on)
+        else:
+            if e.rs > e.rt:
+                xc = offset - CH - CH * (e.j + 1)
+            else:
+                xc = offset + layout["core"] + 14 + 8 + CH * e.k
+            y2 = lane_y(e.rt, e.lane_t)
+            horizontal(xc, xs, y1, e.kind, on)
+            vertical(xc, y2, y1, e.kind, on)
+            horizontal(xc, e.xe, y2, e.kind, on)
+            vertical(e.xe, top + 6, y2, e.kind, on)
+        arrows.append({"x": e.xe - 5, "y": top, "dir": "up", "kind": e.kind,
+                       "on": on})
+        if e.label:
+            labels.append({"x": xs - 6, "y": y1 - 9, "text": e.label})
+
+    return {
+        "width": layout["width"],
+        "height": row_y[layout["rows"]],
+        "rows": layout["rows"],
+        "perRow": layout["per"],
+        "nodes": [{"id": name, "index": i, "x": node_x(i), "y": node_y(i),
+                   "w": NW, "h": NH} for i, name in enumerate(names)],
+        "lines": lines,
+        "arrows": arrows,
+        "labels": labels,
+    }