chaincompiler-si 0.3.0__py3-none-any.whl

chaincompiler_si-0.3.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,12 @@
+si/__init__.py,sha256=LiAsjD1XqFcNXB9Xb6pRZIhMpUorjskBl0fHytJ7Ado,795
+si/interp.py,sha256=FGCTluGe_zEBaXUhwm_DEA2kp6HVT9aHkiJedHPf7UQ,2460
+si/mcp_tree.py,sha256=YQIm7SYEbgmrDEM9t_RCQe32mxqlYJ1mCkQKbJSlBBA,2081
+si/runtime.py,sha256=2ZfRVBCZqGa_ySb77DE8qPTGDjtFcjKhQQBUwZGCEY4,2514
+si/scaffold.py,sha256=TlwSCtB0GovfdpoVy8B5fCTqkN1faWOikT7vs8KWenQ,3077
+si/server.py,sha256=uu5STYqrxdixvpvMs3JbOFl9BW7uXQ6TTNNj_aMXmMI,2925
+si/skill/SKILL.md,sha256=ZVVcQ4T5g5pP84_lnhIG-34zxRbwqSC0ltSC_Fk6zJ0,1115
+chaincompiler_si-0.3.0.dist-info/METADATA,sha256=gAh6iaQT2d3E12MO4BHc36bew92EILd4q8dj00Fvcwg,403
+chaincompiler_si-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+chaincompiler_si-0.3.0.dist-info/entry_points.txt,sha256=xVUAifQ0n2exgnBr_RRWfcoM-4vReFS6FqztxRYNy_M,45
+chaincompiler_si-0.3.0.dist-info/top_level.txt,sha256=Gefnx6gufmA_0rBNGHzBXTHNRIj_pTEQKMF9CbSP1mw,3
+chaincompiler_si-0.3.0.dist-info/RECORD,,

chaincompiler_si-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

chaincompiler_si-0.3.0.dist-info/entry_points.txt

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

chaincompiler_si-0.3.0.dist-info/top_level.txt

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

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__",
+]

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")

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

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

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

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()

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
+```