bantamkit 0.37.1__tar.gz → 0.37.2__tar.gz

{bantamkit-0.37.1 → bantamkit-0.37.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bantamkit
-Version: 0.37.1
+Version: 0.37.2
 Summary: Persistent memory for coding agents: an MCP server for Claude Code, Claude Desktop, Cursor and VS Code Copilot, plus a Python library that lifts small-model agents. Install once, run offline.
 Project-URL: Homepage, https://github.com/Ink01101011/bantamkit
 Project-URL: Repository, https://github.com/Ink01101011/bantamkit
@@ -144,9 +144,9 @@ CPU architecture and Python minor version** (some wheels, such as `pydantic_core
 one platform only), copy `wheels/` across, and install from it:
 
 ```bash
-python -m pip download "bantamkit[mcp]==0.37.1" -d wheels
+python -m pip download "bantamkit[mcp]==0.37.2" -d wheels
 python -m venv <env>
-<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.37.1"
+<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.37.2"
 <env>/bin/bantamkit-mcp --install cursor
 ```
 

{bantamkit-0.37.1 → bantamkit-0.37.2}/README.md

@@ -113,9 +113,9 @@ CPU architecture and Python minor version** (some wheels, such as `pydantic_core
 one platform only), copy `wheels/` across, and install from it:
 
 ```bash
-python -m pip download "bantamkit[mcp]==0.37.1" -d wheels
+python -m pip download "bantamkit[mcp]==0.37.2" -d wheels
 python -m venv <env>
-<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.37.1"
+<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.37.2"
 <env>/bin/bantamkit-mcp --install cursor
 ```
 

{bantamkit-0.37.1 → bantamkit-0.37.2}/src/bantamkit/__init__.py

@@ -29,4 +29,4 @@ from bantamkit.structured import StructuredOutputError, extract_json, structured
 # file as its dynamic version source, so the wheel's metadata and the string the MCP
 # server advertises are the same committed bytes, and neither is a function of when
 # someone last ran `pip`.
-__version__ = "0.37.1"
+__version__ = "0.37.2"

{bantamkit-0.37.1 → bantamkit-0.37.2}/src/bantamkit/memory/component.py

@@ -375,7 +375,8 @@ class Memory:
 
         `only_present`: bound only when some root is a directory, so a machine with no skill
         has exactly the layers it had before the layer existed. A short-lived hook sees a
-        skill the moment it is installed; a long-lived server retries on recall.
+        skill the moment it is installed; a long-lived server retries on each public read
+        (`_bind_pending_skills`).
         """
         if not roots:
             return
@@ -384,6 +385,21 @@ class Memory:
             return
         self._layers.append((SKILL_LAYER, SkillStore(roots), False))
 
+    def _bind_pending_skills(self) -> None:
+        """The `[skill]` layer `_add_skills` held back, bound once a root has appeared.
+
+        Called on entry to every public reader of `_layers`, never between two reads in one
+        call: a layer inserted mid-call would shift the indexes that call already holds.
+        """
+        if self._pending_skills and any(r.is_dir() for r in self._pending_skills):
+            layer = (SKILL_LAYER, SkillStore(self._pending_skills), False)
+            position = next(
+                (i for i, (label, _, _) in enumerate(self._layers) if label == NATIVE_LAYER),
+                len(self._layers),
+            )
+            self._layers.insert(position, layer)
+            self._pending_skills = []
+
     def _add_native(self, native: str | Path | None) -> None:
         """The host's auto-memory as the last, read-only layer, when a directory was resolved."""
         if native is not None and str(native).strip():
@@ -673,14 +689,7 @@ class Memory:
         """
         if not 0.0 <= min_ratio <= 1.0:
             raise MemoryValidationError(MIN_RATIO_RANGE)
-        if self._pending_skills and any(r.is_dir() for r in self._pending_skills):
-            layer = (SKILL_LAYER, SkillStore(self._pending_skills), False)
-            position = next(
-                (i for i, (label, _, _) in enumerate(self._layers) if label == NATIVE_LAYER),
-                len(self._layers),
-            )
-            self._layers.insert(position, layer)
-            self._pending_skills = []
+        self._bind_pending_skills()
         budget = self.k if k is None else max(k, self.k)
         name = query.strip()
         lookup: str | None = None
@@ -739,6 +748,7 @@ class Memory:
 
     def layer_stores(self) -> list[tuple[str, Any, bool]]:
         """`(label, store, writable)` per layer, in precedence order (the touch graph's input)."""
+        self._bind_pending_skills()
         return list(self._layers)
 
     def recall_file(
@@ -758,6 +768,7 @@ class Memory:
         `store.lookup(name, stamp=False)`, and a name no layer holds any more is passed over.
         `status` is `answered` when a fact is shown, else `none`.
         """
+        self._bind_pending_skills()
         rf = _recall_file_mod
         budget = self.k if k is None else max(k, self.k)
         ignored = "" if query is None else f"\n{rf.QUERY_IGNORED}"
@@ -1054,11 +1065,13 @@ class Memory:
 
     def inject_candidates(self, prompt: str, head: str | None = None) -> list[Fact]:
         """What the `UserPromptSubmit` hook would inject for `prompt`, before its byte cap."""
+        self._bind_pending_skills()
         got = self._pooled(prompt, 3, RECALL_MIN_SCORE_RATIO, head=head)
         return [fact for _, fact in got[0]]
 
     def rank_all(self, prompt: str, depth: int = 50, head: str | None = None) -> list[Fact]:
         """The ranking past the gate, `depth` deep: what recall@3 is measured on."""
+        self._bind_pending_skills()
         got = self._pooled(prompt, depth, RECALL_MIN_SCORE_RATIO, head=head)
         return [fact for _, fact in got[0]]
 
@@ -1110,6 +1123,7 @@ class Memory:
         name order, each with its body's first `BODY_EXCERPT` code points, plus the
         instructions for writing theirs. A name whose fact cannot be read is passed over and
         is not counted in `remaining`."""
+        self._bind_pending_skills()
         missing = self._missing(self._named_facts())
         remaining = len(missing)
         facts: list[dict[str, str]] = []
@@ -1147,6 +1161,7 @@ class Memory:
         """`memory_queries {"facts": [...]}` (Q6): every item is checked before anything is
         written, and the first bad one refuses the whole call (S5-S8). Then one write per
         layer sidecar; one that cannot be written is S9. `queries: []` removes an entry."""
+        self._bind_pending_skills()
         labels = [label for label, _, _ in self._layers]
         plan: dict[int, dict[str, tuple[list[str], str] | None]] = {}
         for i, item in enumerate(facts):

{bantamkit-0.37.1 → bantamkit-0.37.2}/src/bantamkit/skillaudit.py

@@ -328,6 +328,10 @@ class _Skill:
     #: `BAD_*` when the frontmatter is malformed, `None` when it is not.
     malformed: str | None = None
     phrases: tuple[str, ...] = field(default_factory=tuple)
+    #: Reached through a symlinked directory (#245); `_drop_aliases` reads it.
+    linked: bool = False
+    #: The real path of the directory holding the file, compared and never reported.
+    real: str = ""
 
     @property
     def in_plugin(self) -> bool:
@@ -368,34 +372,77 @@ def _relative_parts(path: Path, root: Path) -> list[str]:
     return list(path.relative_to(root).parts)
 
 
-def _scan_tree(root: Path) -> tuple[list[Path], list[tuple[str, str, str]]]:
-    """One walk, two answers: every `SKILL.md` under `root`, and every VERSION DIRECTORY.
+def _scan_tree(root: Path) -> tuple[list[Path], list[tuple[str, str, str]], frozenset[Path]]:
+    """One walk, three answers: every `SKILL.md` under `root`, every VERSION DIRECTORY, and
+    which of those files were reached THROUGH a symlinked directory.
 
-    `os.walk` yields directory entries in whatever order the filesystem hands them over, and
-    two machines hand them over differently. Sorting is what makes the scan order — and
-    therefore the omission `what` lists and the duplicate tie-break's "last wins" — the same
-    everywhere. `followlinks` stays off: a symlink loop is not a skill catalogue.
+    The walk is depth-first with each directory's entries in code-point order, and `found` is
+    sorted by path parts after it, which is the same order. Sorting is what makes the scan
+    order — and therefore the omission `what` lists, the duplicate tie-break's "last wins" and
+    which of two links to one directory is walked — the same everywhere. A directory that will
+    not open is skipped in silence, as `os.walk(onerror=None)` did.
+
+    SYMLINKED DIRECTORIES ARE FOLLOWED (#245, #234 N4). A skill directory a person linked into
+    `~/.claude/skills` is loaded by the host every session, so a walk that stops at the link
+    under-reports the catalogue by every such skill. A link is NOT followed when its real path
+    is on the chain of real directories above it (a link back to an ancestor: the loop) or is
+    a directory an earlier link in this walk already entered (two links to one directory: the
+    second is not walked). A dangling link is not a directory and is passed over; only a
+    dangling link NAMED `SKILL.md` is listed, and it is then `unreadable`, as before. Each
+    file reached through a link is in the third answer, and `_drop_aliases` later drops it
+    when its real directory is already counted — so a skill is counted once per real
+    directory, however many names reach it.
 
     THE SECOND ANSWER IS WHY THIS FUNCTION IS NOT JUST A FILE LIST. A version directory
     declares itself by holding a `skills/` directory — `<marketplace>/<plugin>/<version>/
     skills`, the first four segments of the path shape a skill has — and it declares itself
     whether or not anything under it can be read. Resolving over the files instead makes an
     EMPTY newer version invisible, so an older directory wins in silence; see
-    `_resolve_versions`. A directory reached by following a symlink is not walked into on
-    either runtime, so it declares nothing on either.
+    `_resolve_versions`. A directory reached through a symlink declares itself like any other,
+    because every skill under it carries that version and the resolution must know it.
     """
     found: list[Path] = []
     versions: list[tuple[str, str, str]] = []
-    for dirpath, dirnames, filenames in os.walk(root, onerror=None):
-        dirnames.sort()
-        parts = _relative_parts(Path(dirpath), root)
-        if len(parts) == VERSION_PATH_SEGMENTS and parts[3] == SKILLS_SEGMENT:
-            versions.append((parts[0], parts[1], parts[2]))
-        if SKILL_FILE in filenames:
-            found.append(Path(dirpath) / SKILL_FILE)
+    linked: set[Path] = set()
+    entered: set[str] = set()
+
+    def visit(rel: list[str], chain: frozenset[str], via_link: bool) -> None:
+        here = root.joinpath(*rel)
+        try:
+            with os.scandir(here) as it:
+                entries = sorted(it, key=lambda e: e.name)
+        except OSError:
+            return
+        if len(rel) == VERSION_PATH_SEGMENTS and rel[3] == SKILLS_SEGMENT:
+            versions.append((rel[0], rel[1], rel[2]))
+        for entry in entries:
+            try:
+                directory = entry.is_dir()
+            except OSError:
+                directory = False
+            if not directory:
+                if entry.name == SKILL_FILE:
+                    path = here / SKILL_FILE
+                    found.append(path)
+                    if via_link:
+                        linked.add(path)
+                continue
+            real = os.path.realpath(here / entry.name)
+            if real in chain:
+                continue
+            # A Windows junction is a link to Node's `isSymbolicLink()`; it is one here too.
+            if entry.is_symlink() or getattr(entry, "is_junction", lambda: False)():
+                if real in entered:
+                    continue
+                entered.add(real)
+                visit([*rel, entry.name], chain | {real}, True)
+            else:
+                visit([*rel, entry.name], chain | {real}, via_link)
+
+    visit([], frozenset({os.path.realpath(root)}), False)
     found.sort(key=lambda p: p.parts)
     versions.sort()
-    return found, versions
+    return found, versions, frozenset(linked)
 
 
 def _walk(root: Path) -> list[Path]:
@@ -403,6 +450,38 @@ def _walk(root: Path) -> list[Path]:
     return _scan_tree(root)[0]
 
 
+def _reach(skill: _Skill, path: Path, linked: frozenset[Path]) -> _Skill:
+    """Stamp how the walk reached `path`: through a link or not, and the real directory."""
+    skill.linked = path in linked
+    skill.real = os.path.realpath(path.parent)
+    return skill
+
+
+def _drop_aliases(found: list[_Skill]) -> list[_Skill]:
+    """One counted skill per REAL directory (#245): a skill reached through a symlink is
+    dropped when its real directory is already counted — by a skill reached without a link
+    anywhere in the scan, or by an earlier linked one in scan order.
+
+    It runs after the version resolution and before the name dedupe, over the skills still
+    counted, and it removes the alias from the list rather than recording an omission: one
+    directory on disk is one skill, not a duplicate of itself. A skill reached WITHOUT a link
+    is never dropped here, so two roots that overlap on disk behave exactly as before, and a
+    skill #206 promoted by symlink is still counted once, at its source, because bantamkit's
+    roots come before the host's. Running after the resolution keeps a version alias (a
+    linked version directory that wins) counted rather than dropped in favour of a loser.
+    """
+    direct = {s.real for s in found if s.omitted is None and not s.linked}
+    seen: set[str] = set()
+    out: list[_Skill] = []
+    for skill in found:
+        if skill.omitted is None and skill.linked:
+            if skill.real in direct or skill.real in seen:
+                continue
+            seen.add(skill.real)
+        out.append(skill)
+    return out
+
+
 def _scalar_close(value: str, quote: str) -> int:
     """Index of the quote that CLOSES a scalar opened at index 0, or `-1` when none does.
 
@@ -719,10 +798,11 @@ def _scan(
     right from one that is right for two cancelling reasons.
     """
     base = Path(root)
-    files, version_dirs = _scan_tree(base)
-    found = [_load(path, base) for path in files]
+    files, version_dirs, linked = _scan_tree(base)
+    found = [_reach(_load(path, base), path, linked) for path in files]
     _apply_enabled(found, enabled)
     _resolve_versions(found, version_dirs, versions)
+    found = _drop_aliases(found)
     _apply_dedupe(found)
     return found
 
@@ -814,15 +894,16 @@ def scan_roots(
     version_dirs: list[tuple[str, str, str]] = []
     for label, root in roots:
         base = Path(root)
-        files, dirs = _scan_tree(base)
+        files, dirs, linked = _scan_tree(base)
         for path in files:
-            skill = _load(path, base)
+            skill = _reach(_load(path, base), path, linked)
             skill.relpath = f"{label}/{skill.relpath}"
             found.append(skill)
         version_dirs.extend(dirs)
     version_dirs.sort()
     _apply_enabled(found, enabled)
     _resolve_versions(found, version_dirs, versions)
+    found = _drop_aliases(found)
     _apply_dedupe(found)
     return found
 

{bantamkit-0.37.1 → bantamkit-0.37.2}/src/bantamkit/skilldraft.py

@@ -497,8 +497,10 @@ def draft(
     home: str | Path,
     cwd: str | None,
     now: str,
+    own: str | Path | None = None,
 ) -> DraftOutcome:
-    """Walk `chain` for one proposals record; log the outcome; never write a skill."""
+    """Walk `chain` for one proposals record; log the outcome; never write a skill. `own` is
+    passed to the gate (#247: a split's halves are gated with the skill being split as `own`)."""
     b = bundle(cluster)
     system, user = prompt(b)
     unreachable: list[str] = []
@@ -518,7 +520,7 @@ def draft(
             unreachable.append(d.label)
             continue
         text = unfence(answer)
-        g = gate(text, b, home, cwd)
+        g = gate(text, b, home, cwd, own=own)
         outcome = DraftOutcome(d.label, g.ok, text if g.ok else None, g.reasons, unreachable)
         break
     if outcome is None:

{bantamkit-0.37.1 → bantamkit-0.37.2}/src/bantamkit/skillfile.py

@@ -306,8 +306,12 @@ def _fsync(fd: int) -> None:
     os.fsync(fd)
 
 
+class _Taken(SkillFileError):
+    """A temp name already held by an entry this call did not make."""
+
+
 def _taken(path: str) -> SkillFileError:
-    return SkillFileError(f"temp path {path} already exists; refusing to write through it")
+    return _Taken(f"temp path {path} already exists; refusing to write through it")
 
 
 def _write(path: str, data: bytes) -> None:
@@ -344,6 +348,26 @@ def _mkdir_temp(path: str) -> None:
         raise _taken(path) from None
 
 
+# How many temp names one write tries before it refuses. A taken name is passed over, never
+# written through (#250): an orphan a killed writer left under a recycled pid must not block
+# every later writer, so only a run of taken names this long is refused.
+TEMP_TRIES = 8
+
+
+def _claim(target: Path | str, kind: str, make: Callable[[str], None]) -> str:
+    """A temp name beside `target` that `make` created exclusively; the last refusal if none."""
+    for _ in range(TEMP_TRIES - 1):
+        path = _temp(target, kind)
+        try:
+            make(path)
+        except _Taken:
+            continue
+        return path
+    path = _temp(target, kind)
+    make(path)
+    return path
+
+
 def _check_rel(rel: str) -> list[str]:
     parts = rel.split("/")
     if (
@@ -363,8 +387,7 @@ def _build(target: Path, files: dict[str, bytes]) -> str:
     for rel in rels:
         _check_rel(rel)
     target.parent.mkdir(parents=True, exist_ok=True)
-    tmp = _temp(target, "tmp")
-    _mkdir_temp(tmp)
+    tmp = _claim(target, "tmp", _mkdir_temp)
     try:
         for rel in rels:
             path = os.path.join(tmp, *rel.split("/"))
@@ -393,6 +416,23 @@ def write_dir_atomic(target: Path | str, files: dict[str, bytes]) -> None:
         raise
 
 
+def rewrite_dir_atomic(target: Path | str, files: dict[str, bytes]) -> None:
+    """The existing directory `target` replaced by `files` in one rename, no backup (#244).
+
+    The new tree is built in an exclusively claimed temp dir beside `target`, the old one is
+    set aside into another (#250), and on any failure the old directory is back in place.
+    """
+    target = Path(target)
+    if not target.is_dir() or target.is_symlink():
+        raise SkillFileError(f"no skill at {target}")
+    tmp = _build(target, files)
+    try:
+        _swap_in(tmp, target)
+    except BaseException:
+        shutil.rmtree(tmp, ignore_errors=True)
+        raise
+
+
 def _copy_tree(src: Path, dst: str) -> None:
     """Directories and regular files into the existing `dst`, bytes as they are; a symlink is
     not followed or copied."""
@@ -414,8 +454,7 @@ def _set_aside(target: Path) -> tuple[str, str]:
     A rename onto the bare temp name would replace an empty dir planted there (POSIX allows
     it), so the name is claimed by an exclusive mkdir and `target` goes inside it (#250).
     """
-    old = _temp(target, "old")
-    _mkdir_temp(old)
+    old = _claim(target, "old", _mkdir_temp)
     moved = os.path.join(old, target.name)
     try:
         _rename(str(target), moved)
@@ -462,8 +501,7 @@ def _new_backup(backup_root: Path | str, name: str, now: str, fill: Callable[[st
     while os.path.lexists(final):
         n += 1
         final = home / f"{base}-{n}"
-    tmp = _temp(final, "tmp")
-    _mkdir_temp(tmp)  # outside the try: a taken name is not ours to remove
+    tmp = _claim(final, "tmp", _mkdir_temp)  # outside the try: a taken name is not ours to remove
     try:
         fill(tmp)
         _rename(tmp, str(final))
@@ -541,8 +579,7 @@ def undo(backup_root: Path | str, name: str, target: Path | str) -> str:
         shutil.rmtree(backup, ignore_errors=True)
         return f"removed {name}; it did not exist before {entry}"
     target.parent.mkdir(parents=True, exist_ok=True)
-    tmp = _temp(target, "tmp")
-    _mkdir_temp(tmp)  # outside the try: a taken name is not ours to remove
+    tmp = _claim(target, "tmp", _mkdir_temp)  # outside the try: a taken name is not ours to remove
     try:
         _copy_tree(backup, tmp)
         _swap_in(tmp, target)
@@ -566,18 +603,28 @@ def history_add(skill_dir: Path | str, version: int) -> None:
     _write_file_atomic(dst, data)
 
 
+def _unlink_quietly(path: str) -> None:
+    try:
+        os.unlink(path)
+    except OSError:
+        pass
+
+
 def _write_file_atomic(path: Path, data: bytes) -> None:
-    tmp = _temp(path, "tmp")
+    def make(tmp: str) -> None:
+        try:
+            _write(tmp, data)
+        except _Taken:
+            raise  # what sits at a taken name is not ours to unlink
+        except BaseException:
+            _unlink_quietly(tmp)
+            raise
+
+    tmp = _claim(path, "tmp", make)
     try:
-        _write(tmp, data)
         _rename(tmp, str(path))
-    except SkillFileError:
-        raise  # the temp name was taken: what sits there is not ours to unlink
     except BaseException:
-        try:
-            os.unlink(tmp)
-        except OSError:
-            pass
+        _unlink_quietly(tmp)
         raise