loom-code 0.1.2__tar.gz → 0.2.0__tar.gz

{loom_code-0.1.2 → loom_code-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loom-code
-Version: 0.1.2
+Version: 0.2.0
 Summary: loom-code — a loomflow-native terminal coding agent
 Author: Anupam Nautiyal
 License: MIT License
@@ -39,7 +39,7 @@ Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: loomflow[litellm,mcp,web]<0.11,>=0.10.23
+Requires-Dist: loomflow[litellm,mcp,web]<0.11,>=0.10.30
 Requires-Dist: rich>=13
 Requires-Dist: prompt-toolkit>=3.0
 Requires-Dist: anthropic

{loom_code-0.1.2 → loom_code-0.2.0}/loom_code/__init__.py

@@ -19,4 +19,4 @@ belongs in the framework, not here. loom-code is the dogfood test
 that keeps loomflow honest.
 """
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"

{loom_code-0.1.2 → loom_code-0.2.0}/loom_code/agent.py

@@ -442,10 +442,18 @@ def build_agent(
     # coordinator only reads, but a user PreToolUse hook can match
     # ``read``/``grep`` too, so keep it in the set; the workers (which
     # write + run bash) are the main target. No-op when none declared.
+    # The loop guard (doom-loop + missing-binary steering) and the
+    # post-edit diagnostics rider (per-file syntax/lint findings
+    # appended to edit results) ride the same registries — native
+    # post hooks, not shell specs.
+    from . import diagnostics, loop_guard
+
     for tool_agent in (coordinator, *workers.values()):
         attach_tool_hooks(
             tool_agent, extensions.hook_specs, cwd=project.root
         )
+        loop_guard.attach(tool_agent)
+        diagnostics.attach(tool_agent, project.root)
 
     # Stash the MCP registry on the coordinator so the REPL / sidecar can
     # tear it down (``await coordinator._mcp_registry.aclose()``) on exit
@@ -534,6 +542,10 @@ def build_solo_agent(
         from loomflow.tools import web_tool
         agent.add_tool(web_tool(backend=web_backend))  # type: ignore[arg-type]
     attach_tool_hooks(agent, extensions.hook_specs, cwd=project.root)
+    from . import diagnostics, loop_guard
+
+    loop_guard.attach(agent)
+    diagnostics.attach(agent, project.root)
     return agent
 
 

{loom_code-0.1.2 → loom_code-0.2.0}/loom_code/approval.py

@@ -60,7 +60,7 @@ def _is_danger_command(tool: str, args: dict[str, Any]) -> str | None:
     past the check. False positives are acceptable here: an extra
     confirmation on a benign ``git reset --hard`` to a known-safe ref
     costs one keypress; a missed ``rm -rf .git`` costs the repo."""
-    if tool != "bash":
+    if tool not in ("bash", "bash_background"):
         return None
     cmd = str(args.get("command", "")).lower()
     norm = " ".join(cmd.split())

loom_code-0.2.0/loom_code/background.py

@@ -0,0 +1,226 @@
+"""Background bash — long-running processes that don't block the turn.
+
+The capability gap vs Claude Code (background subagents/shells by
+default) and opencode (non-blocking subagents): loom-code's ``bash``
+blocks until the command exits, so a dev server, a watcher, or a long
+test run wedges the whole turn. These tools let the agent start a
+process, keep working, and check on it later:
+
+* ``bash_background(command)`` → spawns detached, returns a handle
+  (``bg1``, ``bg2``, …). Runs arbitrary code, so it is
+  ``destructive=True`` and rides the SAME approval gate + allow/ask/
+  deny rules as ``bash`` (``permissions.call_target`` maps it to the
+  command string, and the irreversible-danger scan applies).
+* ``bash_output(handle)`` → status + the output tail. Read-only.
+* ``bash_kill(handle)`` → terminate the process group. Read-only
+  gate-wise (it only stops what the agent itself started).
+
+Registry is module-level (the ``consent.py`` pattern): tools are
+built at agent construction, the REPL kills leftovers on exit, and
+``atexit`` backstops a crash so no orphan dev-servers outlive the
+session. Output goes to a spool file per process — bounded tail
+reads, no pipe-buffer deadlocks.
+"""
+
+from __future__ import annotations
+
+import atexit
+import os
+import signal
+import subprocess
+import tempfile
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from loomflow import tool
+
+_TAIL_CHARS = 4_000
+
+
+@dataclass
+class _Proc:
+    handle: str
+    command: str
+    popen: subprocess.Popen[bytes]
+    spool_path: Path
+    started_at: float = field(default_factory=time.monotonic)
+
+
+_procs: dict[str, _Proc] = {}
+_counter = 0
+
+
+def reset() -> None:
+    """Kill everything and clear the registry (tests + /clear)."""
+    kill_all()
+    _procs.clear()
+
+
+def _spawn(command: str, cwd: Path) -> _Proc:
+    global _counter
+    _counter += 1
+    handle = f"bg{_counter}"
+    fd, spool = tempfile.mkstemp(prefix=f"loom-{handle}-", suffix=".log")
+    spool_file = os.fdopen(fd, "wb")
+    # New process GROUP so bash_kill can terminate the whole tree
+    # (a dev server forks children; killing just the shell leaks
+    # them). start_new_session works on POSIX; on Windows we fall
+    # back to CREATE_NEW_PROCESS_GROUP.
+    kwargs: dict[str, Any] = {}
+    if os.name == "posix":
+        kwargs["start_new_session"] = True
+    else:  # pragma: no cover - windows
+        kwargs["creationflags"] = getattr(
+            subprocess, "CREATE_NEW_PROCESS_GROUP", 0
+        )
+    popen = subprocess.Popen(  # noqa: S602 - the whole point
+        command,
+        shell=True,
+        cwd=str(cwd),
+        stdout=spool_file,
+        stderr=subprocess.STDOUT,
+        stdin=subprocess.DEVNULL,
+        **kwargs,
+    )
+    spool_file.close()  # child holds its own fd; parent reads by path
+    proc = _Proc(
+        handle=handle,
+        command=command,
+        popen=popen,
+        spool_path=Path(spool),
+    )
+    _procs[handle] = proc
+    return proc
+
+
+def _tail(proc: _Proc) -> str:
+    try:
+        data = proc.spool_path.read_bytes()
+    except OSError:
+        return ""
+    text = data.decode("utf-8", "replace")
+    if len(text) > _TAIL_CHARS:
+        text = f"…(earlier output trimmed)\n{text[-_TAIL_CHARS:]}"
+    return text
+
+
+def _status_line(proc: _Proc) -> str:
+    rc = proc.popen.poll()
+    elapsed = time.monotonic() - proc.started_at
+    if rc is None:
+        return (
+            f"{proc.handle}: RUNNING ({elapsed:.0f}s) — {proc.command}"
+        )
+    return (
+        f"{proc.handle}: EXITED rc={rc} after {elapsed:.0f}s — "
+        f"{proc.command}"
+    )
+
+
+def _kill(proc: _Proc) -> str:
+    rc = proc.popen.poll()
+    if rc is not None:
+        return f"{proc.handle} already exited (rc={rc})"
+    try:
+        if os.name == "posix":
+            os.killpg(os.getpgid(proc.popen.pid), signal.SIGTERM)
+        else:  # pragma: no cover - windows
+            proc.popen.terminate()
+    except (ProcessLookupError, PermissionError, OSError):
+        proc.popen.terminate()
+    try:
+        proc.popen.wait(timeout=3)
+    except subprocess.TimeoutExpired:
+        try:
+            if os.name == "posix":
+                os.killpg(os.getpgid(proc.popen.pid), signal.SIGKILL)
+            else:  # pragma: no cover - windows
+                proc.popen.kill()
+        except (ProcessLookupError, PermissionError, OSError):
+            proc.popen.kill()
+    return f"{proc.handle} terminated"
+
+
+def kill_all() -> int:
+    """Terminate every live background process. Returns how many were
+    still running. Called on REPL exit + atexit."""
+    n = 0
+    for proc in list(_procs.values()):
+        if proc.popen.poll() is None:
+            _kill(proc)
+            n += 1
+    return n
+
+
+atexit.register(kill_all)
+
+
+def background_tools(workdir: Path | str) -> list[Any]:
+    """The three background-process tools, rooted at ``workdir``."""
+    root = Path(workdir)
+
+    async def bash_background(command: str) -> str:
+        command = str(command).strip()
+        if not command:
+            return "ERROR: empty command"
+        proc = _spawn(command, root)
+        return (
+            f"started {proc.handle} (pid {proc.popen.pid}): "
+            f"{command}\nCheck it with bash_output(handle="
+            f"'{proc.handle}'); stop it with bash_kill(handle="
+            f"'{proc.handle}'). Keep working while it runs."
+        )
+
+    async def bash_output(handle: str) -> str:
+        proc = _procs.get(str(handle).strip())
+        if proc is None:
+            live = ", ".join(sorted(_procs)) or "none"
+            return f"ERROR: unknown handle {handle!r} (live: {live})"
+        tail = _tail(proc)
+        body = tail if tail.strip() else "(no output yet)"
+        return f"{_status_line(proc)}\n---\n{body}"
+
+    async def bash_kill(handle: str) -> str:
+        proc = _procs.get(str(handle).strip())
+        if proc is None:
+            live = ", ".join(sorted(_procs)) or "none"
+            return f"ERROR: unknown handle {handle!r} (live: {live})"
+        msg = _kill(proc)
+        tail = _tail(proc)
+        if tail.strip():
+            msg += f"\nfinal output tail:\n{tail[-800:]}"
+        return msg
+
+    return [
+        tool(
+            name="bash_background",
+            description=(
+                "Run a shell command in the BACKGROUND and return a "
+                "handle immediately — for dev servers, watchers, "
+                "long builds/test runs you want to keep working "
+                "past. Check progress with bash_output(handle); "
+                "stop with bash_kill(handle). Use plain bash for "
+                "anything under ~30s."
+            ),
+            # Runs arbitrary code — same safety contract as bash:
+            # approval gate + allow/ask/deny rules + danger scan.
+            destructive=True,
+        )(bash_background),
+        tool(
+            name="bash_output",
+            description=(
+                "Status + output tail of a background process "
+                "started with bash_background. Args: handle "
+                "(e.g. 'bg1')."
+            ),
+        )(bash_output),
+        tool(
+            name="bash_kill",
+            description=(
+                "Terminate a background process (whole process "
+                "group) started with bash_background. Args: handle."
+            ),
+        )(bash_kill),
+    ]

{loom_code-0.1.2 → loom_code-0.2.0}/loom_code/checkpoint.py

@@ -134,18 +134,25 @@ def _snapshot_commit(root: Path) -> tuple[str | None, str]:
 
     # Temp index OUTSIDE the worktree so it never appears in the
     # snapshot (an in-tree temp index leaked itself into the tree —
-    # verified). Seed it from the real index so unchanged staged state
-    # is preserved; if there's no index yet, git creates one.
+    # verified).
+    #
+    # Seed it from HEAD's TREE via read-tree — NOT by copying the real
+    # index file. A copied index carries the real index's STAT CACHE,
+    # and a same-size edit whose mtime matches the cached stat makes
+    # ``git add`` trust the cache and skip re-hashing — the snapshot
+    # silently captures the OLD content and /undo restores stale data
+    # (agents write fast; hit for real on CI). read-tree writes
+    # entries with no stat information, so the add below re-stats and
+    # re-hashes every path — the trap can't fire.
     tmp_fd, tmp_index = tempfile.mkstemp(prefix="loom-ckpt-index-")
     os.close(tmp_fd)
     try:
-        real_index = root / ".git" / "index"
-        if real_index.is_file():
-            try:
-                Path(tmp_index).write_bytes(real_index.read_bytes())
-            except OSError:
-                pass  # start from empty temp index
         env = {"GIT_INDEX_FILE": tmp_index}
+        if parent:
+            rc, _o, err = _git(root, ["read-tree", parent], env=env)
+            if rc != 0:
+                return None, f"read-tree failed: {err.strip()}"
+        # No HEAD yet → empty temp index; add stages everything fresh.
         # Stage tracked changes + untracked files. .loom is excluded so
         # the snapshot doesn't churn on our own state files (it's also
         # usually gitignored, but be explicit).

loom_code-0.2.0/loom_code/context_report.py

@@ -0,0 +1,129 @@
+"""Context observability — the renderers behind ``/context`` and the
+per-turn ``ctx%`` readout.
+
+The loudest 2026 harness complaint (pi's author's core critique,
+Anthropic's own Claude Code postmortems, Kilo's whole positioning) is
+INVISIBLE context: harnesses inject content the user never sees,
+compact silently, and change defaults without telling anyone.
+loom-code's answer is to show everything — on demand (``/context``,
+``/prompt``) and ambiently (a ``N% ctx`` figure on every turn's
+summary line).
+
+Pure functions only (no console, no agent) so the rendering is
+trivially testable; ``repl.py`` gathers the live numbers and prints.
+"""
+
+from __future__ import annotations
+
+# Mirrors loomflow's DEFAULT_CHARS_PER_TOKEN — the conservative
+# cross-content estimate (English prose ≈4 chars/token, code ≈3;
+# under-estimating context left would overflow, so estimate high).
+_CHARS_PER_TOKEN = 4
+
+
+def estimate_tokens(text: str) -> int:
+    """Char-based token estimate, floored at 0 for empty text.
+
+    Used for the working-block sizes in ``/context`` — these blocks
+    never pass through a provider tokenizer on their own, so an
+    estimate is the honest label (and it's marked ``~`` in the UI).
+    """
+    if not text:
+        return 0
+    return max(1, len(text) // _CHARS_PER_TOKEN)
+
+
+def context_percent(used_tokens: int, window: int) -> int:
+    """Whole-percent context occupancy, clamped to [0, 100]."""
+    if window <= 0:
+        return 0
+    return max(0, min(100, round(used_tokens * 100 / window)))
+
+
+def context_report(
+    *,
+    model: str,
+    window: int,
+    used_tokens: int,
+    threshold: int,
+    blocks: list[tuple[str, str]],
+    n_exchanges: int,
+) -> str:
+    """Render the ``/context`` report as plain text.
+
+    ``blocks`` is ``[(name, content), …]`` — every working block
+    loomflow will inject into the next system prompt. ``used_tokens``
+    is the context high-water mark of the last turn's input (the same
+    figure the auto-compactor keys on), so the user sees the number
+    the harness itself acts on — not a synthetic one.
+    """
+    pct = context_percent(used_tokens, window)
+    bar_w = 24
+    filled = round(bar_w * pct / 100)
+    bar = "█" * filled + "░" * (bar_w - filled)
+
+    lines = [
+        f"context — {model}",
+        f"  window     {window:>10,} tokens",
+        f"  used       {used_tokens:>10,} tokens "
+        f"[{bar}] {pct}%",
+    ]
+    if threshold > 0:
+        lines.append(
+            f"  compaction {threshold:>10,} tokens "
+            f"(auto-compacts at this point)"
+        )
+    else:
+        lines.append("  compaction        off")
+    lines.append(
+        f"  history    {n_exchanges:>10,} exchange"
+        f"{'s' if n_exchanges != 1 else ''} this thread"
+    )
+    lines.append("")
+    if blocks:
+        lines.append(
+            "injected working blocks (folded into every system prompt):"
+        )
+        total = 0
+        for name, content in sorted(blocks, key=lambda b: b[0]):
+            t = estimate_tokens(content)
+            total += t
+            lines.append(f"  {name:<18} ~{t:>7,} tokens")
+        lines.append(f"  {'total':<18} ~{total:>7,} tokens")
+    else:
+        lines.append("injected working blocks: none")
+    lines.append("")
+    lines.append(
+        "nothing else is injected — what you see here plus the "
+        "conversation is the model's entire context. /prompt shows "
+        "the full text."
+    )
+    return "\n".join(lines)
+
+
+def prompt_dump(
+    *,
+    instructions: str | None,
+    blocks: list[tuple[str, str]],
+) -> str:
+    """Render the ``/prompt`` dump: the coordinator's static
+    instructions plus every working block body, clearly delimited.
+    No paraphrasing, no elision — the point is that this IS what the
+    model receives."""
+    parts: list[str] = []
+    if instructions:
+        parts.append("═══ system instructions (static) ═══")
+        parts.append(instructions.rstrip())
+    else:
+        parts.append(
+            "═══ system instructions (static) ═══\n"
+            "(not exposed by this agent build — working blocks below "
+            "are still exact)"
+        )
+    for name, content in sorted(blocks, key=lambda b: b[0]):
+        parts.append(
+            f"═══ working block: {name} "
+            f"(~{estimate_tokens(content):,} tokens) ═══"
+        )
+        parts.append(content.rstrip() or "(empty)")
+    return "\n\n".join(parts)

loom_code-0.2.0/loom_code/diagnostics.py

@@ -0,0 +1,155 @@
+"""Post-edit diagnostics — surface syntax/lint errors to the model
+immediately after every file mutation.
+
+The MVP slice of "LSP-aware code intelligence" (named table-stakes for
+2026 harnesses; Claude Code surfaces type errors after each edit, and
+cline's LACK of it is a documented token-cost complaint): after each
+``edit`` / ``multi_edit`` / ``write``, run a CHEAP per-file checker
+and append any findings to the tool result, so the model fixes the
+break in the same breath instead of discovering it three tool calls
+later via a failing test.
+
+Deliberately bounded — this is not an LSP client:
+
+* per-FILE checks only (never whole-project ``tsc``/``cargo check``,
+  which cost seconds-to-minutes per edit);
+* only checkers that are actually PRESENT (never cause the #1 agent
+  failure, "executable not found");
+* hard timeout; on timeout/absence/success the hook is silent.
+
+Rides the same native post-tool-hook mechanism as ``loop_guard`` —
+the hint lands appended to the live ``ToolResult`` before the loop
+serialises it, so it reaches the model inline.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sys
+from pathlib import Path
+from typing import Any
+
+import anyio
+
+_EDIT_TOOLS = frozenset({"edit", "multi_edit", "write"})
+
+_TIMEOUT_S = 4.0
+_MAX_LINES = 12
+_MAX_CHARS = 1200
+
+
+def detect_checker(path: Path) -> list[str] | None:
+    """The per-file checker argv for ``path``, or None.
+
+    Preference order per language: the project's real linter when
+    installed, else a stdlib/toolchain syntax check, else nothing.
+    Every command here is single-file and sub-second."""
+    suffix = path.suffix.lower()
+    if suffix == ".py":
+        ruff = shutil.which("ruff")
+        if ruff:
+            # --no-cache: the agent edits fast; a stale cache dir in
+            # odd cwds causes confusing misses. Still ~50ms/file.
+            return [ruff, "check", "--no-cache", str(path)]
+        return [sys.executable, "-m", "py_compile", str(path)]
+    if suffix in (".js", ".mjs", ".cjs"):
+        node = shutil.which("node")
+        if node:
+            return [node, "--check", str(path)]
+        return None
+    if suffix == ".go":
+        gofmt = shutil.which("gofmt")
+        if gofmt:
+            # -e: report all (syntax) errors; -l alone is silent.
+            return [gofmt, "-e", "-l", str(path)]
+        return None
+    if suffix in (".sh", ".bash"):
+        bash = shutil.which("bash")
+        if bash:
+            return [bash, "-n", str(path)]
+        return None
+    return None
+
+
+def _trim(text: str) -> str:
+    lines = [ln for ln in text.strip().splitlines() if ln.strip()]
+    if len(lines) > _MAX_LINES:
+        lines = lines[:_MAX_LINES] + [
+            f"… (+{len(lines) - _MAX_LINES} more lines)"
+        ]
+    out = "\n".join(lines)
+    return out[:_MAX_CHARS]
+
+
+async def run_diagnostics(path: Path) -> str | None:
+    """Run the file's checker; return trimmed findings on FAILURE,
+    None on success / no checker / timeout / any error. Silence is
+    the contract — diagnostics may only ever add signal."""
+    argv = detect_checker(path)
+    # noqa rationale: one stat on a local path — cheaper than hopping
+    # to a worker thread for it.
+    if argv is None or not path.is_file():  # noqa: ASYNC240
+        return None
+    result: Any = None
+    with anyio.move_on_after(_TIMEOUT_S):
+        try:
+            result = await anyio.run_process(argv, check=False)
+        except Exception:  # noqa: BLE001 — silent by contract
+            return None
+    if result is None:  # timed out
+        return None
+    out = result.stdout.decode("utf-8", "replace")
+    err = result.stderr.decode("utf-8", "replace")
+    # gofmt -e -l prints the filename on stdout for UNFORMATTED files
+    # even with rc=0 — only treat rc!=0 (real syntax/lint errors) as
+    # a finding, matching "silence unless broken".
+    if result.returncode == 0:
+        return None
+    findings = _trim(f"{out}\n{err}")
+    return findings or None
+
+
+def make_post_tool_hook(root: Path) -> Any:
+    """Build the post-tool hook bound to ``root`` — edit tools take
+    project-relative paths, so the hook must resolve them against the
+    project root (mirroring ``paths.resolve_path``), not the process
+    cwd."""
+
+    async def post_tool(call: Any, result: Any) -> None:
+        try:
+            tool = str(getattr(call, "tool", ""))
+            if tool not in _EDIT_TOOLS:
+                return
+            if not getattr(result, "ok", False):
+                return  # the edit itself failed; don't pile on
+            raw = str(
+                dict(getattr(call, "args", {}) or {}).get("path", "")
+            ).strip()
+            if not raw:
+                return
+            # noqa rationale: pure string math, no disk I/O.
+            p = Path(raw).expanduser()  # noqa: ASYNC240
+            if not p.is_absolute():
+                p = root / p
+            findings = await run_diagnostics(p)
+            if findings and isinstance(result.output, str):
+                result.output = (
+                    f"{result.output}\n\n[diagnostics] the edited "
+                    "file now has problems — fix them before moving "
+                    f"on:\n{findings}"
+                )
+        except Exception:  # noqa: BLE001 — never break a tool result
+            return
+
+    return post_tool
+
+
+def attach(agent: Any, root: Path) -> None:
+    """Register on ``agent``'s hook registry (same shape as
+    loop_guard.attach). Best-effort."""
+    try:
+        agent._hooks.register_post_tool(  # noqa: SLF001
+            make_post_tool_hook(root)
+        )
+    except Exception:  # noqa: BLE001
+        return