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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loom-code
-Version: 0.1.2
+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

{loom_code-0.1.2 → 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.2"
+__version__ = "0.1.3"

{loom_code-0.1.2 → 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.2 → 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.2 → 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.2
+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

{loom_code-0.1.2 → 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.2 → loom_code-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "loom-code"
-version = "0.1.2"
+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.2"
+current_version = "0.1.3"
 search = "{current_version}"
 replace = "{new_version}"
 commit = true

{loom_code-0.1.2 → 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}"
+    )