chaincompiler-si 0.3.0__tar.gz

chaincompiler_si-0.3.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: chaincompiler-si
+Version: 0.3.0
+Summary: Self-Interpreter for the ChainCompiler chain dialect — an MCP that is also a skill
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: chainaios==0.3.0
+Requires-Dist: chaincompiler-accc==0.3.0
+Requires-Dist: corcc==0.3.0
+Requires-Dist: sccc==0.3.0
+Requires-Dist: agent-skilltree>=0.4.0
+Requires-Dist: fastmcp

chaincompiler_si-0.3.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chaincompiler-si"
+version = "0.3.0"
+description = "Self-Interpreter for the ChainCompiler chain dialect — an MCP that is also a skill"
+requires-python = ">=3.11"
+dependencies = ["chaincompiler==0.3.0", "chainaios==0.3.0", "chaincompiler-accc==0.3.0", "corcc==0.3.0", "sccc==0.3.0", "agent-skilltree>=0.4.0", "fastmcp"]
+
+[project.scripts]
+si-server = "si.server:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+si = ["skill/SKILL.md"]

chaincompiler_si-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chaincompiler_si-0.3.0/src/chaincompiler_si.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: chaincompiler-si
+Version: 0.3.0
+Summary: Self-Interpreter for the ChainCompiler chain dialect — an MCP that is also a skill
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: chainaios==0.3.0
+Requires-Dist: chaincompiler-accc==0.3.0
+Requires-Dist: corcc==0.3.0
+Requires-Dist: sccc==0.3.0
+Requires-Dist: agent-skilltree>=0.4.0
+Requires-Dist: fastmcp

chaincompiler_si-0.3.0/src/chaincompiler_si.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+pyproject.toml
+src/chaincompiler_si.egg-info/PKG-INFO
+src/chaincompiler_si.egg-info/SOURCES.txt
+src/chaincompiler_si.egg-info/dependency_links.txt
+src/chaincompiler_si.egg-info/entry_points.txt
+src/chaincompiler_si.egg-info/requires.txt
+src/chaincompiler_si.egg-info/top_level.txt
+src/si/__init__.py
+src/si/interp.py
+src/si/mcp_tree.py
+src/si/runtime.py
+src/si/scaffold.py
+src/si/server.py
+src/si/skill/SKILL.md
+tests/test_scaffold.py
+tests/test_si.py
+tests/test_si_regressions.py

chaincompiler_si-0.3.0/src/chaincompiler_si.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chaincompiler_si-0.3.0/src/chaincompiler_si.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+si-server = si.server:main

chaincompiler_si-0.3.0/src/chaincompiler_si.egg-info/requires.txt

@@ -0,0 +1,7 @@
+chaincompiler==0.3.0
+chainaios==0.3.0
+chaincompiler-accc==0.3.0
+corcc==0.3.0
+sccc==0.3.0
+agent-skilltree>=0.4.0
+fastmcp

chaincompiler_si-0.3.0/src/chaincompiler_si.egg-info/top_level.txt

@@ -0,0 +1 @@
+si

chaincompiler_si-0.3.0/src/si/__init__.py

