corcc 0.3.0__tar.gz

corcc-0.3.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: corcc
+Version: 0.3.0
+Summary: Chain-of-Reasoning Compiler-Compiler — spoken reasoning + persona-melt gauge
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler-accc==0.3.0
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: honeyc==0.3.0
+Requires-Dist: rulecatcher==0.3.0
+Requires-Dist: click

corcc-0.3.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "corcc"
+version = "0.3.0"
+description = "Chain-of-Reasoning Compiler-Compiler — spoken reasoning + persona-melt gauge"
+requires-python = ">=3.11"
+dependencies = ["chaincompiler-accc==0.3.0", "chaincompiler==0.3.0", "honeyc==0.3.0", "rulecatcher==0.3.0", "click"]
+
+[project.scripts]
+corcc = "corcc.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

corcc-0.3.0/setup.cfg

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

corcc-0.3.0/src/corcc/__init__.py

@@ -0,0 +1,29 @@
+"""CORCC — Chain-of-Reasoning Compiler-Compiler.
+
+A CoR IS A spoken, paragraphical AC that makes a decision. CORCC is a SYNTAX
+compiler: catch grammar → lint (keep the model writing valid CoR) → compile to a
+markdown file → package as <name>/SKILL.md. Composes ACCC (inner attention
+template). ACCC → CORCC → SCCC.
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .forge import (
+    Persona,
+    cor_chain,
+    forge_persona,
+    inner_template,
+    lint,
+    outer_template,
+    package,
+    prime,
+)
+from .notation import BANDIT, DEFAULT, EINSTEIN, FEYNMAN, SEED_PERSONAS, Move, PersonaSpec
+
+__all__ = [
+    "forge_persona", "Persona", "inner_template", "outer_template",
+    "lint", "package", "prime", "cor_chain",
+    "Move", "PersonaSpec", "BANDIT", "DEFAULT", "EINSTEIN", "FEYNMAN",
+    "SEED_PERSONAS", "__version__",
+]

corcc-0.3.0/src/corcc/cli.py

@@ -0,0 +1,78 @@
+"""corcc — forge personas (inner AC + outer CoR), lint CoR syntax, package."""
+from __future__ import annotations
+
+from pathlib import Path
+import tempfile
+
+import click
+
+from .forge import forge_persona, inner_template, lint, outer_template, package, prime
+from .notation import SEED_PERSONAS
+
+
+@click.group()
+@click.version_option(message="corcc %(version)s")
+def main() -> None:
+    """Chain-of-Reasoning Compiler-Compiler."""
+
+
+@main.command()
+def demo() -> None:
+    """Forge ThinkLikeEinstein, lint CoR syntax, and emit a SKILL.md package."""
+    with tempfile.TemporaryDirectory() as tmp:
+        db = str(Path(tmp) / "corcc.db")
+        persona = forge_persona(SEED_PERSONAS["ThinkLikeEinstein"], db=db)
+
+        click.echo("══ 1. FORGE — a persona = inner AC (silent) + outer CoR (spoken) ══")
+        click.echo(f"  forged '{persona.name}'  (chain grammar scope={persona.inner.scope})")
+
+        click.echo("\n══ 2. INNER — attention chain (template for a section / thinking; NOT spoken) ══")
+        click.echo(inner_template(persona))
+
+        click.echo("\n══ 3. OUTER — the CoR the model MUST say (paragraph, ends in a decision) ══")
+        click.echo(outer_template(persona))
+
+        click.echo("\n══ 4. LINT — a well-formed CoR (valid syntax = persona intact) ══")
+        good = "[Invariants] ⇒ [ThoughtExperiment] ⇒ [Simplicity] ⇒ |Reframe|"
+        v, _ = lint(persona, good)
+        click.echo(f"  {good}\n    → {'clean ✓ (intact)' if not v else 'violations'}")
+
+        click.echo("\n══ 5. LINT — a malformed CoR (dropped a connector = melting) ══")
+        bad = "[Invariants] [ThoughtExperiment] ⇒ |Reframe|"
+        v, fixes = lint(persona, bad)
+        if v:
+            vio, fx = v[0], fixes[0]
+            click.echo(f"  {bad}\n    ✗ {vio.verdict}: expected {vio.expected_token!r}, "
+                       f"found {vio.found_token!r}; fix: insert {list(fx.candidate_tokens)}")
+        else:
+            click.echo("  (clean)")
+
+        click.echo("\n══ 6. PACKAGE — compile the CoR to a publishable <name>/SKILL.md ══")
+        path = package(persona, out_dir=tmp)
+        click.echo(f"  wrote {path}")
+        click.echo("  ── SKILL.md ──")
+        click.echo("\n".join("  " + ln for ln in path.read_text().splitlines()))
+
+
+@main.command(name="lint")
+@click.argument("persona_name")
+@click.argument("cor_text")
+def lint_cmd(persona_name: str, cor_text: str) -> None:
+    """Syntax-lint a CoR string against a seed persona's chain grammar."""
+    import tempfile
+    spec = SEED_PERSONAS.get(persona_name)
+    if spec is None:
+        raise click.ClickException(f"unknown persona {persona_name!r}; have {list(SEED_PERSONAS)}")
+    with tempfile.TemporaryDirectory() as tmp:
+        persona = forge_persona(spec, db=str(Path(tmp) / "c.db"))
+        v, fixes = lint(persona, cor_text)
+    if not v:
+        click.echo("clean ✓ (valid CoR — persona intact)")
+        return
+    for vio, fx in zip(v, fixes):
+        click.echo(f"✗ {vio.verdict}: expected {vio.expected_token!r}, found {vio.found_token!r}; "
+                   f"fix: insert {list(fx.candidate_tokens)}")
+
+
+if __name__ == "__main__":
+    main()

