sccc 0.3.0__py3-none-any.whl

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

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

@@ -0,0 +1,9 @@
+sccc/__init__.py,sha256=S5yf_3tJheIVvcIKT139S_-ALgV3IyAdmNjvs7eaYhU,494
+sccc/cli.py,sha256=oP-JvnjJa4N1Ju67KNMLM_2hOFAuvdkeTPVcx_SiSyo,3760
+sccc/forge.py,sha256=d5NuzzSCvHCj3qgtu4N01EB1TBCn1b9uUglUhIl-V3A,4046
+sccc/notation.py,sha256=JOmWBlFczK2BXjdTtYqInfwbAgSW7MIpzk9oxiLzQ-4,866
+sccc-0.3.0.dist-info/METADATA,sha256=WNwg_qLx3tAo5F7AtqVkfzCUs2pXd4yr7igxgGuVvcQ,361
+sccc-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+sccc-0.3.0.dist-info/entry_points.txt,sha256=8uARCuJWYrcWRRIZ2ix8ix1Qx3qJm9KaK_3utRj02RI,39
+sccc-0.3.0.dist-info/top_level.txt,sha256=gbdxIxYzSZHmeSYHp-yjiU1hnnux3q43COsBFxAKhvM,5
+sccc-0.3.0.dist-info/RECORD,,

sccc-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
+

sccc-0.3.0.dist-info/entry_points.txt

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

sccc-0.3.0.dist-info/top_level.txt

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