chaincompiler 0.3.0__py3-none-any.whl

chaincompiler/__init__.py

@@ -0,0 +1,31 @@
+"""chaincompiler — the ChainCompiler BASE: the generic compiler-compiler (DESIGN.md §2).
+
+This package imports only DOWN (APE + honeyc + rulecatcher). It is the machine the *CC are MADE FROM:
+  - forge   : the generic "forge a language" core (Language / forge / gate_language / grammar / package_skill)
+  - bridge  : the HoneyC compile seam + the rulecatcher grammar seam (learn / gate, re-exported from APE)
+  - prime   : build_prime — the re-injectable prime block
+  - skillpack / persona : SKILL.md packaging + the glyph-persona-program compiler
+
+ACCC / CORCC / SCCC build ON this base (they import CC). CC NEVER imports the *CC. The Bandit AIOS
+application that orchestrates AC+CoR+SC (construct_language / GBA / HBA / COG) lives ABOVE the *CC in the
+`chainaios` package — it was extracted out of here precisely so this base no longer imports the *CC.
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .bridge import compile_chain, gate, learn
+from .prime import build_prime
+from .skillpack import skill_markdown, slugify, write_skill
+# the generic compiler-compiler core — the machine the *CC are MADE FROM (DESIGN.md §2). Imports only APE.
+from .forge import Language, forge, gate_language, grammar, package_skill
+# re-export the APE cognition helper the *CC need, so they route through CC (not around it to APE):
+from prompt_engineering import cor_skeleton
+
+__all__ = [
+    "learn", "gate", "compile_chain", "build_prime",
+    "write_skill", "skill_markdown", "slugify",
+    # the forge core (ACCC/CORCC/SCCC import these DOWN from here):
+    "Language", "forge", "gate_language", "grammar", "package_skill", "cor_skeleton",
+    "__version__",
+]

chaincompiler/bridge.py

@@ -0,0 +1,36 @@
+"""The HoneyC seam (compile a gated chain into lenses) + re-exports of the rulecatcher seam.
+
+The rulecatcher seam — `learn` / `gate` / `grammar_lines` / `foreign_tokens` — MOVED DOWN to
+`prompt_engineering.grammar` (REBUILD-SPEC.md §4 — single source of truth, D1). chaincompiler keeps the
+HoneyC-wrapping `compile_chain` (HoneyC is chaincompiler's concern, §6) and RE-EXPORTS the grammar seam,
+so `from chaincompiler.bridge import learn, gate, grammar_lines` and `from chaincompiler import learn,
+gate` stay byte-stable.
+"""
+from __future__ import annotations
+
+from honeyc.normalize import normalize
+from honeyc.parser import parse_text
+from honeyc.render import render
+
+# the rulecatcher seam now lives in the base (DOWN edge):
+from prompt_engineering.grammar import (
+    ForeignToken,
+    foreign_tokens,
+    gate,
+    grammar_lines,
+    learn,
+)
+
+
+def compile_chain(chain: str) -> dict:
+    """Compile a chain through HoneyC into semantic lenses."""
+    program = parse_text(chain)
+    return {
+        "readable": render(program, "readable"),
+        "triples": render(program, "triples"),
+        "prose": render(program, "prose"),
+        "statements": normalize(program),
+    }
+
+
+__all__ = ["compile_chain", "learn", "gate", "grammar_lines", "foreign_tokens", "ForeignToken"]

chaincompiler/forge.py

@@ -0,0 +1,59 @@
+"""forge.py — the generic compiler-compiler core (the "forge a language" move).
+
+This is the machine the *CC are *made FROM* (DESIGN.md §2: ACCC/CORCC/SCCC import CC). A forged
+language = a rulecatcher SCOPE holding a ratified grammar; `forge` mints one, `gate_language` enforces it,
+`grammar` reads it back, `package_skill` wraps a compiled body as a publishable `<name>/SKILL.md`. Each
+*CC calls these with its own chain-kind prefix + render/parse and adds nothing to the mechanism.
+
+CC imports only DOWN (APE + rulecatcher); it never imports the *CC.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from prompt_engineering import write_skill, grammar_lines, learn
+from prompt_engineering.grammar import gate as _gate
+from rulecatcher.db import connect, list_rules
+
+
+@dataclass
+class Language:
+    """A forged language: a rulecatcher scope holding a ratified grammar."""
+    name: str
+    scope: str
+    db: str
+    rule_count: int
+
+
+def forge(kind: str, name: str, examples: list[str], *, db: str, strict: bool = False) -> Language:
+    """Mint a `kind` language for `name` from example chains (scope = `<kind>:<name>`).
+
+    strict=False → learn the SHAPE only (next_kind): any vocabulary is allowed.
+    strict=True  → also pin the vocabulary (next_token): the gate enforces domain-specific tokens.
+    """
+    scope = f"{kind}:{name}"
+    rule_types = ("next_kind", "next_token") if strict else ("next_kind",)
+    with connect(db) as cx:
+        adopted = learn(cx, examples, scope=scope, rule_types=rule_types, label=f"forge:{name}")
+    return Language(name=name, scope=scope, db=db, rule_count=len(adopted))
+
+
+def gate_language(language: Language, candidate: str) -> tuple[list, list]:
+    """Lint a candidate chain against a forged language's ratified grammar."""
+    with connect(language.db) as cx:
+        return _gate(cx, candidate, scope=language.scope)
+
+
+def grammar(language: Language) -> list[str]:
+    """The ratified grammar lines of a forged language."""
+    with connect(language.db) as cx:
+        return grammar_lines(list_rules(cx, "adopted", scope=language.scope))
+
+
+def package_skill(name: str, body: str, *, out_dir: str, description: str,
+                  extra: dict | None = None):
+    """Wrap a compiled chain body as a publishable `<name>/SKILL.md` package."""
+    return write_skill(name, description, body, out_dir=out_dir, extra=extra)
+
+
+__all__ = ["Language", "forge", "gate_language", "grammar", "package_skill"]

chaincompiler/persona.py

@@ -0,0 +1,157 @@
+"""Persona compiler — the front-end that ingests a glyph-persona-program and emits
+the artifacts the rest of ChainCompiler already eats.
+
+A BizziBee-style prompt is not prose: it is a program in a cognition-DSL with three
+layers, each of which a ChainCompiler tool already compiles —
+
+  [VarDefs]{ [🌸‍💧]=NectarWF, 📃=drilldown, … }  → a glyphsteer LEGEND (glyph↔meaning)
+  🌸‍💧 → 🍯 → 🍹  (dense-rune chains)              → HoneyC compiles / rulecatcher gates
+  ⚙️0–5  (if / while / for / 🔁 / terminal)        → a workflow (the SI executes; here: extracted)
+  [ROLE]…[/ROLE]  (the persona wrapper)            → a SKILL.md (the one type)
+
+So this module parses the human-authored glyph-persona into: a `legend.json`, a list of
+workflow steps, and a `<cogid>/SKILL.md` — putting the persona INSIDE the closed algebra.
+Full execution of the ⚙️ control flow is the SI's job (ASPIRATIONAL: `persona run`).
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .skillpack import slugify, write_skill
+
+# operator glyphs that are NOT vocabulary entries (arrows / connectors)
+_OPERATORS = set("→⇒⇔↔⟶⇄⟷=+/")
+_NONASCII = re.compile(r"[^\x00-\x7f]+")
+_IDENT = re.compile(r"[A-Za-z][A-Za-z0-9]*")
+_HEADER = re.compile(r"^\[([A-Za-z][A-Za-z0-9]*)\]:\s*(.*)$", re.M)
+_VARDEFS = re.compile(r"\[VarDefs\]:\s*\{(.*?)\}\s*(?:\n|$)", re.S)
+_STEP = re.compile(r"⚙️([0-9][0-9.]*)\)\s*`?(.*)")
+_CTRL = re.compile(r"\b(if|while|for|end)\b|🔁", re.I)
+
+
+@dataclass
+class Persona:
+    name: str
+    description: str
+    fields: dict[str, str] = field(default_factory=dict)
+    legend: object = None                 # a glyphsteer.Vocabulary
+    steps: list[dict] = field(default_factory=list)
+
+
+# ---- block parsing ----------------------------------------------------------
+def parse_header(text: str) -> dict[str, str]:
+    """The `[TAG]: value` header fields (ROLE, CogID, LAW, Mission, …)."""
+    return {k: v.strip() for k, v in _HEADER.findall(text)}
+
+
+def vardefs_text(text: str) -> str:
+    m = _VARDEFS.search(text)
+    return m.group(1) if m else ""
+
+
+# ---- VarDefs → legend -------------------------------------------------------
+def _clean_glyph(run: str) -> str:
+    return "".join(ch for ch in run if ch not in _OPERATORS).strip()
+
+
+def extract_legend(text: str):
+    """Parse the VarDefs glyph↔name pairs into a glyphsteer Vocabulary (best-effort)."""
+    from glyphsteer import Axis, Vocabulary, author
+    raw = vardefs_text(text) or text
+    specs, gseen, nseen = [], set(), set()
+    for piece in re.split(r"[,\n]", raw):
+        glyph_runs = [g for g in (_clean_glyph(r) for r in _NONASCII.findall(piece)) if g]
+        names = _IDENT.findall(piece)
+        if not glyph_runs or not names:
+            continue
+        glyph, name = glyph_runs[0], names[0]
+        if glyph in gseen or name in nseen:
+            continue
+        try:
+            Vocabulary([Axis(name, glyph)])          # validates clean glyph + derivable tag
+        except ValueError:
+            continue
+        gseen.add(glyph); nseen.add(name)
+        specs.append({"name": name, "glyph": glyph, "description": piece.strip()})
+    return author(specs)
+
+
+# ---- ⚙️ steps → workflow ----------------------------------------------------
+def extract_workflow(text: str) -> list[dict]:
+    """The numbered ⚙️N) steps, in order, with detected control-flow keywords."""
+    steps = []
+    for num, body in _STEP.findall(text):
+        body = body.strip().rstrip("`").strip()
+        ctrl = sorted({m.group(0).lower() for m in _CTRL.finditer(body)})
+        steps.append({"step": num, "ctrl": ctrl, "body": body[:140]})
+    return steps
+
+
+# ---- compile ----------------------------------------------------------------
+def parse_persona(text: str) -> Persona:
+    h = parse_header(text)
+    name = h.get("CogID") or h.get("ROLE") or "persona"
+    name = re.sub(r"[*]+$", "", name).strip()
+    return Persona(
+        name=name,
+        description=h.get("Mission", f"{name} persona"),
+        fields=h,
+        legend=extract_legend(text),
+        steps=extract_workflow(text),
+    )
+
+
+def _render_body(p: Persona) -> str:
+    from glyphsteer import render_legend
+    h = p.fields
+    out = [f"# {h.get('ROLE', p.name)} — compiled persona", ""]
+    for key in ("LAW", "Mission", "FnMx", "ActsLike", "OutputWrapper"):
+        if h.get(key):
+            out.append(f"- **{key}**: {h[key]}")
+    out += ["", "## Legend (the glyph vocabulary)", "```", render_legend(p.legend), "```", ""]
+    out += ["## Workflow (⚙️ steps)", ""]
+    for s in p.steps:
+        ctrl = f"  _[{', '.join(s['ctrl'])}]_" if s["ctrl"] else ""
+        out.append(f"{s['step']}. {s['body']}{ctrl}")
+    out += ["", "> Terminal output is reached only after a multi-round sequence of the "
+            "looping steps (the ⚙️ workflow is executable via the SI — ASPIRATIONAL)."]
+    return "\n".join(out)
+
+
+def lint_pipeline(p: Persona) -> dict | None:
+    """If the legend + ChainCompiler grammar gate are available, lint a glyph chain
+    drawn from the legend (rulecatcher syntax gate). Returns a verdict or None."""
+    try:
+        from glyphsteer import GlyphGrammar
+    except Exception:
+        return None
+    glyphs = p.legend.glyphs
+    if len(glyphs) < 2:
+        return None
+    code = p.legend.code(glyphs[:3])
+    try:
+        with GlyphGrammar(p.legend, scope=f"persona_{slugify(p.name)}") as gg:
+            lint = gg.lint(code)
+            return {"chain": code, "verdict": lint.verdict}
+    except Exception:
+        return None
+
+
+def compile_persona(text: str, out_dir: str | Path) -> dict:
+    """Compile a glyph-persona-program → `<cogid>/SKILL.md` + `legend.json`."""
+    from glyphsteer import save_legend
+    p = parse_persona(text)
+    skill_path = write_skill(p.name, p.description, _render_body(p), out_dir=out_dir,
+                             extra={"glyphs": p.legend.code(p.legend.glyphs[:1]) or ""})
+    legend_path = skill_path.parent / "legend.json"
+    save_legend(p.legend, legend_path)
+    return {
+        "name": p.name,
+        "skill": str(skill_path),
+        "legend": str(legend_path),
+        "axes": len(p.legend.axes),
+        "steps": len(p.steps),
+        "gate": lint_pipeline(p),
+    }

chaincompiler/prime.py

@@ -0,0 +1,41 @@
+"""Build the re-injectable PRIME block — the output that closes the loop.
+
+A prime is a context block that (a) tells the LLM the ratified grammar of the
+notation so it generates in-shape, and (b) shows a compiled example so it knows
+what the notation MEANS. Re-injecting the prime self-primes the model; every
+chain it then emits is gated by the same grammar (bridge.gate).
+"""
+from __future__ import annotations
+
+from .bridge import compile_chain, grammar_lines
+
+
+def build_prime(scope: str, adopted_rows: list, example_chain: str) -> str:
+    compiled = compile_chain(example_chain)
+    g = grammar_lines(adopted_rows)
+
+    sections = [
+        f'# PRIME — "{scope}" cognition-chain notation',
+        "",
+        "You think in this notation. Write cognition chains in the shape below; "
+        "every chain you emit is gated against the grammar (fix violations before continuing).",
+        "",
+        f"## Ratified grammar ({len(g)} rules, learned from examples)",
+        *(g or ["(none ratified yet)"]),
+        "",
+        "## A compiled chain (what one MEANS)",
+        f"chain:    {example_chain.strip()}",
+        f"readable: {compiled['readable']}",
+        "",
+        "triples:",
+        *(f"  {line}" for line in compiled["triples"].splitlines()),
+    ]
+    if compiled["prose"].strip():
+        sections += ["", "prose:", f"  {compiled['prose']}"]
+    sections += [
+        "",
+        "## Directive",
+        "Emit chains of this form. End a reasoning chain with a bounded |Predict| "
+        "(the kill-criterion). Stay inside the grammar; the gate will reject drift.",
+    ]
+    return "\n".join(sections)

chaincompiler/skillpack.py

@@ -0,0 +1,12 @@
+"""chaincompiler.skillpack — the skill-packager, now living in the BASE.
+
+MOVED DOWN to `prompt_engineering.skillpack` (REBUILD-SPEC.md §7 — single source of truth, D1). This
+module now just re-exports it, so `from chaincompiler.skillpack import write_skill` and
+`from chaincompiler import write_skill, slugify, skill_markdown` stay byte-stable for existing consumers
+(archetype, the *CC tests).
+"""
+from __future__ import annotations
+
+from prompt_engineering.skillpack import slugify, skill_markdown, write_skill
+
+__all__ = ["slugify", "skill_markdown", "write_skill"]

chaincompiler-0.3.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: chaincompiler
+Version: 0.3.0
+Summary: The printing press for agent cognition chains: learn → gate → compile → prime
+Requires-Python: >=3.11
+Requires-Dist: honeyc==0.3.0
+Requires-Dist: rulecatcher==0.3.0
+Requires-Dist: agent-skilltree>=0.4.0
+Requires-Dist: agent-prompt-engineering>=0.2.0
+Provides-Extra: persona
+Requires-Dist: glyphsteer==0.3.0; extra == "persona"

chaincompiler-0.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+chaincompiler/__init__.py,sha256=R8JOQ24tFq7VExtGIgocDKHiy5gN7OYHSkUsA1qB-y4,1681
+chaincompiler/bridge.py,sha256=uc75cN4IurAiq5Ec0o6Y_pLitmmoyybEeTdFkUS23kk,1294
+chaincompiler/forge.py,sha256=kSOHwGgYexrY2vJqzhBz56XkaSZDuzQElF-PYMRx-6o,2486
+chaincompiler/persona.py,sha256=2ZGI4zcAUuKYBY0DOdWHesU2oTuBeDaww4d2KTyXGno,6342
+chaincompiler/prime.py,sha256=jqpN1mHO9cp_0iLDnNK7ynBy2OEtD755pTRqJJbv4so,1630
+chaincompiler/skillpack.py,sha256=SEjy1XqXeDYUP-tSE0ObNhuQ9I1qGbtToFgSdOy9Oj4,575
+chaincompiler-0.3.0.dist-info/METADATA,sha256=rzMK5NySvCUiXXCKEe2kHhRyGmVooG8KT8KCU0_XVjc,399
+chaincompiler-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+chaincompiler-0.3.0.dist-info/top_level.txt,sha256=YqHPev5jmDAlZqEahcPBrvKEv02NYNUjUFacgVw-DSM,14
+chaincompiler-0.3.0.dist-info/RECORD,,

chaincompiler-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-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+chaincompiler