sliceagent 0.1.1__tar.gz → 0.1.2__tar.gz

{sliceagent-0.1.1 → sliceagent-0.1.2}/CHANGELOG.md

@@ -5,6 +5,20 @@ this project aims for [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.2] — 2026-07-02
+
+Nothing may hang the user — three fixes from a live first-run reproduction.
+
+### Fixed
+- **Repo-map walk is hard-bounded** (`max_dirs` budget): the first slice build can no longer hang for
+  minutes when the workspace root is huge (a home directory mistaken for a project, a giant monorepo).
+  Output caps existed; now the walk itself is bounded — worst case ~1s, maps what it saw.
+- **The OS-account home never counts as a project root**, independent of `$HOME`: a stray
+  `package.json` in the real home no longer turns the entire home directory into a "project"
+  (the prior guard compared against `$HOME`, which containers/sandboxes/sudo can override).
+- **Ctrl-C during the slice build cancels the turn cleanly** (`· cancelled`) instead of crashing the
+  REPL with a traceback — the build phase ran before the turn's interrupt handling.
+
 ## [0.1.1] — 2026-07-02
 
 First-run onboarding, hardened by a live stranger walkthrough.

{sliceagent-0.1.1 → sliceagent-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sliceagent
-Version: 0.1.1
+Version: 0.1.2
 Summary: A coding agent with a new context-engineering framework: bounded, deterministic, reconstructed context (slice architecture) — built for long-horizon work.
 Author: TT-Wang
 License-Expression: MIT

{sliceagent-0.1.1 → sliceagent-0.1.2}/src/sliceagent/__init__.py

@@ -1,3 +1,3 @@
 """sliceagent — a memory-native coding agent (deterministic, bounded, reconstructed context)."""
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"

{sliceagent-0.1.1 → sliceagent-0.1.2}/src/sliceagent/cli.py

@@ -831,7 +831,13 @@ def main() -> None:
             _stats["topic"] = one_line(session.active().goal, 40) if session.active_id else ""
             record_user(session.active(), line)  # short-range continuity: the RECENT CONVERSATION tier
             _expand_mentions(line)               # @path → pin the file into OPEN FILES
-            build = make_build_slice(session, tools, retriever, memory, line, session.session_id)
+            try:
+                # slice-build phase happens BEFORE run_turn's own KeyboardInterrupt handling — a ctrl-c
+                # here (e.g. during the one-time repo-map build) must cancel the turn, not crash the REPL.
+                build = make_build_slice(session, tools, retriever, memory, line, session.session_id)
+            except KeyboardInterrupt:
+                print("\n  · cancelled")
+                continue
             if os.environ.get("AGENT_TIMING"):   # per-turn latency breakdown (build vs model) → find the hang
                 import time as _tt
                 _b = build

{sliceagent-0.1.1 → sliceagent-0.1.2}/src/sliceagent/sensory_cortex.py

@@ -94,6 +94,17 @@ def _home() -> Optional[Path]:
         return None
 
 
+def _os_home() -> Optional[Path]:
+    """The account's home from the OS user database — independent of the $HOME env var. Guards the
+    home-is-not-a-project rule even when $HOME is overridden (containers, sudo, test sandboxes):
+    without this, a stray package.json in the real home turns the whole home dir into a 'project'."""
+    try:
+        import pwd
+        return Path(pwd.getpwuid(os.getuid()).pw_dir).resolve()
+    except (ImportError, KeyError, OSError):   # pwd is POSIX-only; degrade to the env-based home
+        return None
+
+
 def _marker_root(cwd: Path) -> Optional[Path]:
     """Nearest ancestor (≤6 levels) that looks like a project root, or ``None``.
 
@@ -104,11 +115,11 @@ def _marker_root(cwd: Path) -> Optional[Path]:
         current = cwd.resolve()
     except (OSError, RuntimeError, ValueError):
         return None
-    home = _home()
+    homes = {h for h in (_home(), _os_home()) if h is not None}
     for depth, parent in enumerate([current, *current.parents]):
         if depth > 6:
             break
-        if parent == home:
+        if parent in homes:
             continue
         try:
             for marker in _PROJECT_MARKERS:
@@ -443,7 +454,8 @@ _CODE_SUFFIX = (".py", ".js", ".ts", ".jsx", ".tsx", ".go", ".rs", ".java", ".rb
                 ".exs", ".clj", ".r", ".jl", ".vue", ".sql")
 
 
-def repo_map(root: str, *, max_entries: int = 300, max_per_dir: int = 25, max_chars: int = 12000) -> str:
+def repo_map(root: str, *, max_entries: int = 300, max_per_dir: int = 25, max_chars: int = 12000,
+             max_dirs: int = 4000) -> str:
     """A compact, ignore-aware STRUCTURAL MAP of the project (SENSORY CORTEX — the derived-view tier-B
     resident view, memoized for the session, never a persisted store): directories with their files,
     pruned of VCS/venv/cache + asset/log noise, RANKED by source-density so the real code tree shows
@@ -456,8 +468,17 @@ def repo_map(root: str, *, max_entries: int = 300, max_per_dir: int = 25, max_ch
     if not root or not os.path.isdir(root):
         return ""
     rows: list[tuple[str, list[str], int, int]] = []  # (rel, files, total, code_count)
+    walked = 0
     try:
         for dirpath, dirnames, filenames in os.walk(root):  # symlinks not followed
+            # HARD WALK BUDGET — the invariant is that repo_map completes in bounded time on ANY root.
+            # max_entries/max_chars cap the OUTPUT but only after the walk; without this, a huge root
+            # (a home dir mistaken for a project, a giant monorepo) hangs the first slice build for
+            # minutes inside os.walk. Past the budget we map what we saw — bounded beats complete.
+            walked += 1
+            if walked > max_dirs:
+                dirnames[:] = []
+                break
             dirnames[:] = sorted(d for d in dirnames if not _is_ignored(d))
             files = sorted(f for f in filenames
                            if not _is_ignored(f) and not f.endswith(_MAP_SKIP_SUFFIX))

sliceagent-0.1.2/tests/test_repo_map_bounded.py

@@ -0,0 +1,91 @@
+"""The repo-map walk must be BOUNDED — it can never hang the first slice build, no matter what the
+workspace root is (a huge monorepo, or a home dir that a stray package.json turned into a 'project').
+Found live: launching from /Users/<u> with HOME overridden made os.walk crawl the entire home dir for
+minutes; ctrl-c then killed the REPL with a traceback. Invariant: repo_map completes within its walk
+budget on ANY root, and the OS-account home never counts as a project root regardless of $HOME.
+Run: PYTHONPATH=src python tests/test_repo_map_bounded.py
+"""
+import os
+import pathlib
+import sys
+import time
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from sliceagent import sensory_cortex as sc  # noqa: E402
+
+CHECKS = []
+def check(fn):
+    CHECKS.append(fn)
+    return fn
+
+
+def _make_tree(root: pathlib.Path, n_dirs: int) -> None:
+    for i in range(n_dirs):
+        d = root / f"pkg{i:03d}"
+        d.mkdir(parents=True)
+        (d / "mod.py").write_text("x = 1\n")
+
+
+@check
+def walk_stops_at_the_dir_budget():
+    import tempfile
+    root = pathlib.Path(tempfile.mkdtemp())
+    _make_tree(root, 60)
+    out = sc.repo_map(str(root), max_dirs=10)
+    # bounded: only what the budget allowed got mapped (root dir itself may count as one visit)
+    mapped = [ln for ln in out.splitlines() if ln.strip()]
+    assert 0 < len(mapped) <= 10, f"expected ≤10 mapped dirs under a 10-dir budget, got {len(mapped)}"
+
+
+@check
+def bounded_walk_is_fast_even_on_a_big_tree():
+    import tempfile
+    root = pathlib.Path(tempfile.mkdtemp())
+    _make_tree(root, 300)
+    t0 = time.monotonic()
+    out = sc.repo_map(str(root), max_dirs=50)
+    dt = time.monotonic() - t0
+    assert out, "map must still be produced within the budget"
+    assert dt < 5.0, f"bounded walk took {dt:.1f}s — the budget is not bounding"
+
+
+@check
+def default_budget_maps_a_normal_project_fully():
+    import tempfile
+    root = pathlib.Path(tempfile.mkdtemp())
+    _make_tree(root, 20)
+    out = sc.repo_map(str(root))          # default max_dirs — far above a normal project
+    assert sum(1 for ln in out.splitlines() if "mod.py" in ln) == 20, "normal projects must be unaffected"
+
+
+@check
+def os_account_home_never_counts_as_a_project_even_with_home_overridden():
+    import tempfile
+    fake_os_home = pathlib.Path(tempfile.mkdtemp())          # stands in for pw_dir
+    (fake_os_home / "package.json").write_text("{}")          # the stray marker that caused the live bug
+    orig = sc._os_home
+    sc._os_home = lambda: fake_os_home.resolve()
+    try:
+        # $HOME points elsewhere (the live-repro condition), yet the OS home must still be skipped
+        assert sc._marker_root(fake_os_home) is None, \
+            "a marker in the OS-account home must not make the home a project"
+        # ...while a real project UNDER the home is still detected
+        proj = fake_os_home / "code" / "myproj"
+        proj.mkdir(parents=True)
+        (proj / "pyproject.toml").write_text("[project]\nname='x'\n")
+        got = sc._marker_root(proj)
+        assert got is not None and got.name == "myproj", f"real subproject must still resolve, got {got}"
+    finally:
+        sc._os_home = orig
+
+
+if __name__ == "__main__":
+    ok = 0
+    for fn in CHECKS:
+        try:
+            fn(); ok += 1; print(f"PASS {fn.__name__}")
+        except Exception as e:  # noqa: BLE001
+            print(f"FAIL {fn.__name__}: {type(e).__name__}: {e}")
+    print(f"\n{ok}/{len(CHECKS)} passed")
+    sys.exit(0 if ok == len(CHECKS) else 1)