loom-code 0.1.1__tar.gz → 0.1.3__tar.gz

{loom_code-0.1.1 → loom_code-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loom-code
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -106,11 +106,12 @@ load-bearing — the agent loop, tools, planning, memory — is loomflow.
 ## Install
 
 ```bash
-pipx install git+https://github.com/Anurich/loomflow-cli
+pipx install loom-code
 ```
 
-(`pip install` works too; `pipx` keeps CLI tools in their own venvs.
-No pipx? `brew install pipx` or `python -m pip install --user pipx`.)
+(`pip install loom-code` works too; `pipx` keeps CLI tools in their
+own venvs. No pipx? `brew install pipx` or
+`python -m pip install --user pipx`.)
 
 Requires Python 3.11+. To update: `pipx upgrade loom-code`.
 

{loom_code-0.1.1 → loom_code-0.1.3}/README.md

@@ -52,11 +52,12 @@ load-bearing — the agent loop, tools, planning, memory — is loomflow.
 ## Install
 
 ```bash
-pipx install git+https://github.com/Anurich/loomflow-cli
+pipx install loom-code
 ```
 
-(`pip install` works too; `pipx` keeps CLI tools in their own venvs.
-No pipx? `brew install pipx` or `python -m pip install --user pipx`.)
+(`pip install loom-code` works too; `pipx` keeps CLI tools in their
+own venvs. No pipx? `brew install pipx` or
+`python -m pip install --user pipx`.)
 
 Requires Python 3.11+. To update: `pipx upgrade loom-code`.
 

{loom_code-0.1.1 → loom_code-0.1.3}/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.1"
+__version__ = "0.1.3"

{loom_code-0.1.1 → loom_code-0.1.3}/loom_code/approval.py

@@ -112,6 +112,30 @@ def _read_key_raw(fd: int) -> str:
     return ch.lower()
 
 
+def _read_key_msvcrt() -> str:
+    """Windows equivalent of :func:`_read_key_raw` — one LOGICAL key
+    via ``msvcrt.getwch()`` (already raw + no echo, so no mode
+    setup/teardown is needed).
+
+    Arrow keys arrive as a TWO-event sequence: a ``'\\xe0'`` (or
+    ``'\\x00'`` for some layouts) prefix, then ``'H'`` (up) /
+    ``'P'`` (down). Ctrl-C surfaces as ``'\\x03'`` and maps to the
+    SAFE 'esc', mirroring the POSIX reader."""
+    import msvcrt
+
+    ch = msvcrt.getwch()
+    if ch in ("\r", "\n"):
+        return "enter"
+    if ch == "\x03":  # Ctrl-C
+        return "esc"
+    if ch == "\x1b":
+        return "esc"
+    if ch in ("\xe0", "\x00"):  # extended-key prefix
+        final = msvcrt.getwch()
+        return {"H": "up", "P": "down"}.get(final, "esc")
+    return ch.lower()
+
+
 def _read_key() -> str:
     """Single-key read that manages its own raw-mode window. Prefer
     :func:`_read_key_raw` inside a selector that enters raw mode ONCE
@@ -187,23 +211,54 @@ def _select_option(options: list[tuple[str, str]], default: int = 0) -> str:
             out.write("\r\n")  # explicit CR+LF for raw mode
         out.flush()
 
-    # Enter raw mode ONCE for the whole selector session — no
+    # Pick the platform's key reader + raw-mode strategy.
+    #
+    # POSIX: enter raw mode ONCE for the whole selector session — no
     # per-keypress termios churn, and no cooked-mode gap between keys
     # where type-ahead would echo raw escape bytes onto the prompt.
-    import termios
-    import tty
+    #
+    # Windows: there is NO termios (the bare import crashed /set_model
+    # for pipx users with ModuleNotFoundError). msvcrt.getwch() is
+    # already raw + unbuffered, so no mode management is needed at
+    # all; ``os.system("")`` nudges legacy conhost into processing the
+    # ANSI redraw sequences (Windows Terminal has VT on by default).
+    def _restore() -> None:
+        return None
+
+    def _reader() -> str:
+        return _read_key()
 
-    fd = sys.stdin.fileno()
     try:
-        old = termios.tcgetattr(fd)
-    except Exception:
-        old = None
-    if old is not None:
-        tty.setraw(fd)
+        import termios
+        import tty
+
+        fd = sys.stdin.fileno()
+        try:
+            old = termios.tcgetattr(fd)
+        except Exception:
+            old = None
+        if old is not None:
+            tty.setraw(fd)
+
+            def _reader() -> str:
+                return _read_key_raw(fd)
+
+            def _restore() -> None:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    except ImportError:
+        try:
+            import msvcrt  # noqa: F401 — probe: Windows console?
+            import os
+
+            os.system("")  # enable VT processing on legacy conhost
+            _reader = _read_key_msvcrt
+        except ImportError:
+            pass  # exotic platform → keep the _read_key fallback
+
     try:
         _draw(first=True)
         while True:
-            key = _read_key_raw(fd) if old is not None else _read_key()
+            key = _reader()
             if key == "up":
                 idx = (idx - 1) % n
             elif key == "down":
@@ -221,8 +276,7 @@ def _select_option(options: list[tuple[str, str]], default: int = 0) -> str:
                 continue  # unknown key: ignore, keep waiting
             _draw(first=False)
     finally:
-        if old is not None:
-            termios.tcsetattr(fd, termios.TCSADRAIN, old)
+        _restore()
 
 
 def _read_single_key() -> str:

{loom_code-0.1.1 → loom_code-0.1.3}/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.1.1 → loom_code-0.1.3}/loom_code/loominit/repomap.py

@@ -134,23 +134,61 @@ _SKIP_DIRS = frozenset(
 
 # Cache: root -> (signature, rendered map). The signature is cheap to
 # recompute; the expensive AST walk only re-runs when it changes.
-_REPO_MAP_CACHE: dict[str, tuple[tuple[float, int], str | None]] = {}
+# ``_UNMAPPABLE`` in the signature slot marks a root we refuse to map
+# (drive root / home dir / walk blew the budget) — cached so later
+# turns skip instantly instead of re-attempting the walk.
+_UNMAPPABLE = object()
+_REPO_MAP_CACHE: dict[str, tuple[object, str | None]] = {}
+
+# Walk guards. The signature walk runs at EVERY turn start, on the
+# REPL's event loop — it must never be able to stall a turn. A user
+# launched loom-code at ``D:\`` (drive root, no git → cwd becomes the
+# project root) and the first turn hung walking the whole drive.
+_SIG_MAX_FILES = 50_000  # .py files — far beyond any sane repo
+_SIG_TIME_BUDGET_S = 3.0  # wall-clock cap for the whole walk
+
+
+def _unmappable_root(root: Path) -> bool:
+    """Roots where a repo map makes no sense and the walk is dangerous:
+    a filesystem/drive root (``/``, ``C:\\``, ``D:\\``) or the user's
+    home directory. These aren't projects — they're the world."""
+    try:
+        return root == Path(root.anchor) or root == Path.home()
+    except OSError:
+        return True  # can't even resolve — don't walk it
 
 
-def _tree_signature(root: Path) -> tuple[float, int]:
+def _tree_signature(root: Path) -> tuple[float, int] | None:
     """A cheap freshness key: (newest .py mtime, file count). Either
     moving means the tree changed → rebuild. Count catches add/delete
-    that don't bump the newest mtime."""
+    that don't bump the newest mtime.
+
+    ``os.walk`` with pruning (NOT ``rglob``, which descends into
+    node_modules/.venv and filters after the fact) plus a file-count
+    and wall-clock budget. Returns ``None`` when the budget is
+    breached — the tree is too big to map; the caller caches the
+    refusal."""
+    import os
+    import time as _time
+
+    deadline = _time.monotonic() + _SIG_TIME_BUDGET_S
     newest = 0.0
     count = 0
-    for p in root.rglob("*.py"):
-        if any(part in _SKIP_DIRS for part in p.parts):
-            continue
-        try:
-            newest = max(newest, p.stat().st_mtime)
+    for dirpath, dirnames, filenames in os.walk(root):
+        if _time.monotonic() > deadline:
+            return None
+        dirnames[:] = [d for d in dirnames if d not in _SKIP_DIRS]
+        for fn in filenames:
+            if not fn.endswith(".py"):
+                continue
+            try:
+                st = os.stat(os.path.join(dirpath, fn))
+            except OSError:
+                continue
+            newest = max(newest, st.st_mtime)
             count += 1
-        except OSError:
-            continue
+            if count > _SIG_MAX_FILES:
+                return None
     return (newest, count)
 
 
@@ -161,11 +199,23 @@ def _repo_map_cached(
     True when the source tree changed and we re-walked, False on a
     cache hit. Freshness-keyed (newest .py mtime + file count), so it
     only re-parses when something actually moved. Mirrors the map to
-    ``<root>/.loom/repomap.md`` on every rebuild for inspection."""
+    ``<root>/.loom/repomap.md`` on every rebuild for inspection.
+
+    Unmappable roots (drive root / home / budget-breaching trees)
+    return ``(None, False)`` and are cached as such — the agent simply
+    runs without a repo map there, and no later turn pays the walk."""
     root_p = Path(root).resolve()
     key = str(root_p)
-    sig = _tree_signature(root_p)
     cached = _REPO_MAP_CACHE.get(key)
+    if cached is not None and cached[0] is _UNMAPPABLE:
+        return None, False
+    if _unmappable_root(root_p):
+        _REPO_MAP_CACHE[key] = (_UNMAPPABLE, None)
+        return None, False
+    sig = _tree_signature(root_p)
+    if sig is None:  # walk breached the budget — tree too big
+        _REPO_MAP_CACHE[key] = (_UNMAPPABLE, None)
+        return None, False
     if cached is not None and cached[0] == sig:
         return cached[1], False
     rendered = repo_map_for_root(root_p, max_tokens=max_tokens)

{loom_code-0.1.1 → loom_code-0.1.3}/loom_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loom-code
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -106,11 +106,12 @@ load-bearing — the agent loop, tools, planning, memory — is loomflow.
 ## Install
 
 ```bash
-pipx install git+https://github.com/Anurich/loomflow-cli
+pipx install loom-code
 ```
 
-(`pip install` works too; `pipx` keeps CLI tools in their own venvs.
-No pipx? `brew install pipx` or `python -m pip install --user pipx`.)
+(`pip install loom-code` works too; `pipx` keeps CLI tools in their
+own venvs. No pipx? `brew install pipx` or
+`python -m pip install --user pipx`.)
 
 Requires Python 3.11+. To update: `pipx upgrade loom-code`.
 

{loom_code-0.1.1 → loom_code-0.1.3}/loom_code.egg-info/requires.txt

@@ -1,4 +1,4 @@
-loomflow[litellm,mcp,web]<0.11,>=0.10.23
+loomflow[litellm,mcp,web]<0.11,>=0.10.30
 rich>=13
 prompt-toolkit>=3.0
 anthropic

{loom_code-0.1.1 → loom_code-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "loom-code"
-version = "0.1.1"
+version = "0.1.3"
 description = "loom-code — a loomflow-native terminal coding agent"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -54,11 +54,16 @@ dependencies = [
     # plugin to use MCP. Discovery degrades gracefully if it's ever absent.
     # >=0.10.25 carries the tool-call arg coercion + PEP 563 schema-typing
     # fix that loom-code's typed tools (edit replace_all=bool, etc.) rely on.
+    # >=0.10.30 floor: the tool-transcript capture fix — earlier
+    # versions leaked rehydrated prose (a prior answer + the run's own
+    # prompt) into persisted transcripts on resumed sessions,
+    # corrupting rehydration and the /resume preview. loom-code's
+    # /resume scrubs old data; the floor stops NEW corruption.
     # <0.11 ceiling: loomflow is pre-1.0, so a minor bump may break the
     # composed surfaces (Team kwargs, stop hooks, working blocks). Raise
     # the ceiling deliberately after testing, not by accident on a
     # user's machine mid-`pipx upgrade`.
-    "loomflow[litellm,web,mcp]>=0.10.23,<0.11",
+    "loomflow[litellm,web,mcp]>=0.10.30,<0.11",
     "rich>=13",
     # prompt_toolkit drives the REPL line editor — gives us inline
     # slash-command autocomplete (a menu pops the moment the user
@@ -129,7 +134,7 @@ select = ["E", "F", "I", "B", "UP", "ASYNC"]
 # publishing — no tokens). Daily flow stays plain git; ``make release
 # BUMP=patch|minor|major`` is the explicit "this is a release" flag.
 [tool.bumpversion]
-current_version = "0.1.1"
+current_version = "0.1.3"
 search = "{current_version}"
 replace = "{new_version}"
 commit = true

{loom_code-0.1.1 → loom_code-0.1.3}/tests/test_approval.py

@@ -70,3 +70,78 @@ async def test_approval_gate_allow_all_works_for_every_tool() -> None:
     for tool in ("bash", "edit", "write"):
         call = ToolCall(tool=tool, args={})
         assert await gate.handler(call) is True
+
+
+# ---- Windows key reader (msvcrt) -------------------------------------
+# termios doesn't exist on Windows; the selector dispatches to
+# _read_key_msvcrt there. We can't run real Windows in CI, but the
+# reader's decode logic is pure — drive it with a fake msvcrt module.
+
+
+def _fake_msvcrt(keys: list[str]):
+    """A stand-in msvcrt whose getwch() pops from ``keys``."""
+    import types
+
+    mod = types.ModuleType("msvcrt")
+    seq = iter(keys)
+    mod.getwch = lambda: next(seq)
+    return mod
+
+
+def test_msvcrt_reader_decodes_logical_keys(monkeypatch) -> None:
+    import sys as _sys
+
+    from loom_code.approval import _read_key_msvcrt
+
+    cases = [
+        (["\r"], "enter"),
+        (["\n"], "enter"),
+        (["\x03"], "esc"),   # Ctrl-C → SAFE cancel
+        (["\x1b"], "esc"),
+        (["\xe0", "H"], "up"),
+        (["\xe0", "P"], "down"),
+        (["\x00", "H"], "up"),     # alternate extended prefix
+        (["\xe0", "K"], "esc"),    # unknown extended key → safe
+        (["3"], "3"),
+        (["Y"], "y"),
+    ]
+    for keys, expected in cases:
+        monkeypatch.setitem(
+            _sys.modules, "msvcrt", _fake_msvcrt(keys)
+        )
+        assert _read_key_msvcrt() == expected, (keys, expected)
+
+
+def test_select_option_survives_missing_termios(monkeypatch) -> None:
+    """Regression: on Windows there is no termios — the selector's
+    bare ``import termios`` crashed /set_model with
+    ModuleNotFoundError for every pipx-on-Windows user. With the
+    dispatch fix, a missing termios falls through to the msvcrt
+    reader (faked here): ↓ then Enter must select option 2 and
+    never raise."""
+    import builtins
+    import sys as _sys
+
+    from loom_code import approval
+
+    real_import = builtins.__import__
+
+    def _no_termios(name, *args, **kwargs):
+        if name in ("termios", "tty"):
+            raise ImportError(f"No module named '{name}'")
+        return real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", _no_termios)
+    monkeypatch.setitem(
+        _sys.modules, "msvcrt", _fake_msvcrt(["\xe0", "P", "\r"])
+    )
+    monkeypatch.delitem(_sys.modules, "termios", raising=False)
+    monkeypatch.delitem(_sys.modules, "tty", raising=False)
+    # stdin must look like a TTY to reach the interactive path
+    monkeypatch.setattr(
+        approval.sys.stdin, "isatty", lambda: True, raising=False
+    )
+    result = approval._select_option(
+        [("a", "first"), ("b", "second"), ("c", "third")]
+    )
+    assert result == "b"  # ↓ moved 0→1, Enter picked it

{loom_code-0.1.1 → loom_code-0.1.3}/tests/test_checkpoint.py

@@ -155,3 +155,38 @@ def test_no_checkpoints_to_restore(tmp_path: Path) -> None:
     restored, err = cp.restore(root)
     assert restored is None
     assert "no checkpoint" in err.lower()
+
+
+def test_checkpoint_sees_same_second_same_size_edit(
+    tmp_path: Path,
+) -> None:
+    """Regression: the racy-git stat trap. The temp snapshot index was
+    seeded by COPYING the real index — inheriting its stat cache. An
+    edit that keeps the same SIZE and lands in the same mtime SECOND
+    as the last index write (agents write fast; CI is faster) made
+    ``git add`` trust the cached hash and skip the file, so the
+    snapshot captured the OLD content and /undo restored stale data.
+    Forge the collision deterministically with os.utime."""
+    import os
+    import time
+
+    root = tmp_path
+    _git(root, "init", "-q")
+    _git(root, "config", "user.email", "t@t.co")
+    _git(root, "config", "user.name", "t")
+    (root / ".loom").mkdir()
+    a = root / "a.py"
+    past = time.time() - 10  # older than the temp index's mtime →
+    a.write_text("v1\n")     # the entry is NOT "racy", so git's
+    os.utime(a, (past, past))  # racy-protection can't save us
+    _git(root, "add", "-A")
+    _git(root, "commit", "-qm", "init")
+    a.write_text("v2\n")  # same 3-byte size as "v1\n"
+    os.utime(a, (past, past))  # identical stat → cache trusted
+
+    snap, err = cp.checkpoint(root, summary="racy edit")
+    assert snap is not None, err
+    in_snapshot = _git(root, "show", f"{snap.sha}:a.py")
+    assert in_snapshot == "v2\n", (
+        f"snapshot captured stale content: {in_snapshot!r}"
+    )