corcc-0.3.0/src/corcc/forge.py

@@ -0,0 +1,117 @@
+"""CORCC — the CoR Compiler-Compiler. Composes ACCC for the inner template.
+
+A CoR IS A spoken, paragraphical AC that makes a decision. Like every *CC, CORCC
+is a SYNTAX compiler — it catches the CoR notation's grammar, LINTS it (so the
+model never writes malformed CoR), compiles it to a markdown file, and packages
+that as `<name>/SKILL.md`. It judges no content.
+
+A forged persona carries one chain notation rendered two ways:
+- inner : an attention chain (ACCC) — the silent "how to think" template
+- outer : the spoken CoR paragraph that converges on a DECISION
+
+The chain's grammar (forged via ACCC) is what `lint` checks. A clean lint = the
+model is writing valid CoR (persona intact); violations = it drifted out of the
+syntax (melting).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from accc import Language as ACLanguage
+from accc import attention_block, forge as ac_forge
+from accc import gate as ac_gate
+from chaincompiler import write_skill   # made FROM CC (CC re-exports APE's write_skill)
+
+from .notation import PersonaSpec
+from .paragraph import cor_template, must_say_directive
+
+
+def cor_chain(spec: PersonaSpec) -> str:
+    """The reasoning-move sequence as a Dense Rune-Chain (the shared chain)."""
+    foci = " ⇒ ".join(f"[{m.name}]" for m in spec.moves[:-1])
+    return f"{foci} ⇒ |{spec.held.name}|"
+
+
+@dataclass
+class Persona:
+    spec: PersonaSpec
+    inner: ACLanguage      # the attention-chain language (from ACCC); also the lint grammar
+    db: str
+
+    @property
+    def name(self) -> str:
+        return self.spec.name
+
+
+def forge_persona(spec: PersonaSpec, *, db: str) -> Persona:
+    """Mint a persona: forge the chain grammar via ACCC (ACCC → CORCC composition)."""
+    inner = ac_forge(spec.name, [cor_chain(spec)], db=db)
+    return Persona(spec=spec, inner=inner, db=db)
+
+
+def inner_template(persona: Persona) -> str:
+    """INNER attention chain — a template for a section / thinking. Not spoken."""
+    return attention_block(persona.name, cor_chain(persona.spec))
+
+
+def outer_template(persona: Persona) -> str:
+    """OUTER CoR — the spoken paragraph skeleton that converges on a decision."""
+    return cor_template(persona.spec)
+
+
+def lint(persona: Persona, cor_text: str) -> tuple[list, list]:
+    """Syntax-lint a CoR written in the persona's chain notation.
+
+    This is the only check CORCC makes: is the CoR well-formed? A clean result
+    means the model is still writing valid CoR (persona intact); violations mean
+    it drifted out of the custom syntax ("melting"). No content is judged.
+    """
+    return ac_gate(persona.inner, cor_text)
+
+
+def package(persona: Persona, *, out_dir: str, description: str | None = None):
+    """Compile the CoR to a publishable `<name>/SKILL.md` package."""
+    spec = persona.spec
+    chain = cor_chain(spec)
+    # 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"Chain-of-reasoning (spoken, ends in a decision) — {spec.blurb}."
+        if spec.blurb else "Chain-of-reasoning — spoken reasoning that ends in a decision."
+    )
+    body = "\n".join([
+        "This is a **chain of reasoning (CoR)** — a SPOKEN, paragraphical reasoning chain "
+        "that ends in a DECISION. Say it as a paragraph; keep the moves in order.",
+        "",
+        "## CoR (custom syntax)",
+        "```rune",
+        chain,
+        "```",
+        "",
+        "## Say it as a paragraph, in order",
+        must_say_directive(spec),
+        outer_template(persona),
+        "",
+        "## Inner attention chain (use silently to generate the above)",
+        inner_template(persona),
+    ])
+    return write_skill(spec.name, desc, body, out_dir=out_dir, extra={"kind": "chain-of-reasoning"})
+
+
+def prime(persona: Persona) -> str:
+    spec = persona.spec
+    return "\n".join([
+        f'# PRIME — persona "{persona.name}"',
+        f"({spec.blurb})" if spec.blurb else "",
+        "",
+        "## Inner attention chain (use silently; a template for this section / your thinking)",
+        inner_template(persona),
+        "",
+        "## Outer chain-of-reasoning (you MUST say this, as a paragraph ending in a decision)",
+        must_say_directive(spec),
+        outer_template(persona),
+        "",
+        "## Syntax",
+        "Write the CoR in the chain notation above; it is linted — if it is malformed, "
+        "fix it before continuing (a malformed CoR = the persona is melting).",
+    ])

corcc-0.3.0/src/corcc/notation.py

@@ -0,0 +1,92 @@
+"""CoR personas: ordered reasoning MOVES with cue-markers.
+
+A CoR (Chain of Reasoning) is the OUTER half of a persona. Unlike an attention
+chain (inner, silent, a template for a section/thinking), a CoR is something the
+model MUST SAY, as a paragraph. Because it is spoken, it is gauge-able: if the
+emitted prose performs the required moves IN ORDER, the persona is intact; if it
+skips or scrambles them, the persona has melted.
+
+Each persona is an ordered tuple of Moves. Each Move carries cue-markers — the
+surface phrases that count as evidence the move was performed. The LAST move is
+the convergence (the held conclusion the paragraph must reach).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Move:
+    name: str
+    cues: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class PersonaSpec:
+    name: str
+    moves: tuple[Move, ...]          # ordered; last move = the held convergence
+    blurb: str = ""
+
+    @property
+    def held(self) -> Move:
+        return self.moves[-1]
+
+
+# ── THE DEFAULT persona: the agent IS the bandit ────────────────────────────
+# Einstein/Feynman below are *flavors* — each is a single proven chain, i.e. a
+# ChainConstruct OUTPUT. The DEFAULT persona is the thing that sits ABOVE the
+# flavors and decides whether to construct one at all: the ChainSelector. Given a
+# task it picks an arm —
+#     ChainSelect    (exploit): reuse a proven / "golden" chain
+#     ChainConstruct (explore): assemble a NEW chain
+# This is compoctopus's `router.py` Bandit (Link→Chain→Compiler→Bandit) rendered
+# as a CoR: in ChainCompiler the LLM, shaped by the gate, IS the selector — so the
+# bandit policy is a persona the model reads and performs, not a separate engine.
+BANDIT = PersonaSpec(
+    name="BanditChain",
+    blurb="frame the task, recall a proven chain, choose exploit (select) vs explore (construct), execute it, record the reward",
+    moves=(
+        Move("Task", ("the task is", "what's being asked", "given the task",
+                      "the goal here", "what I need to do")),
+        Move("Recall", ("have I done this", "a proven chain", "golden chain",
+                        "already have one", "seen this before", "in the registry")),
+        Move("Decide", ("exploit", "reuse the existing", "explore", "no chain exists yet",
+                        "reward is high enough", "construct a new", "select vs construct",
+                        "so I'll select", "so I'll construct")),
+        Move("Execute", ("run the chain", "execute it", "apply it", "run it on", "now I run")),
+        Move("Reward", ("the result is", "which worked", "record the reward",
+                        "update the golden", "so the outcome", "the answer is")),
+    ),
+)
+
+
+# The worked example: think like Einstein.
+EINSTEIN = PersonaSpec(
+    name="ThinkLikeEinstein",
+    blurb="fix the invariant, run a thought experiment, strip to simplest form, reframe the question",
+    moves=(
+        Move("Invariants", ("invariant", "stays fixed", "regardless of frame",
+                            "holds in every frame", "what cannot change")),
+        Move("ThoughtExperiment", ("imagine", "suppose", "thought experiment",
+                                   "ride alongside", "gedanken", "picture")),
+        Move("Simplicity", ("simplest", "strip", "essence", "as simple as possible", "bare")),
+        Move("Reframe", ("reframe", "the real question", "actually about",
+                         "so the question becomes", "reframes")),
+    ),
+)
+
+# A second persona, to show CORCC mints languages, not one hard-coded shape.
+FEYNMAN = PersonaSpec(
+    name="ThinkLikeFeynman",
+    blurb="restate plainly, give a concrete example, find where it breaks, then explain simply",
+    moves=(
+        Move("Plainly", ("in plain terms", "put simply", "what this really says")),
+        Move("ConcreteExample", ("for example", "concretely", "take a case", "imagine a")),
+        Move("WhereItBreaks", ("breaks down", "fails when", "the catch", "where it goes wrong")),
+        Move("ExplainSimply", ("so simply put", "the punchline", "bottom line", "in short")),
+    ),
+)
+
+# DEFAULT = the selector; the flavors are what it constructs.
+DEFAULT = BANDIT
+SEED_PERSONAS = {p.name: p for p in (BANDIT, EINSTEIN, FEYNMAN)}

