sccc 0.3.0__tar.gz

sccc-0.3.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: sccc
+Version: 0.3.0
+Summary: Skillchain Compiler-Compiler — chains ACs + CoRs + skills into one SKILL.md
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler-accc==0.3.0
+Requires-Dist: corcc==0.3.0
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: rulecatcher==0.3.0
+Requires-Dist: skillchain-compiler==0.3.0
+Requires-Dist: click

sccc-0.3.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sccc"
+version = "0.3.0"
+description = "Skillchain Compiler-Compiler — chains ACs + CoRs + skills into one SKILL.md"
+requires-python = ">=3.11"
+dependencies = ["chaincompiler-accc==0.3.0", "corcc==0.3.0", "chaincompiler==0.3.0", "rulecatcher==0.3.0", "skillchain-compiler==0.3.0", "click"]
+
+[project.scripts]
+sccc = "sccc.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

sccc-0.3.0/setup.cfg

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

sccc-0.3.0/src/sccc/__init__.py

@@ -0,0 +1,15 @@
+"""SCCC — Skillchain Compiler-Compiler. The highest composite: AC + CoR + skills.
+
+Same *CC shape (catch → lint → compile → package as SKILL.md). Built on the
+`skillchain` module. ACCC → CORCC → SCCC.
+"""
+from __future__ import annotations
+
+__version__ = "0.3.0"
+
+from .forge import SCLanguage, StepRef, forge, lint, package, parse_sequence, resolve_steps
+
+__all__ = [
+    "forge", "lint", "package", "parse_sequence", "resolve_steps",
+    "SCLanguage", "StepRef", "__version__",
+]

sccc-0.3.0/src/sccc/cli.py

@@ -0,0 +1,86 @@
+"""sccc — chain forged ACs + CoRs + regular skills into one SKILL.md rollup."""
+from __future__ import annotations
+
+from pathlib import Path
+import tempfile
+
+import click
+
+from . import forge, lint, package, resolve_steps
+from .notation import SEED_SEQUENCES
+
+_STUB_SKILL = """---
+name: summarize
+description: Condense the prior step's result into a short answer.
+---
+
+Summarize the input into 3 sentences and state the single most important takeaway.
+"""
+
+
+@click.group()
+@click.version_option(message="sccc %(version)s")
+def main() -> None:
+    """Skillchain Compiler-Compiler — the highest composite (AC + CoR + skills)."""
+
+
+@main.command()
+def demo() -> None:
+    """Forge AC + CoR + a regular skill, chain them into one SKILL.md rollup."""
+    import accc
+    import corcc
+    from corcc.notation import EINSTEIN
+
+    with tempfile.TemporaryDirectory() as tmp:
+        db = str(Path(tmp) / "cc.db")
+        skills_dir = str(Path(tmp) / "skills")
+        out_dir = str(Path(tmp) / "dist")
+
+        click.echo("══ 1. FORGE + PACKAGE the parts (each a SKILL.md) ══")
+        accc.forge("debug-attention", ["[Symptom] ⇒ [Repro] ⇒ [Hypothesis] ⇒ |Localize|"], db=db)
+        ac_path = accc.package("debug-attention",
+                               "[Symptom] ⇒ [Repro] ⇒ [Hypothesis] ⇒ |Localize|", out_dir=skills_dir)
+        persona = corcc.forge_persona(EINSTEIN, db=db)
+        cor_path = corcc.package(persona, out_dir=skills_dir)
+        skill_path = Path(skills_dir) / "summarize" / "SKILL.md"
+        skill_path.parent.mkdir(parents=True, exist_ok=True)
+        skill_path.write_text(_STUB_SKILL, encoding="utf-8")
+        ac_slug, cor_slug = ac_path.parent.name, cor_path.parent.name
+        click.echo(f"  AC  → {ac_slug}/SKILL.md")
+        click.echo(f"  CoR → {cor_slug}/SKILL.md")
+        click.echo(f"  skill → summarize/SKILL.md  (a regular skill)")
+
+        click.echo("\n══ 2. FORGE the SC sequence grammar (shape) ══")
+        scl = forge("debug-then-explain", SEED_SEQUENCES, db=db)
+        click.echo(f"  forged scope={scl.scope}, {scl.rule_count} rules")
+
+        sequence = f"[ac:{ac_slug}] ⇒ [cor:{cor_slug}] ⇒ [skill:summarize] ⇒ |Answer|"
+        click.echo(f"\n══ 3. LINT the SC sequence (syntax) ══\n  {sequence}")
+        v, fixes = lint(scl, sequence)
+        click.echo(f"    → {'clean ✓' if not v else 'violations'}")
+
+        click.echo("\n══ 4. LINT a malformed sequence (dropped ⇒) ══")
+        bad = f"[ac:{ac_slug}] [skill:summarize] ⇒ |Answer|"
+        v2, fx2 = lint(scl, bad)
+        if v2:
+            click.echo(f"  {bad}\n    ✗ {v2[0].verdict}: expected {v2[0].expected_token!r}, "
+                       f"found {v2[0].found_token!r}; fix insert {list(fx2[0].candidate_tokens)}")
+
+        click.echo("\n══ 5. RESOLVE steps (each must exist on disk) ══")
+        rows, missing = resolve_steps(sequence, skills_dir=skills_dir)
+        for i, kind, ref, status, path in rows:
+            click.echo(f"  {'✓' if status=='ok' else '✗'} [{i}] {kind:5} {ref}")
+
+        click.echo("\n══ 6. PACKAGE — roll the chain up into one SKILL.md ══")
+        sc_path = package("debug-then-explain", sequence, out_dir=out_dir, skills_dir=skills_dir)
+        click.echo(f"  wrote {sc_path}")
+        click.echo("  ── SKILL.md (rollup) ──")
+        click.echo("\n".join("  " + ln for ln in sc_path.read_text().splitlines()[:24]))
+
+        click.echo("\n══ 7. The capstone ══")
+        click.echo("  AC → CoR → SC: an attention template, a spoken reasoning chain, and a regular "
+                   "skill, composed into ONE publishable skillchain. All SKILL.md. All syntax-checked.")
+
+
+if __name__ == "__main__":
+    main()