@@ -0,0 +1,20 @@
+"""si — the Self-Interpreter for the ChainCompiler chain dialect.
+
+A Python dialect: the interpreter defers to native Python and only injects the
+ChainCompiler vocabulary. Ships as an MCP server (si.server) that is ALSO a skill
+(si/skill/SKILL.md), and can turn skill trees / exchange masters into MCPs.
+The execute arm of Compilero Bandito; the self-hosting capstone.
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .interp import interpret, make_env
+from .mcp_tree import build_tree_server, tree_to_mcp
+from .runtime import reachable, read_skill, walk
+from .scaffold import scaffold_repo, validate_node
+
+__all__ = [
+    "interpret", "make_env", "walk", "reachable", "read_skill",
+    "build_tree_server", "tree_to_mcp", "scaffold_repo", "validate_node", "__version__",
+]

chaincompiler_si-0.3.0/src/si/interp.py

@@ -0,0 +1,58 @@
+"""The Self-Interpreter for the chain dialect.
+
+The dialect is **a Python dialect** — so the interpreter does NOT re-wrap Python's
+native ops (arithmetic, control flow, data). It runs the program with Python, and
+only *injects the ChainCompiler vocabulary* as builtins: forge/gate/package the
+chains, build/walk skill trees, build exchanges, turn trees into MCPs. A program
+sets `result` (or the namespace is returned) — that's the value.
+
+Self-interpreter: programs can themselves forge languages, build trees, and emit
+MCPs — including ones that interpret further. ChainCompiler thereby runs itself.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+def make_env(extra: dict[str, Any] | None = None) -> dict[str, Any]:
+    """The dialect's vocabulary — ChainCompiler primitives, injected as names."""
+    import accc
+    import chaincompiler
+    import chainaios
+    import corcc
+    import sccc
+    import skilltree
+
+    from . import runtime
+    from .mcp_tree import tree_to_mcp
+
+    env: dict[str, Any] = {
+        # construct (the AIOS top-door now lives in chainaios; write_skill stays in the CC base)
+        "construct_language": chainaios.construct_language,
+        "write_skill": chaincompiler.write_skill,
+        "forge_ac": accc.forge, "package_ac": accc.package, "gate_ac": accc.gate,
+        "forge_cor": corcc.forge_persona, "package_cor": corcc.package, "lint_cor": corcc.lint,
+        "forge_sc": sccc.forge, "package_sc": sccc.package, "lint_sc": sccc.lint,
+        # organize
+        "SkillTree": skilltree.SkillTree, "TreeNode": skilltree.TreeNode,
+        "materialize": skilltree.materialize, "validate_tree": skilltree.validate,
+        "build_exchange": skilltree.build_exchange, "load_exchange": skilltree.load_exchange,
+        # execute / search / emit
+        "walk": runtime.walk, "reachable": runtime.reachable, "read_skill": runtime.read_skill,
+        "tree_to_mcp": tree_to_mcp,
+        "result": None,
+    }
+    if extra:
+        env.update(extra)
+    return env
+
+
+def interpret(source: str, *, env: dict[str, Any] | None = None) -> Any:
+    """Interpret a chain-dialect program. Returns `result` (or the eval of a single expr)."""
+    ns = make_env(env)
+    try:
+        code = compile(source, "<si>", "eval")          # single expression?
+        return eval(code, ns)
+    except SyntaxError:
+        exec(compile(source, "<si>", "exec"), ns)        # full program
+        return ns.get("result")

chaincompiler_si-0.3.0/src/si/mcp_tree.py

