chaincompiler-accc 0.3.0__py3-none-any.whl

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

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

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

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,
+}

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

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

@@ -0,0 +1,10 @@
+accc/__init__.py,sha256=bnQ9VCvNBKhTdlY13nr2-GiToLzaQb9LXVqJQJtKtmo,463
+accc/cli.py,sha256=CPavOMqItOeAkPT4G81rt5GwFecAQZjuxQ_WxcqqAK8,3248
+accc/forge.py,sha256=PumYqtANuGgyWL7euDukYmHsqYuu35T8oqnCDsYgd-4,3518
+accc/notation.py,sha256=PAXrRBbHP23c1qoAoPE0CtSzPtpPuRI3S0hJHtup0Es,1660
+accc/render.py,sha256=uD7LyEjXbpAHuESzKl03tpc7FeLUGYZRshCOKWOPiA8,1704
+chaincompiler_accc-0.3.0.dist-info/METADATA,sha256=53bLlVIxYYEwv6glN_PxPF-65xhYX_FKUlO0PpGnRA8,291
+chaincompiler_accc-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+chaincompiler_accc-0.3.0.dist-info/entry_points.txt,sha256=fNFz95ekeNUgHPzVGFiv6PFswWJYB9Z5IKjrUwFm_IU,39
+chaincompiler_accc-0.3.0.dist-info/top_level.txt,sha256=cAgWuaOtwW4H43SrtL7M0TfzbtXbWgD4dREFovVxgVU,5
+chaincompiler_accc-0.3.0.dist-info/RECORD,,

chaincompiler_accc-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_accc-0.3.0.dist-info/entry_points.txt

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

chaincompiler_accc-0.3.0.dist-info/top_level.txt

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