sccc-0.3.0/src/sccc/forge.py

@@ -0,0 +1,106 @@
+"""SCCC — the Skillchain Compiler-Compiler. Composes ACCC + CORCC + regular skills.
+
+Same *CC shape: catch the SC sequence grammar → LINT its syntax → resolve each
+step to a SKILL.md package (forged AC/CoR or regular skill) → compile the rollup
+to `<name>/SKILL.md`. Built on the existing `skillchain` module for indexing,
+resolution, and rollup compilation. Syntax + resolution only — never content.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import re
+
+import skillchain as sc
+
+from chaincompiler import slugify, learn   # made FROM CC (CC re-exports APE's slugify/learn)
+from chaincompiler import gate as cp_gate   # the persistent grammar gate, re-exported by CC
+from rulecatcher.db import connect
+
+_STEP_RE = re.compile(r"\[(ac|cor|skill):([^\]]+)\]")
+_HELD_RE = re.compile(r"\|([^|]+)\|")
+
+
+@dataclass
+class SCLanguage:
+    name: str
+    scope: str
+    db: str
+    rule_count: int
+
+
+@dataclass
+class StepRef:
+    kind: str        # ac | cor | skill
+    ref: str         # the referenced package name
+    slug: str        # resolved package slug
+
+
+def forge(name: str, sequences: list[str], *, db: str) -> SCLanguage:
+    """Catch + ratify the SC sequence notation grammar (shape only)."""
+    scope = f"sc:{name}"
+    with connect(db) as cx:
+        adopted = learn(cx, sequences, scope=scope, rule_types=("next_kind",), label=f"sc:{name}")
+    return SCLanguage(name=name, scope=scope, db=db, rule_count=len(adopted))
+
+
+def lint(language: SCLanguage, sequence: str) -> tuple[list, list]:
+    """Syntax-lint an SC sequence against the ratified grammar (the *CC check)."""
+    with connect(language.db) as cx:
+        return cp_gate(cx, sequence, scope=language.scope)
+
+
+def parse_sequence(sequence: str) -> tuple[list[StepRef], str | None]:
+    steps = [StepRef(kind=m.group(1), ref=m.group(2).strip(), slug=slugify(m.group(2).strip()))
+             for m in _STEP_RE.finditer(sequence)]
+    held = _HELD_RE.search(sequence)
+    return steps, (held.group(1).strip() if held else None)
+
+
+def _index(skills_dir: str | None):
+    roots = list(sc.SKILL_ROOTS)
+    if skills_dir:
+        roots.insert(0, Path(skills_dir))
+    return sc.index_skills(roots=roots)
+
+
+def resolve_steps(sequence: str, *, skills_dir: str | None = None) -> tuple[list, list[str]]:
+    """Resolve each step to a package. Returns (rows, missing)."""
+    steps, _ = parse_sequence(sequence)
+    idx = _index(skills_dir)
+    rows, missing = [], []
+    for i, step in enumerate(steps, 1):
+        rec = sc.resolve(step.slug, idx) or sc.resolve(step.ref, idx)
+        if rec:
+            rows.append((i, step.kind, step.ref, "ok", str(rec["path"])))
+        else:
+            rows.append((i, step.kind, step.ref, "MISSING", ""))
+            missing.append(f"{step.kind}:{step.ref}")
+    return rows, missing
+
+
+def package(name: str, sequence: str, *, out_dir: str, skills_dir: str | None = None,
+            description: str | None = None) -> Path:
+    """Compile an SC sequence into a rollup `<name>/SKILL.md`.
+
+    Resolves AC/CoR/skill steps to their packages (validated present) and rolls
+    them up in order via the skillchain compiler.
+    """
+    steps, held = parse_sequence(sequence)
+    spec = {
+        "name": slugify(name),
+        # NOTE: no ": " prefix in the default — write_skill (APE) does not YAML-escape
+        # the description; a plain scalar containing ": " emits unparseable frontmatter.
+        # (The step refs keep their `kind:name` form — colon-no-space is YAML-safe.)
+        "description": description or (
+            f"Skillchain — {' → '.join(f'{s.kind}:{s.ref}' for s in steps)}"
+            + (f" → {held}" if held else "")
+        ),
+        "steps": [{"skill": s.slug} for s in steps],
+    }
+    idx = _index(skills_dir)
+    ok, _rows, missing = sc.validate(spec, idx)
+    if not ok:
+        raise ValueError(f"cannot compile SC '{name}': unresolved steps {missing}")
+    pkg, _deps = sc.compile_package(spec, idx, out_dir)
+    return pkg / "SKILL.md"

sccc-0.3.0/src/sccc/notation.py

@@ -0,0 +1,19 @@
+"""SC (skillchain) sequence notation.
+
+An SC IS A sequence chaining ACs + CoRs + regular skills, converging on a result:
+
+    [ac:<name>] ⇒ [cor:<name>] ⇒ [skill:<name>] ⇒ ... ⇒ |Result|
+
+Each `[kind:name]` step references a SKILL.md package on disk — a forged
+attention chain (kind=ac), a forged chain-of-reasoning (kind=cor), or a regular
+skill (kind=skill). Written in Dense Rune-Chain so it is syntax-linted like every
+other *CC notation. SC is the highest composite: AC → CoR → SC.
+"""
+from __future__ import annotations
+
+# Seed SC sequences (used to forge the SC notation grammar — the shape only).
+SEED_SEQUENCES = [
+    "[ac:debug-attention] ⇒ [cor:think-like-einstein] ⇒ [skill:summarize] ⇒ |Answer|",
+    "[ac:debug-attention] ⇒ [skill:summarize] ⇒ |Answer|",
+    "[cor:think-like-einstein] ⇒ [skill:summarize] ⇒ |Answer|",
+]

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

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: sccc
+Version: 0.3.0
+Summary: Skillchain Compiler-Compiler — chains ACs + CoRs + skills into one SKILL.md
+Requires-Python: >=3.11
+Requires-Dist: chaincompiler-accc==0.3.0
+Requires-Dist: corcc==0.3.0
+Requires-Dist: chaincompiler==0.3.0
+Requires-Dist: rulecatcher==0.3.0
+Requires-Dist: skillchain-compiler==0.3.0
+Requires-Dist: click

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

@@ -0,0 +1,12 @@
+pyproject.toml
+src/sccc/__init__.py
+src/sccc/cli.py
+src/sccc/forge.py
+src/sccc/notation.py
+src/sccc.egg-info/PKG-INFO
+src/sccc.egg-info/SOURCES.txt
+src/sccc.egg-info/dependency_links.txt
+src/sccc.egg-info/entry_points.txt
+src/sccc.egg-info/requires.txt
+src/sccc.egg-info/top_level.txt
+tests/test_sccc.py

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,6 @@
+chaincompiler-accc==0.3.0
+corcc==0.3.0
+chaincompiler==0.3.0
+rulecatcher==0.3.0
+skillchain-compiler==0.3.0
+click

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

@@ -0,0 +1 @@
+sccc

sccc-0.3.0/tests/test_sccc.py

@@ -0,0 +1,83 @@
+"""SCCC tests: forging the sequence grammar, lint, resolution, rollup packaging."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import accc
+import corcc
+from corcc.notation import EINSTEIN
+
+from sccc import forge, lint, package, parse_sequence, resolve_steps
+from sccc.notation import SEED_SEQUENCES
+
+_STUB = "---\nname: summarize\ndescription: condense\n---\n\nSummarize it.\n"
+
+
+def _setup(tmp_path: Path):
+    db = str(tmp_path / "cc.db")
+    skills = tmp_path / "skills"
+    accc.forge("debug-attention", ["[Symptom] ⇒ [Repro] ⇒ |Localize|"], db=db)
+    ac = accc.package("debug-attention", "[Symptom] ⇒ [Repro] ⇒ |Localize|", out_dir=str(skills))
+    persona = corcc.forge_persona(EINSTEIN, db=db)
+    cor = corcc.package(persona, out_dir=str(skills))
+    (skills / "summarize").mkdir(parents=True, exist_ok=True)
+    (skills / "summarize" / "SKILL.md").write_text(_STUB)
+    seq = f"[ac:{ac.parent.name}] ⇒ [cor:{cor.parent.name}] ⇒ [skill:summarize] ⇒ |Answer|"
+    return db, str(skills), seq
+
+
+def test_parse_sequence_extracts_typed_steps():
+    steps, held = parse_sequence("[ac:foo] ⇒ [cor:bar] ⇒ [skill:baz] ⇒ |Result|")
+    assert [(s.kind, s.ref) for s in steps] == [("ac", "foo"), ("cor", "bar"), ("skill", "baz")]
+    assert held == "Result"
+
+
+def test_closure_a_skillchain_can_chain_another_skillchain(tmp_path: Path):
+    """Everything is a skill dir, so an SC can reference an SC. The algebra closes."""
+    db, skills, seq = _setup(tmp_path)
+    # SC#1 compiled INTO the skills dir → it is itself an indexable skill dir.
+    forge("inner", [seq], db=db)
+    sc1 = package("inner", seq, out_dir=skills, skills_dir=skills)
+    assert sc1.exists()
+    # SC#2 references SC#1 as a plain skill (closure) + another skill.
+    seq2 = f"[skill:{sc1.parent.name}] ⇒ [skill:summarize] ⇒ |Done|"
+    _rows, missing = resolve_steps(seq2, skills_dir=skills)
+    assert missing == []
+    sc2 = package("outer", seq2, out_dir=skills, skills_dir=skills)
+    assert sc1.parent.name in sc2.read_text()      # SC#2 rolls up SC#1
+
+
+def test_forge_and_lint_sequence(tmp_path: Path):
+    db, skills, seq = _setup(tmp_path)
+    scl = forge("demo", SEED_SEQUENCES, db=db)
+    assert scl.rule_count > 0
+    assert lint(scl, seq)[0] == []                       # well-formed
+    assert lint(scl, "[ac:foo] [skill:baz] ⇒ |R|")[0]    # malformed (dropped ⇒)
+
+
+def test_resolve_steps_finds_forged_packages(tmp_path: Path):
+    _db, skills, seq = _setup(tmp_path)
+    rows, missing = resolve_steps(seq, skills_dir=skills)
+    assert missing == []
+    assert all(status == "ok" for _, _, _, status, _ in rows)
+
+
+def test_package_rolls_up_into_one_skill(tmp_path: Path):
+    _db, skills, seq = _setup(tmp_path)
+    out = tmp_path / "dist"
+    sc_path = package("debug-then-explain", seq, out_dir=str(out), skills_dir=skills)
+    text = sc_path.read_text()
+    assert sc_path.name == "SKILL.md"
+    assert "debug-attention" in text          # AC step referenced
+    assert "thinklikeeinstein" in text        # CoR step referenced
+    assert "summarize" in text                # regular skill referenced
+
+
+def test_package_refuses_when_step_missing(tmp_path: Path):
+    db, skills, _seq = _setup(tmp_path)
+    bad_seq = "[skill:does-not-exist] ⇒ |R|"
+    try:
+        package("broken", bad_seq, out_dir=str(tmp_path / "d"), skills_dir=skills)
+        assert False, "should refuse to compile with a missing step"
+    except ValueError:
+        pass