chaincompiler-accc 0.3.0__tar.gz

chaincompiler_accc-0.3.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: chaincompiler-accc
+Version: 0.3.0
+Summary: Attention-Chain Compiler-Compiler — the atom of the cognition-chain stack
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: honeyc==0.3.0
+Requires-Dist: rulecatcher==0.3.0
+Requires-Dist: click

chaincompiler_accc-0.3.0/README.md

@@ -0,0 +1,68 @@
+# ACCC — Attention-Chain Compiler-Compiler
+
+The **atom** of the cognition-chain stack: `ACCC → CORCC → SCCC`.
+
+An **attention chain (AC)** is **inner** — not necessarily spoken. The model uses
+it as a *template for a section* of its output, or as a *thinking scaffold*: a
+silent sequence of attention foci converging on a held focus. (Contrast CORCC's
+CoR, which is the **outer** paragraph the model must *say* and is gauged for
+persona-melt.) Written in Dense Rune-Chain so HoneyC compiles it and rulecatcher
+catches its grammar:
+
+```txt
+[Focus_1] ⇒ [Focus_2] ⇒ ... ⇒ |Held|
+```
+
+ACCC is a **compiler-compiler**, not a compiler: `forge()` mints a *new* AC
+language for a task/domain (it doesn't just compile one chain). Each forged
+language is a rulecatcher scope holding the ratified grammar; `gate()` enforces
+it; `prime()` emits the re-injectable block.
+
+## The stack it sits in
+
+| layer | chain of… | each node expands to… | built |
+|------|-----------|-----------------------|-------|
+| **ACCC** | attention foci | — (the atom) | ✅ |
+| CORCC | reasoning steps | a forged **AC** | next |
+| SCCC | skills | a **CoR** (+ can forge new languages) | after |
+
+Composition is HoneyC scope/drilldown: a CoR step `[Frame]:{ <ac> }` *contains*
+the attention chain that powers it.
+
+## Built on
+
+- **rulecatcher** — catches + gates the emergent grammar (`learn`, `lint`, the
+  `orthogonal`/`syntax_break` verdict).
+- **HoneyC** — compiles the Dense Rune-Chain notation.
+- **chaincompiler** — the generic `learn → gate → compile → prime` loop. ACCC is
+  the first domain layer on it.
+
+## Run
+
+```bash
+pip install --no-build-isolation --no-deps -e .   # rulecatcher/honeyc/chaincompiler already installed
+accc demo                                          # forge 2 AC languages, gate, prime
+accc forge debug examples/debug.ac --strict        # mint a domain AC language
+pytest                                             # 5 tests
+```
+
+## What the demo shows
+
+1. **forge** `generic` (shape-only) and `debug` (strict, vocabulary-pinned) — two
+   distinct attention-chain languages, induced from examples.
+2. **prime** the debug language → grammar + a compiled attention block.
+3. **gate** a valid debug AC → `clean ✓`.
+4. **gate** an off-domain chain (`[Goal] ⇒ …` in the debug language) → rejected
+   with verdict **`orthogonal`** (valid identifier, wrong vocabulary → steerable),
+   fix: insert `Symptom`.
+
+## API (what CORCC will consume)
+
+```python
+from accc import forge, gate, prime, attention_block, parse_ac
+
+lang = forge("debug", debug_examples, db=".accc.db", strict=True)
+violations, fixes = gate(lang, "[Symptom] ⇒ [Repro] ⇒ |Localize|")
+block = attention_block("debug", "[Symptom] ⇒ [Repro] ⇒ |Localize|")
+foci, held = parse_ac("[Symptom] ⇒ [Repro] ⇒ |Localize|")
+```

chaincompiler_accc-0.3.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chaincompiler-accc"
+version = "0.3.0"
+description = "Attention-Chain Compiler-Compiler — the atom of the cognition-chain stack"
+requires-python = ">=3.11"
+dependencies = ["chaincompiler==0.3.0", "honeyc==0.3.0", "rulecatcher==0.3.0", "click"]
+
+[project.scripts]
+accc = "accc.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

chaincompiler_accc-0.3.0/setup.cfg

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

chaincompiler_accc-0.3.0/src/accc/__init__.py

@@ -0,0 +1,15 @@
+"""ACCC — Attention-Chain Compiler-Compiler. The atom of the cognition stack.
+
+ACCC → CORCC → SCCC: a CoR step embeds a forged AC; a skill embeds a CoR.
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .forge import Language, forge, gate, grammar, package, prime
+from .render import attention_block, parse_ac
+
+__all__ = [
+    "forge", "gate", "grammar", "prime", "package", "Language",
+    "attention_block", "parse_ac", "__version__",
+]

chaincompiler_accc-0.3.0/src/accc/cli.py

@@ -0,0 +1,76 @@
+"""accc — forge attention-chain languages, gate them, compile them to blocks."""
+from __future__ import annotations
+
+from pathlib import Path
+import tempfile
+
+import click
+
+from .forge import forge, gate, grammar, prime
+from .notation import SEED_LANGUAGES
+
+
+@click.group()
+@click.version_option(message="accc %(version)s")
+def main() -> None:
+    """Attention-Chain Compiler-Compiler."""
+
+
+@main.command()
+@click.argument("name")
+@click.argument("examples_file", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.option("--db", default=".accc.db")
+@click.option("--strict/--shape-only", default=False, help="Pin focus vocabulary (strict) or shape only.")
+def forge_cmd(name: str, examples_file: Path, db: str, strict: bool) -> None:
+    """Forge an AC language NAME from EXAMPLES_FILE (one chain per line)."""
+    examples = [ln for ln in examples_file.read_text(encoding="utf-8").splitlines() if ln.strip()]
+    lang = forge(name, examples, db=db, strict=strict)
+    click.echo(f"forged '{lang.name}' (scope {lang.scope}, {lang.rule_count} rules):")
+    for line in grammar(lang):
+        click.echo("  " + line)
+
+
+main.add_command(forge_cmd, name="forge")
+
+
+@main.command()
+def demo() -> None:
+    """Forge two distinct AC languages, gate them, and emit a prime block."""
+    with tempfile.TemporaryDirectory() as tmp:
+        db = str(Path(tmp) / "accc.db")
+
+        click.echo("══ 1. FORGE — mint a generic AC language (shape only) ══")
+        generic = forge("generic", SEED_LANGUAGES["generic"], db=db)
+        for line in grammar(generic):
+            click.echo("  " + line)
+
+        click.echo("\n══ 2. FORGE — mint a DEBUG AC language (strict: pins the vocabulary) ══")
+        debug = forge("debug", SEED_LANGUAGES["debug"], db=db, strict=True)
+        click.echo(f"  debug language scope={debug.scope}, {debug.rule_count} rules "
+                   "(distinct from generic — domain-specific attention)")
+
+        click.echo("\n══ 3. PRIME — the re-injectable attention block for the debug language ══")
+        click.echo(prime(debug, "[Symptom] ⇒ [Logs] ⇒ [Hypothesis] ⇒ |Localize|"))
+
+        click.echo("\n══ 4. GATE — a valid debug AC (should pass) ══")
+        good = "[Symptom] ⇒ [Repro] ⇒ [Diff] ⇒ |Localize|"
+        v, _ = gate(debug, good)
+        click.echo(f"  {good}\n    → {'clean ✓' if not v else 'REJECTED'}")
+
+        click.echo("\n══ 5. GATE — an off-domain AC (planning foci in the debug language) ══")
+        wrong = "[Goal] ⇒ [Constraints] ⇒ [Evidence] ⇒ |Plan|"
+        v, fixes = gate(debug, wrong)
+        if v:
+            vio, fx = v[0], fixes[0]
+            click.echo(f"  {wrong}\n    ✗ {vio.verdict}: expected {vio.expected_token!r}, "
+                       f"found {vio.found_token!r}; fix: {list(fx.candidate_tokens) or fx.reason}")
+        else:
+            click.echo("  (clean — shape matched; strict vocab not violated)")
+
+        click.echo("\n══ 6. The CC point ══")
+        click.echo("  Two attention-chain LANGUAGES were minted from examples — not hand-written. "
+                   "CORCC will embed a forged AC inside each reasoning step.")
+
+
+if __name__ == "__main__":
+    main()

chaincompiler_accc-0.3.0/src/accc/forge.py

@@ -0,0 +1,87 @@
+"""ACCC — the Attention-Chain Compiler-Compiler. Made FROM ChainCompiler (DESIGN.md §2: ACCC imports CC).
+
+The compiler-compiler move: `forge` mints a *new* AC language for a task/domain (it doesn't just compile
+one chain). The generic machinery (forge a rulecatcher scope, gate against it, read the grammar, wrap a
+body as SKILL.md) lives in `chaincompiler.forge`; ACCC specializes it to attention chains (the `ac:` kind
++ the attention-block render). CORCC consumes these: a reasoning step embeds a forged AC.
+"""
+from __future__ import annotations
+
+# made FROM CC — the generic forge core (CC re-exports APE's write_skill/learn/gate underneath):
+from chaincompiler import (
+    Language,
+    forge as _forge,
+    gate_language as _gate,
+    grammar as _grammar,
+    package_skill as _package,
+)
+
+from .render import attention_block, parse_ac
+
+
+def forge(name: str, examples: list[str], *, db: str, strict: bool = False) -> Language:
+    """Mint an AC language for `name` from example chains (CC's forge, `ac:` kind).
+
+    strict=False  → learn the SHAPE only (next_kind): any focus vocabulary is allowed.
+    strict=True   → also pin the focus vocabulary (next_token): the gate enforces
+                    domain-specific foci (e.g. a debug AC must open on a Symptom).
+    """
+    return _forge("ac", name, examples, db=db, strict=strict)
+
+
+def gate(language: Language, ac: str) -> tuple[list, list]:
+    """Lint a candidate attention chain against a forged language."""
+    return _gate(language, ac)
+
+
+def grammar(language: Language) -> list[str]:
+    return _grammar(language)
+
+
+def package(name: str, ac: str, *, out_dir: str, description: str | None = None):
+    """Compile an attention chain to a publishable `<name>/SKILL.md` package.
+
+    The body is a markdown file carrying the AC in its custom syntax + how to use
+    it. The dir/SKILL.md wrapper is just so any agent auto-loads it.
+    """
+    foci, held = parse_ac(ac)
+    # NOTE: no ": " in the default — write_skill (APE) does not YAML-escape the
+    # description, and a plain scalar containing ": " emits unparseable frontmatter.
+    desc = description or (
+        f"Attention template (how to think) — attend to {', '.join(foci)}"
+        + (f" → hold {held}" if held else "") + "."
+    )
+    body = "\n".join([
+        "This is an **attention chain** — an INNER template for how to think about something "
+        "(a scaffold for a section or for your thinking). Not necessarily spoken.",
+        "",
+        "## Chain (custom syntax)",
+        "```rune",
+        ac.strip(),
+        "```",
+        "",
+        "## How to use it",
+        attention_block(name, ac),
+    ])
+    return _package(name, body, out_dir=out_dir, description=desc, extra={"kind": "attention-chain"})
+
+
+def prime(language: Language, exemplar: str) -> str:
+    """The re-injectable PRIME for a forged AC language."""
+    g = grammar(language)
+    block = attention_block(language.name, exemplar)
+    return "\n".join([
+        f'# PRIME — attention-chain language "{language.name}"',
+        "",
+        "Direct your attention using chains of this shape. Every chain you emit is "
+        "gated against the language; fix violations before continuing.",
+        "",
+        f"## Ratified grammar ({len(g)} rules)",
+        *(g or ["(none)"]),
+        "",
+        "## Exemplar (compiled to an attention block)",
+        block,
+        "",
+        "## Directive",
+        "Emit attention chains in this language. End on a bounded |Held| focus.",
+    ])

chaincompiler_accc-0.3.0/src/accc/notation.py

@@ -0,0 +1,45 @@
+"""The Attention-Chain notation + seed corpora.
+
+An ATTENTION CHAIN (AC) is the atom of the cognition stack: a prompt block that
+sequences attention foci and converges on a held focus. It is what powers ONE
+reasoning step (a CoR step embeds an AC). Written in Dense Rune-Chain so HoneyC
+compiles it and rulecatcher catches its grammar:
+
+    [Focus_1] ⇒ [Focus_2] ⇒ ... ⇒ |Held|
+
+- each [Focus_i] is something to attend to, in order
+- ⇒ flows attention forward
+- |Held| (bounded) is the convergence point attention is stabilized on
+
+Different domains forge different AC languages: the SHAPE is shared, the focus
+vocabulary and the held target differ. That is what makes ACCC a
+compiler-compiler — it mints AC *languages*, not just compiles one AC.
+"""
+from __future__ import annotations
+
+# Generic planning attention chain: orient → converge on a plan.
+GENERIC_AC = [
+    "[Goal] ⇒ [Constraints] ⇒ [Evidence] ⇒ |Plan|",
+    "[Goal] ⇒ [Risks] ⇒ [Evidence] ⇒ |Plan|",
+    "[Goal] ⇒ [Constraints] ⇒ [Options] ⇒ |Plan|",
+]
+
+# Domain-specific AC: debugging. Different vocabulary, different held target.
+DEBUG_AC = [
+    "[Symptom] ⇒ [Repro] ⇒ [Hypothesis] ⇒ |Localize|",
+    "[Symptom] ⇒ [Logs] ⇒ [Hypothesis] ⇒ |Localize|",
+    "[Symptom] ⇒ [Repro] ⇒ [Diff] ⇒ |Localize|",
+]
+
+# Another domain: literature research.
+RESEARCH_AC = [
+    "[Question] ⇒ [Sources] ⇒ [Claims] ⇒ |Synthesis|",
+    "[Question] ⇒ [Sources] ⇒ [Conflicts] ⇒ |Synthesis|",
+    "[Question] ⇒ [Gaps] ⇒ [Claims] ⇒ |Synthesis|",
+]
+
+SEED_LANGUAGES = {
+    "generic": GENERIC_AC,
+    "debug": DEBUG_AC,
+    "research": RESEARCH_AC,
+}

chaincompiler_accc-0.3.0/src/accc/render.py

@@ -0,0 +1,44 @@
+"""Compile an attention chain into a usable attention-directing prompt block.
+
+This is the AC-specific lens (HoneyC gives generic triples/prose; this turns an
+AC into the actual block you inject to direct a model's attention).
+"""
+from __future__ import annotations
+
+from honeyc.ast_nodes import Bounded, Chain, Entity, Glyph, Symbol, TypeAnn
+from honeyc.parser import parse_text
+
+
+def _label(term: object) -> str:
+    if isinstance(term, Bounded):
+        return _label(term.term)
+    if isinstance(term, TypeAnn):
+        return _label(term.term)
+    if isinstance(term, Entity):
+        return term.id
+    if isinstance(term, Symbol):
+        return term.name
+    if isinstance(term, Glyph):
+        return term.name or term.id
+    return str(term)
+
+
+def parse_ac(ac: str) -> tuple[list[str], str | None]:
+    """Return (ordered foci, held focus) for an attention chain."""
+    program = parse_text(ac)
+    chain = next((s for s in program.statements if isinstance(s, Chain)), None)
+    if chain is None:
+        raise ValueError(f"not an attention chain: {ac!r}")
+    foci = [_label(t) for t in chain.terms if not isinstance(t, Bounded)]
+    held_term = next((t for t in chain.terms if isinstance(t, Bounded)), None)
+    return foci, (_label(held_term) if held_term is not None else None)
+
+
+def attention_block(name: str, ac: str) -> str:
+    """The injectable prompt block that directs attention along the chain."""
+    foci, held = parse_ac(ac)
+    lines = [f"# Attention chain — {name}", "Attend, in order:"]
+    lines += [f"  {i}. {focus}" for i, focus in enumerate(foci, 1)]
+    if held:
+        lines.append(f"Hold: {held}  ← converge attention here, then act")
+    return "\n".join(lines)

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

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: chaincompiler-accc
+Version: 0.3.0
+Summary: Attention-Chain Compiler-Compiler — the atom of the cognition-chain stack
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: honeyc==0.3.0
+Requires-Dist: rulecatcher==0.3.0
+Requires-Dist: click

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

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/accc/__init__.py
+src/accc/cli.py
+src/accc/forge.py
+src/accc/notation.py
+src/accc/render.py
+src/chaincompiler_accc.egg-info/PKG-INFO
+src/chaincompiler_accc.egg-info/SOURCES.txt
+src/chaincompiler_accc.egg-info/dependency_links.txt
+src/chaincompiler_accc.egg-info/entry_points.txt
+src/chaincompiler_accc.egg-info/requires.txt
+src/chaincompiler_accc.egg-info/top_level.txt
+tests/test_accc.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+accc = accc.cli:main

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

@@ -0,0 +1,4 @@
+chaincompiler==0.3.0
+honeyc==0.3.0
+rulecatcher==0.3.0
+click

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

@@ -0,0 +1 @@
+accc

chaincompiler_accc-0.3.0/tests/test_accc.py

@@ -0,0 +1,63 @@
+"""ACCC tests: forging distinct languages, compiling, and gating."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from accc import attention_block, forge, gate, parse_ac
+from accc.notation import DEBUG_AC, GENERIC_AC
+
+
+def test_parse_ac_extracts_foci_and_held():
+    foci, held = parse_ac("[Symptom] ⇒ [Repro] ⇒ [Hypothesis] ⇒ |Localize|")
+    assert foci == ["Symptom", "Repro", "Hypothesis"]
+    assert held == "Localize"
+
+
+def test_attention_block_renders_ordered_foci():
+    block = attention_block("debug", "[Symptom] ⇒ [Repro] ⇒ |Localize|")
+    assert "1. Symptom" in block
+    assert "2. Repro" in block
+    assert "Hold: Localize" in block
+
+
+def test_forge_two_distinct_languages(tmp_path: Path):
+    db = str(tmp_path / "ac.db")
+    generic = forge("generic", GENERIC_AC, db=db)
+    debug = forge("debug", DEBUG_AC, db=db, strict=True)
+    assert generic.scope != debug.scope
+    assert generic.rule_count > 0 and debug.rule_count > 0
+
+
+def test_strict_debug_language_gates_off_domain_chain(tmp_path: Path):
+    db = str(tmp_path / "ac.db")
+    debug = forge("debug", DEBUG_AC, db=db, strict=True)
+    # valid debug chain passes
+    ok, _ = gate(debug, "[Symptom] ⇒ [Repro] ⇒ [Diff] ⇒ |Localize|")
+    assert ok == []
+    # off-domain planning chain is rejected by the pinned vocabulary
+    bad, _ = gate(debug, "[Goal] ⇒ [Constraints] ⇒ [Evidence] ⇒ |Plan|")
+    assert bad, "strict debug language should reject off-domain foci"
+
+
+def test_shape_only_language_accepts_any_vocabulary(tmp_path: Path):
+    db = str(tmp_path / "ac.db")
+    generic = forge("generic", GENERIC_AC, db=db)  # shape only
+    # a novel-vocabulary chain of the same SHAPE should pass
+    ok, _ = gate(generic, "[Aim] ⇒ [Limits] ⇒ [Facts] ⇒ |Sketch|")
+    assert ok == []
+
+
+def test_default_description_yields_parseable_frontmatter(tmp_path: Path):
+    """Regression: write_skill (APE) does not YAML-escape descriptions, so a default
+    description containing ': ' emits unparseable SKILL.md frontmatter. The *CC
+    defaults must therefore be colon-free (2026-08-12; found minting real ACs)."""
+    import yaml
+
+    from accc import package
+
+    path = package("yamlcheck", "[Symptom] ⇒ [Repro] ⇒ |Localize|", out_dir=str(tmp_path))
+    front = path.read_text(encoding="utf-8").split("---")[1]
+    meta = yaml.safe_load(front)  # raises on the ': ' defect
+    assert meta["name"] == "yamlcheck"
+    assert meta["kind"] == "attention-chain"
+    assert ": " not in meta["description"]