corcc-0.3.0/src/corcc/paragraph.py

@@ -0,0 +1,24 @@
+"""Render a CoR persona into the paragraph the model must say.
+
+§5 convergence: the fill-in skeleton format lives in the base (`cor_skeleton`); this module renders CORCC's
+PersonaSpec THROUGH that single source (routed via CC, which re-exports it) instead of re-implementing it.
+"""
+from __future__ import annotations
+
+from chaincompiler import cor_skeleton   # made FROM CC (CC re-exports APE's cor_skeleton)
+
+from .notation import PersonaSpec
+
+
+def must_say_directive(spec: PersonaSpec) -> str:
+    moves = ", ".join(m.name for m in spec.moves[:-1])
+    return (f"State your reasoning as ONE paragraph that performs, in order, {len(spec.moves)} moves: "
+            f"{moves}, and finally converges on {spec.held.name}.")
+
+
+def cor_template(spec: PersonaSpec) -> str:
+    """A fill-in paragraph skeleton with one clause per move and its cue — rendered via the base's
+    `cor_skeleton` (single source of the format). Each Move contributes its first cue phrase."""
+    moves = [m.name for m in spec.moves]
+    cues = {m.name: m.cues[0] for m in spec.moves}
+    return cor_skeleton(moves, cues)

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

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: corcc
+Version: 0.3.0
+Summary: Chain-of-Reasoning Compiler-Compiler — spoken reasoning + persona-melt gauge
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler-accc==0.3.0
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: honeyc==0.3.0
+Requires-Dist: rulecatcher==0.3.0
+Requires-Dist: click

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