@@ -0,0 +1,57 @@
+"""Turn a skill tree (or exchange master) into an MCP server.
+
+`build_tree_server` makes a FastMCP server that exposes a materialized tree's
+skills as tools (list / read / walk). `tree_to_mcp` writes a tiny launcher so any
+tree or master becomes a runnable MCP — that's "make trees and masters into MCPs".
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from . import runtime
+
+
+def build_tree_server(root_dir: str | Path, root_name: str, *, name: str | None = None):
+    """A FastMCP server exposing the tree's skills. (Run with .run() for stdio.)"""
+    from fastmcp import FastMCP
+
+    root_dir = str(root_dir)
+    server = FastMCP(name or f"skilltree:{root_name}")
+
+    @server.tool()
+    def list_skills() -> list[str]:
+        """List every skill reachable from this tree's root."""
+        return runtime.reachable(root_dir, root_name)
+
+    @server.tool()
+    def read_skill(skill: str) -> str:
+        """Return the body of a skill in this tree by name."""
+        body = runtime.read_skill(root_dir, skill)
+        return body if body is not None else f"(no skill named {skill!r} in this tree)"
+
+    @server.tool()
+    def walk() -> dict:
+        """Return the full tree, traversed by following its breadcrumbs."""
+        return runtime.walk(root_dir, root_name)
+
+    return server
+
+
+_LAUNCHER = '''#!/usr/bin/env python3
+"""Auto-generated MCP launcher for skill tree {name!r} (root {root!r})."""
+from si.mcp_tree import build_tree_server
+
+if __name__ == "__main__":
+    build_tree_server({root_dir!r}, {root!r}, name={name!r}).run()
+'''
+
+
+def tree_to_mcp(root_dir: str | Path, root_name: str, out_path: str | Path,
+                *, name: str | None = None) -> Path:
+    """Write a runnable MCP launcher that serves this tree/master. Returns its path."""
+    out = Path(out_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(_LAUNCHER.format(root_dir=str(Path(root_dir).resolve()),
+                                    root=root_name, name=name or f"skilltree:{root_name}"),
+                   encoding="utf-8")
+    return out

chaincompiler_si-0.3.0/src/si/runtime.py

@@ -0,0 +1,62 @@
+"""The execute arm — walk a SkillTree by following its Read-breadcrumbs.
+
+This is what "running" a tree means: start at the root SKILL.md, parse the
+breadcrumb paths, and recurse. No new mechanism — the same breadcrumbs the
+validator checks are the ones the runtime follows. (The breadcrumb verb is the
+Read tool, not `cat`; the path is what we follow.)
+"""
+from __future__ import annotations
+
+from pathlib import Path
+import re
+
+_CRUMB = re.compile(r"`([^`]+/SKILL\.md)`")     # the backticked SKILL.md path, verb-agnostic
+_COORD = re.compile(r"^\d+(?:\.\d+)*-")         # a coordinate-addressed folder: `0.1-<name>`
+
+
+def _skill_md(node_dir: Path, name: str) -> Path:
+    return Path(node_dir) / ".claude" / "skills" / name / "SKILL.md"
+
+
+def _strip_front(text: str) -> str:
+    return text.split("---", 2)[-1].strip() if text.lstrip().startswith("---") else text.strip()
+
+
+def _walk_md(md: Path) -> dict:
+    node = {"name": md.parent.name, "skill": str(md), "children": []}
+    if not md.is_file():
+        node["error"] = "missing"
+        return node
+    node_dir = md.parents[3]          # <node>/.claude/skills/<name>/SKILL.md → <node>
+    for p in _CRUMB.findall(md.read_text(encoding="utf-8")):
+        child = Path(p)
+        if not child.is_absolute():       # a portable crumb is relative to the node's folder
+            child = node_dir / child      # (SkillTree ≥0.4.0); a localized one is absolute
+        node["children"].append(_walk_md(child))
+    return node
+
+
+def walk(root_dir: str | Path, root_name: str) -> dict:
+    """Traverse the tree from its root by following breadcrumbs. Returns a nested dict."""
+    return _walk_md(_skill_md(Path(root_dir), root_name))
+
+
+def reachable(root_dir: str | Path, root_name: str) -> list[str]:
+    """Flat list of every skill name reachable from the root (the execute frontier)."""
+    out: list[str] = []
+    def rec(n):
+        out.append(n["name"])
+        for c in n["children"]:
+            rec(c)
+    rec(walk(root_dir, root_name))
+    return out
+
+
+def read_skill(root_dir: str | Path, name: str) -> str | None:
+    """Search the tree for a skill by name; return its body (the search arm). A coordinate-addressed
+    tree names each skill's folder `<coord>-<name>`; the name matches with or without the coordinate."""
+    for md in Path(root_dir).rglob("SKILL.md"):
+        folder = md.parent.name
+        if folder == name or _COORD.sub("", folder) == name:
+            return _strip_front(md.read_text(encoding="utf-8"))
+    return None

chaincompiler_si-0.3.0/src/si/scaffold.py

@@ -0,0 +1,71 @@
+"""P5.1 — scaffold a federated node repo from a skill tree.
+
+When the SI emits an MCP, it can also stamp a ChainCompiler-SHAPED node repo: the
+skill tree (breadcrumbs), a marketplace registry that **federates under a
+parent**, a runnable MCP launcher, and a README. The fractal made real — each
+emitted MCP becomes a repo like ours, its marketplace joining under ours.
+
+Full CI mechanics (deploy workflow, site generator) are P5.2; this stamps the
+load-bearing shape: tree + registry + MCP + README, all validatable.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from skilltree import SkillTree, Violation, materialize
+from skilltree import validate as validate_tree
+
+from .mcp_tree import tree_to_mcp
+
+_NODE_README = """# {name} — a ChainCompiler node
+
+A self-contained skill tree, served as an MCP, federated under `{parent}`.
+
+- **Walk it** — start at `.claude/skills/{root}/SKILL.md` and Read each breadcrumb to descend.
+- **Serve it** — `python serve_mcp.py` (an MCP exposing this tree's skills).
+- **Marketplace** — see `registry.json`; this node registers under its parent.
+"""
+
+
+def scaffold_repo(name: str, tree: SkillTree | str | Path, out_dir: str | Path,
+                  *, parent: str | None = None) -> Path:
+    """Stamp a federated node repo at <out_dir>/<name>. Returns the repo path."""
+    if isinstance(tree, (str, Path)):
+        tree = SkillTree.load(tree)
+    repo = Path(out_dir) / name
+    repo.mkdir(parents=True, exist_ok=True)
+
+    materialize(tree, repo)                      # the node's skill tree (breadcrumbs)
+    root = tree.root.name
+
+    (repo / "registry.json").write_text(json.dumps({          # marketplace, federated
+        "name": name,
+        "parent": parent,                                      # null at the root; else a repo ref
+        "entries": [{"name": root, "kind": "tree", "manifest": "skilltree.json",
+                     "trust": "unverified"}],
+    }, indent=2), encoding="utf-8")
+
+    tree_to_mcp(repo, root, repo / "serve_mcp.py", name=f"node:{name}")   # the runnable MCP
+    (repo / "README.md").write_text(
+        _NODE_README.format(name=name, parent=parent or "(root)", root=root), encoding="utf-8")
+    return repo
+
+
+def validate_node(repo: str | Path) -> list[Violation]:
+    """Validate a scaffolded node: the tree + the registry + the MCP launcher."""
+    repo = Path(repo)
+    out = list(validate_tree(repo))
+    reg = repo / "registry.json"
+    if not reg.is_file():
+        out.append(Violation("error", repo.name, "missing registry.json"))
+    else:
+        try:
+            data = json.loads(reg.read_text(encoding="utf-8"))
+            if "parent" not in data or "entries" not in data:
+                out.append(Violation("error", repo.name, "registry.json missing parent/entries"))
+        except json.JSONDecodeError:
+            out.append(Violation("error", repo.name, "registry.json is not valid JSON"))
+    if not (repo / "serve_mcp.py").is_file():
+        out.append(Violation("error", repo.name, "missing serve_mcp.py launcher"))
+    return out

chaincompiler_si-0.3.0/src/si/server.py

@@ -0,0 +1,77 @@
+"""The Self-Interpreter as an MCP server (and it is also a skill — see si/skill/).
+
+Exposes the chain dialect to any MCP client:
+  - si_interpret(source)              run a chain-dialect program
+  - si_walk(root_dir, root_name)      traverse a materialized tree
+  - si_reachable(root_dir, root_name) list reachable skills
+  - si_read_skill(root_dir, skill)    fetch a skill body by name
+  - si_tree_to_mcp(root_dir, name, out) turn a tree/master into its own MCP
+  - si_search(root_dir, query)        BM25 over a tree, optionally coordinate-scoped
+
+Run:  python -m si.server   (or the `si-server` console script)
+
+The tool functions stay plain callables (registered, not rebound) so they're
+usable directly and in tests, not only over the wire.
+"""
+from __future__ import annotations
+
+import re
+
+from fastmcp import FastMCP
+
+from . import runtime
+from .interp import interpret
+from .mcp_tree import tree_to_mcp
+
+mcp = FastMCP("self-interpreter")
+
+
+def si_interpret(source: str) -> str:
+    """Interpret a ChainCompiler chain-dialect program; returns repr(result)."""
+    return repr(interpret(source))
+
+
+def si_walk(root_dir: str, root_name: str) -> dict:
+    """Traverse a materialized skill tree by following its breadcrumbs."""
+    return runtime.walk(root_dir, root_name)
+
+
+def si_reachable(root_dir: str, root_name: str) -> list[str]:
+    """List every skill reachable from a tree's root."""
+    return runtime.reachable(root_dir, root_name)
+
+
+def si_read_skill(root_dir: str, skill: str) -> str:
+    """Search a tree for a skill by name and return its body."""
+    body = runtime.read_skill(root_dir, skill)
+    return body if body is not None else f"(no skill named {skill!r})"
+
+
+def si_tree_to_mcp(root_dir: str, root_name: str, out_path: str) -> str:
+    """Turn a skill tree (or exchange master) into a runnable MCP launcher."""
+    return str(tree_to_mcp(root_dir, root_name, out_path))
+
+
+def si_search(root_dir: str, query: str, scope_coord: str | None = None, limit: int = 10) -> list[dict]:
+    """Search the skill tree (BM25), optionally scoped to a coordinate subtree (e.g. '0.1'). SkillTree's search hands a
+    query's words to FTS5 unquoted, so it raises on a query with no word and on an operator word (`NOT`, `AND`); this
+    door sends it the query's words alone, lowercased — FTS5's operators are capitals and its index folds case, so the
+    words match as before — and answers a query with no word with nothing."""
+    words = re.findall(r"\w+", query.lower())
+    if not words:
+        return []
+    from skilltree import search_tree
+    return search_tree(root_dir, " ".join(words), scope_coord=scope_coord, limit=limit)
+
+
+# Register as MCP tools without rebinding the names (keep them plain callables).
+for _fn in (si_interpret, si_walk, si_reachable, si_read_skill, si_tree_to_mcp, si_search):
+    mcp.tool()(_fn)
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

chaincompiler_si-0.3.0/src/si/skill/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: self-interpreter
+description: Run ChainCompiler chain-dialect programs and turn skill trees into MCPs. Use to forge languages, build/walk skill trees, or execute a cognition chain.
+---
+
+# Self-Interpreter (SI)
+
+The SI runs the **chain dialect** — a Python dialect whose vocabulary is the
+ChainCompiler primitives (`forge_ac`, `forge_cor`, `forge_sc`, `construct_language`,
+`SkillTree`, `TreeNode`, `materialize`, `walk`, `build_exchange`, `tree_to_mcp`, …).
+It defers to native Python for everything else.
+
+## As an MCP
+
+Start it: `python -m si.server`. Tools:
+
+- `si_interpret(source)` — run a chain-dialect program; returns `repr(result)`.
+- `si_walk(root_dir, root_name)` / `si_reachable(...)` — traverse a skill tree.
+- `si_read_skill(root_dir, skill)` — fetch a skill body by name.
+- `si_tree_to_mcp(root_dir, root_name, out)` — turn a tree/master into its own MCP.
+
+## Example program
+
+```python
+tree = SkillTree(TreeNode("root", "sc", children=[TreeNode("a", "ac"), TreeNode("b", "cor")]))
+materialize(tree, OUT)
+result = reachable(OUT, "root")     # the execute arm: walk the tree
+```

chaincompiler_si-0.3.0/tests/test_scaffold.py

@@ -0,0 +1,40 @@
+"""P5.1 tests: scaffold a federated node repo and validate it."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from si import scaffold_repo, validate_node
+from skilltree import SkillTree, TreeNode
+
+
+def _tree() -> SkillTree:
+    return SkillTree(TreeNode("cc-skill-tree", "sc", children=[
+        TreeNode("reason", "cor", children=[TreeNode("simplify", "ac")]),
+    ]))
+
+
+def test_scaffold_stamps_a_chaincompiler_shaped_node(tmp_path: Path):
+    repo = scaffold_repo("debug-node", _tree(), tmp_path, parent="github:sancovp/chaincompiler")
+    # the load-bearing shape: tree + registry + MCP launcher + README
+    assert (repo / ".claude" / "skills" / "cc-skill-tree" / "SKILL.md").is_file()
+    assert (repo / "skilltree.json").is_file()
+    assert (repo / "registry.json").is_file()
+    assert (repo / "serve_mcp.py").is_file()
+    assert (repo / "README.md").is_file()
+    assert validate_node(repo) == []
+
+
+def test_registry_federates_under_parent(tmp_path: Path):
+    repo = scaffold_repo("node-x", _tree(), tmp_path, parent="github:sancovp/chaincompiler")
+    reg = json.loads((repo / "registry.json").read_text())
+    assert reg["parent"] == "github:sancovp/chaincompiler"     # joins under ours
+    assert reg["entries"][0]["name"] == "cc-skill-tree"
+    assert reg["entries"][0]["trust"] == "unverified"          # untrusted by default
+
+
+def test_validate_node_catches_a_broken_node(tmp_path: Path):
+    repo = scaffold_repo("node-y", _tree(), tmp_path)
+    (repo / "serve_mcp.py").unlink()                            # remove the MCP launcher
+    issues = [v for v in validate_node(repo) if v.severity == "error"]
+    assert any("serve_mcp.py" in v.message for v in issues)

chaincompiler_si-0.3.0/tests/test_si.py

@@ -0,0 +1,85 @@
+"""SI tests: the dialect interpreter, the walk runtime, and tree→MCP."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from si import build_tree_server, interpret, reachable, read_skill, tree_to_mcp
+
+
+def test_interpret_single_expression():
+    assert interpret("2 + 3") == 5            # native Python op, not re-wrapped
+
+
+def test_interpret_builds_and_walks_a_tree(tmp_path: Path):
+    # a chain-dialect program: build a tree with injected primitives, walk it
+    src = """
+tree = SkillTree(TreeNode("root", "sc", children=[TreeNode("a", "ac"), TreeNode("b", "cor")]))
+materialize(tree, OUT)
+result = reachable(OUT, "root")
+"""
+    out = str(tmp_path / "tree")
+    result = interpret(src, env={"OUT": out})
+    assert result == ["root", "a", "b"]       # the execute arm followed the breadcrumbs
+
+
+def test_interpret_constructs_a_language(tmp_path: Path):
+    from corcc.notation import EINSTEIN
+    src = """
+result = construct_language("triage", ac_chain="[A] ⇒ [B] ⇒ |C|",
+                            cor_persona=PERSONA, db=DB, skills_dir=SK, out_dir=OUT)
+"""
+    bundle = interpret(src, env={
+        "PERSONA": EINSTEIN, "DB": str(tmp_path / "x.db"),
+        "SK": str(tmp_path / "sk"), "OUT": str(tmp_path / "out"),
+    })
+    assert bundle.ac.exists() and bundle.cor.exists() and bundle.sc.exists()
+
+
+def test_tree_to_mcp_writes_launcher(tmp_path: Path):
+    src = 'materialize(SkillTree(TreeNode("root","sc",children=[TreeNode("a","ac")])), OUT)'
+    out = str(tmp_path / "tree")
+    interpret(src, env={"OUT": out})
+    launcher = tree_to_mcp(out, "root", tmp_path / "serve_tree.py")
+    assert launcher.is_file()
+    text = launcher.read_text()
+    assert "build_tree_server" in text and "root" in text
+
+
+def test_build_tree_server_constructs(tmp_path: Path):
+    src = 'materialize(SkillTree(TreeNode("root","sc",children=[TreeNode("a","ac")])), OUT)'
+    out = str(tmp_path / "tree")
+    interpret(src, env={"OUT": out})
+    server = build_tree_server(out, "root")
+    assert server is not None
+    # the runtime the server wraps works
+    assert reachable(out, "root") == ["root", "a"]
+    assert read_skill(out, "a") is not None
+
+
+def test_walk_reaches_grandchildren_of_a_portable_tree(tmp_path: Path, monkeypatch):
+    # SkillTree ≥0.4.0 writes each breadcrumb relative to its node's folder; the walk must
+    # resolve it there, not against the working directory. A one-level tree hides the
+    # difference (a missing child still records its name), so this tree has two levels.
+    from si import walk
+    src = ('materialize(SkillTree(TreeNode("root","sc",children=['
+           'TreeNode("a","cor",children=[TreeNode("a1","ac")])])), OUT)')
+    out = tmp_path / "tree"
+    interpret(src, env={"OUT": str(out)})
+    monkeypatch.chdir(tmp_path)               # any working directory but the tree's own
+    assert reachable(out, "root") == ["root", "a", "a1"]
+
+    def errors(node):
+        own = [node["name"]] if "error" in node else []
+        return own + [e for child in node["children"] for e in errors(child)]
+
+    assert errors(walk(out, "root")) == []
+
+
+def test_read_skill_finds_a_skill_in_a_coordinate_tree(tmp_path: Path):
+    # materialize(coords=True) names each folder `<coord>-<name>`; read_skill finds it by its name
+    from skilltree import SkillTree, TreeNode, materialize
+    out = tmp_path / "tree"
+    materialize(SkillTree(TreeNode("root", "sc", children=[TreeNode("a", "ac")])), out, coords=True)
+    assert read_skill(out, "a") is not None
+    assert read_skill(out, "missing") is None
+

chaincompiler_si-0.3.0/tests/test_si_regressions.py

@@ -0,0 +1,32 @@
+"""The self-interpreter's search door never crashes on what a query holds: one with no word in it finds nothing, and
+an operator word (`NOT`, `AND`) is read as a word.
+
+A query with no word crashes glyphsteer's index (the public repository's bug sweeps, pull requests #1 and #2), and both
+crash SkillTree's search behind this door; the door sends SkillTree the query's words alone.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from si.server import si_search
+
+
+def _tree(root: Path) -> Path:
+    skill = root / "triage" / "SKILL.md"
+    skill.parent.mkdir(parents=True)
+    skill.write_text("---\nname: triage\ndescription: triage some text\n---\nbody text\n", encoding="utf-8")
+    return root
+
+
+def test_si_search_answers_a_query_with_no_word_with_nothing(tmp_path):
+    root = _tree(tmp_path)
+    for query in ('"', '?"!', '""', "   "):
+        assert si_search(str(root), query) == []
+    assert [h["name"] for h in si_search(str(root), "triage")] == ["triage"]
+
+
+def test_si_search_reads_operator_words_as_words(tmp_path):
+    root = _tree(tmp_path)
+    assert si_search(str(root), "NOT") == []                   # FTS5's NOT, unquoted, was a syntax error
+    for query in ("triage AND", "Triage OR NOT", "NEAR triage", "triage*"):
+        assert [h["name"] for h in si_search(str(root), query)] == ["triage"], query