@@ -0,0 +1,14 @@
+pyproject.toml
+src/corcc/__init__.py
+src/corcc/cli.py
+src/corcc/forge.py
+src/corcc/notation.py
+src/corcc/paragraph.py
+src/corcc.egg-info/PKG-INFO
+src/corcc.egg-info/SOURCES.txt
+src/corcc.egg-info/dependency_links.txt
+src/corcc.egg-info/entry_points.txt
+src/corcc.egg-info/requires.txt
+src/corcc.egg-info/top_level.txt
+tests/test_corcc.py
+tests/test_corcc_regressions.py

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

@@ -0,0 +1 @@
+

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

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

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

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

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

@@ -0,0 +1 @@
+corcc

corcc-0.3.0/tests/test_corcc.py

@@ -0,0 +1,42 @@
+"""CORCC tests: forging personas, the inner/outer split, syntax lint, packaging."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from corcc import cor_chain, forge_persona, inner_template, lint, outer_template, package
+from corcc.notation import EINSTEIN
+
+
+def test_cor_chain_built_from_moves():
+    assert cor_chain(EINSTEIN) == "[Invariants] ⇒ [ThoughtExperiment] ⇒ [Simplicity] ⇒ |Reframe|"
+
+
+def test_forge_persona_builds_inner_ac(tmp_path: Path):
+    p = forge_persona(EINSTEIN, db=str(tmp_path / "c.db"))
+    assert p.inner.scope == "ac:ThinkLikeEinstein"
+    assert p.inner.rule_count > 0
+    assert "Attend" in inner_template(p)          # inner = silent template
+    assert "Invariants" in outer_template(p)      # outer = spoken paragraph skeleton
+
+
+def test_lint_accepts_well_formed_cor(tmp_path: Path):
+    p = forge_persona(EINSTEIN, db=str(tmp_path / "c.db"))
+    violations, _ = lint(p, "[Invariants] ⇒ [ThoughtExperiment] ⇒ [Simplicity] ⇒ |Reframe|")
+    assert violations == []
+
+
+def test_lint_flags_malformed_cor(tmp_path: Path):
+    p = forge_persona(EINSTEIN, db=str(tmp_path / "c.db"))
+    # dropped a connector between the first two moves -> malformed syntax (melting)
+    violations, _ = lint(p, "[Invariants] [ThoughtExperiment] ⇒ |Reframe|")
+    assert violations, "malformed CoR should be caught by the syntax linter"
+
+
+def test_package_writes_skill_md(tmp_path: Path):
+    p = forge_persona(EINSTEIN, db=str(tmp_path / "c.db"))
+    path = package(p, out_dir=str(tmp_path / "skills"))
+    assert path.name == "SKILL.md"
+    text = path.read_text()
+    assert "chain-of-reasoning" in text          # frontmatter kind
+    assert "DECISION" in text                     # CoR ends in a decision
+    assert cor_chain(EINSTEIN) in text            # the custom-syntax chain is in the body

corcc-0.3.0/tests/test_corcc_regressions.py

@@ -0,0 +1,24 @@
+"""The directive a CoR carries says what the paragraph does (the public repository's bug sweeps, pull requests #1 and #2).
+
+It fails on the code before the fix and passes after it.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from corcc import forge_persona, package, prime
+from corcc.notation import BANDIT
+from corcc.paragraph import must_say_directive
+
+DIRECTIVE = "State your reasoning as ONE paragraph that performs, in order, 5 moves: "
+
+
+def test_the_directive_has_its_verb():
+    assert must_say_directive(BANDIT).startswith(DIRECTIVE)
+
+
+def test_every_door_that_writes_the_directive_writes_it_whole(tmp_path: Path):
+    persona = forge_persona(BANDIT, db=str(tmp_path / "rules.db"))
+    skill = Path(package(persona, out_dir=str(tmp_path / "skills")))
+    assert DIRECTIVE in skill.read_text(encoding="utf-8")
+    assert DIRECTIVE in prime(persona)