@event4u/agent-config 6.1.0 → 7.0.0

package/dist/agent-src/skills/corpus-grounding/scripts/ground.py

@@ -1,166 +0,0 @@
-#!/usr/bin/env python3
-"""corpus-grounding · ground — CLI entry point (interface v1).
-
-Usage (paths resolve skill-relative — works from ANY cwd; see
-docs/contracts/skill-bundled-assets.md for the invocation contract):
-
-  # Search one domain of a corpus (auto-detects domain when omitted):
-  python3 ground.py search --manifest <path/to/manifest.json> "fintech dashboard"
-  python3 ground.py search --manifest m.json --domain color "muted palette" --json
-
-  # Structured pre-filter before ranking:
-  python3 ground.py search --manifest m.json --filter "Severity=HIGH" "forms"
-
-  # Stack axis:
-  python3 ground.py search --manifest m.json --stack react "memo rerender"
-
-  # Conditional grounding (tier 2 — reasoning plan + decision rules):
-  python3 ground.py ground --manifest m.json "luxury e-commerce" [--persist DIR]
-
-  # Validate a manifest:
-  python3 ground.py validate --manifest m.json
-
-Pure stdlib · read-only except --persist · no network · no subprocess.
-Ported CLI surface from nextlevelbuilder/ui-ux-pro-max-skill `search.py`
-@ b7e3af80f6e331f6fb456667b82b12cade7c9d35 · MIT · last checked 2026-06-07.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-# Skill-relative import: the engine modules sit beside this file.
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-
-from decision_engine import ground as run_ground  # noqa: E402
-from decision_engine import persist_grounding, search_domain, search_stack  # noqa: E402
-from schema_validator import ManifestError, load_manifest, validate_manifest  # noqa: E402
-
-
-def _parse_filters(pairs: list[str]) -> dict:
-    filters: dict = {}
-    for pair in pairs or []:
-        if "=" not in pair:
-            raise SystemExit(f"--filter expects COLUMN=VALUE, got: {pair!r}")
-        col, value = pair.split("=", 1)
-        filters.setdefault(col, [])
-        filters[col].append(value)
-    return {k: (v if len(v) > 1 else v[0]) for k, v in filters.items()}
-
-
-def _format_search(result: dict) -> str:
-    if result.get("error"):
-        return f"Error: {result['error']}"
-    out = ["## Corpus search results"]
-    head = f"**Domain:** {result.get('stack') or result.get('domain')} | **Query:** {result.get('query')}"
-    out.append(head)
-    conf = result.get("confidence") or {}
-    out.append(
-        f"**Source:** {result.get('file')} | **Found:** {result.get('count')} "
-        f"| **Confidence:** {conf.get('label')} ({conf.get('score')})"
-    )
-    out.append("")
-    for i, row in enumerate(result.get("results") or [], 1):
-        out.append(f"### Result {i}")
-        for key, value in row.items():
-            value_str = str(value)
-            if len(value_str) > 300:
-                value_str = value_str[:300] + "…"
-            if value_str:
-                out.append(f"- **{key}:** {value_str}")
-        out.append("")
-    gaps = result.get("evidence_gap") or []
-    if gaps:
-        out.append("### Evidence gap")
-        out.extend(f"- {g}" for g in gaps)
-    return "\n".join(out)
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(prog="ground", description=__doc__)
-    sub = parser.add_subparsers(dest="op", required=True)
-
-    common = argparse.ArgumentParser(add_help=False)
-    common.add_argument("--manifest", required=True, help="Path to the domain manifest.json")
-    common.add_argument("--json", action="store_true", help="Emit raw JSON")
-
-    p_search = sub.add_parser("search", parents=[common], help="Search one corpus domain")
-    p_search.add_argument("query")
-    p_search.add_argument("--domain", "-d", help="Domain (auto-detected when omitted)")
-    p_search.add_argument("--stack", "-s", help="Stack axis instead of a domain")
-    p_search.add_argument("--max-results", "-n", type=int, default=None)
-    p_search.add_argument(
-        "--filter", action="append", default=[], metavar="COLUMN=VALUE",
-        help="Structured pre-filter before ranking (repeatable)",
-    )
-    p_search.add_argument(
-        "--retriever", choices=["bm25", "structured", "hybrid"], default=None,
-        help="Override the manifest's retriever",
-    )
-
-    p_ground = sub.add_parser("ground", parents=[common], help="Conditional grounding")
-    p_ground.add_argument("query")
-    p_ground.add_argument("--context", help="JSON object of context flags for rule evaluation")
-    p_ground.add_argument("--persist", metavar="DIR", help="Write MASTER.md (+ page override) under DIR")
-    p_ground.add_argument("--project-name", "-p", default=None)
-    p_ground.add_argument("--page", default=None)
-
-    p_validate = sub.add_parser("validate", parents=[common], help="Validate a manifest")
-
-    args = parser.parse_args(argv)
-
-    try:
-        if args.op == "validate":
-            raw = json.loads(Path(args.manifest).read_text(encoding="utf-8"))
-            errors = validate_manifest(raw)
-            if errors:
-                print("INVALID manifest:")
-                for err in errors:
-                    print(f"  - {err}")
-                return 1
-            print("OK — manifest satisfies contract v1")
-            return 0
-
-        manifest = load_manifest(Path(args.manifest))
-        if args.retriever if hasattr(args, "retriever") else None:
-            manifest["retriever"] = args.retriever
-
-        if args.op == "search":
-            if args.stack:
-                result = search_stack(
-                    manifest, args.query, args.stack,
-                    args.max_results or 3, _parse_filters(args.filter) or None,
-                )
-            else:
-                result = search_domain(
-                    manifest, args.query, args.domain,
-                    args.max_results, _parse_filters(args.filter) or None,
-                )
-            print(json.dumps(result, indent=2, ensure_ascii=False) if args.json
-                  else _format_search(result))
-            return 0 if not result.get("error") else 1
-
-        # ground
-        context = json.loads(args.context) if args.context else {}
-        grounded = run_ground(manifest, args.query, context)
-        if args.persist:
-            info = persist_grounding(
-                grounded, Path(args.persist), args.project_name, args.page
-            )
-            grounded["persisted"] = info
-        if args.json:
-            print(json.dumps(grounded, indent=2, ensure_ascii=False))
-        else:
-            from decision_engine import _render_markdown
-            print(_render_markdown(grounded))
-        return 0
-    except (ManifestError, json.JSONDecodeError, OSError) as exc:
-        print(f"Error: {exc}", file=sys.stderr)
-        return 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/dist/agent-src/skills/corpus-grounding/scripts/schema_validator.py

@@ -1,160 +0,0 @@
-#!/usr/bin/env python3
-"""corpus-grounding · schema_validator — manifest contract (interface v1).
-
-Validates a domain's plug-in manifest (`manifest.json`) against the
-schema-agnostic contract from ADR-061 §3. Each domain declares its OWN
-axes — the validator checks structure + provenance discipline, never a
-uniform schema.
-
-Pure stdlib, no network. Interface contract: SKILL.md § Interface contract.
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-MANIFEST_VERSION = 1
-
-#: Output sophistication tiers (ADR-061 §3).
-TIERS = ("lookup-only", "conditional-grounding", "constraint-emission")
-
-_REQUIRED_TOP = ("manifest_version", "domain", "tier", "domains")
-_REQUIRED_PROVENANCE = ("owner", "refresh_cadence", "upstream")
-_REQUIRED_DOMAIN_KEYS = ("file", "search_cols", "output_cols")
-_REQUIRED_REASONING_KEYS = ("file", "match_column", "plan")
-
-
-class ManifestError(ValueError):
-    """Raised when a manifest violates the v1 contract."""
-
-
-def load_manifest(path: Path) -> dict:
-    """Load + validate a manifest. Raises ManifestError on violation."""
-    if not path.exists():
-        raise ManifestError(f"Manifest not found: {path}")
-    try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except json.JSONDecodeError as exc:
-        raise ManifestError(f"Manifest is not valid JSON: {path}: {exc}") from exc
-    errors = validate_manifest(data)
-    if errors:
-        raise ManifestError(
-            f"Manifest contract violations in {path}:\n  - " + "\n  - ".join(errors)
-        )
-    data["_manifest_dir"] = str(path.resolve().parent)
-    return data
-
-
-def validate_manifest(data: object) -> list[str]:
-    """Return a list of contract violations (empty = valid)."""
-    errors: list[str] = []
-    if not isinstance(data, dict):
-        return ["manifest must be a JSON object"]
-
-    for key in _REQUIRED_TOP:
-        if key not in data:
-            errors.append(f"missing required key: {key!r}")
-    if errors:
-        return errors
-
-    if data["manifest_version"] != MANIFEST_VERSION:
-        errors.append(
-            f"manifest_version {data['manifest_version']!r} unsupported "
-            f"(engine speaks v{MANIFEST_VERSION})"
-        )
-    if data["tier"] not in TIERS:
-        errors.append(f"tier {data['tier']!r} not in {TIERS}")
-
-    domains = data.get("domains")
-    if not isinstance(domains, dict) or not domains:
-        errors.append("domains must be a non-empty object")
-    else:
-        for name, cfg in domains.items():
-            if not isinstance(cfg, dict):
-                errors.append(f"domains.{name} must be an object")
-                continue
-            for key in _REQUIRED_DOMAIN_KEYS:
-                if key not in cfg:
-                    errors.append(f"domains.{name} missing {key!r}")
-            for key in ("search_cols", "output_cols"):
-                if key in cfg and (
-                    not isinstance(cfg[key], list) or not cfg[key]
-                ):
-                    errors.append(f"domains.{name}.{key} must be a non-empty list")
-
-    default_domain = data.get("default_domain")
-    if default_domain and isinstance(domains, dict) and default_domain not in domains:
-        errors.append(f"default_domain {default_domain!r} not in domains")
-
-    detect = data.get("detect")
-    if detect is not None:
-        if not isinstance(detect, dict):
-            errors.append("detect must be an object of domain → keyword list")
-        elif isinstance(domains, dict):
-            for name, kws in detect.items():
-                if name not in domains and name != "_stack":
-                    errors.append(f"detect.{name} references unknown domain")
-                if not isinstance(kws, list):
-                    errors.append(f"detect.{name} must be a list of keywords")
-
-    reasoning = data.get("reasoning")
-    if reasoning is not None:
-        if data.get("tier") == "lookup-only":
-            errors.append("reasoning block present but tier is lookup-only")
-        if not isinstance(reasoning, dict):
-            errors.append("reasoning must be an object")
-        else:
-            for key in _REQUIRED_REASONING_KEYS:
-                if key not in reasoning:
-                    errors.append(f"reasoning missing {key!r}")
-            plan = reasoning.get("plan")
-            if plan is not None:
-                if not isinstance(plan, dict):
-                    errors.append("reasoning.plan must be an object of domain → max_results")
-                elif isinstance(domains, dict):
-                    for name in plan:
-                        if name not in domains:
-                            errors.append(f"reasoning.plan.{name} references unknown domain")
-
-    stacks = data.get("stacks")
-    if stacks is not None:
-        if not isinstance(stacks, dict):
-            errors.append("stacks must be an object of stack-id → csv path")
-        elif "stack_cols" not in data:
-            errors.append("stacks present but stack_cols missing")
-
-    # Provenance discipline (ADR-061 §6) — a corpus without an owner rots.
-    for key in _REQUIRED_PROVENANCE:
-        if key not in data:
-            errors.append(f"missing provenance key: {key!r} (ADR-061 §6)")
-    upstream = data.get("upstream")
-    if isinstance(upstream, dict):
-        for key in ("repo", "sha", "last_checked"):
-            if key not in upstream:
-                errors.append(f"upstream missing {key!r}")
-    elif upstream is not None:
-        errors.append("upstream must be an object {repo, sha, last_checked}")
-
-    retriever = data.get("retriever")
-    if retriever is not None and retriever not in ("bm25", "structured", "hybrid"):
-        errors.append(f"retriever {retriever!r} unknown")
-
-    return errors
-
-
-def resolve_data_path(manifest: dict, relative: str) -> Path:
-    """Resolve a corpus file path relative to the manifest's directory.
-
-    Refuses absolute paths and parent-escapes — corpus files live beside
-    their manifest by contract (runtime-safety: read-only, local).
-    """
-    rel = Path(relative)
-    if rel.is_absolute() or ".." in rel.parts:
-        raise ManifestError(f"corpus path must be manifest-relative: {relative!r}")
-    base = Path(manifest.get("_manifest_dir", "."))
-    data_dir = manifest.get("data_dir", ".")
-    dd = Path(data_dir)
-    if dd.is_absolute() or ".." in dd.parts:
-        raise ManifestError(f"data_dir must be manifest-relative: {data_dir!r}")
-    return (base / dd / rel).resolve()

package/dist/agent-src/skills/design-tokens/scripts/tokens.py

@@ -1,296 +0,0 @@
-#!/usr/bin/env python3
-"""design-tokens · tokens — DTCG token toolchain (generate / validate / embed).
-
-Python port (no Node runtime dependency — ADR-061 fork, unanimous) of the
-upstream `.cjs` trio from `nextlevelbuilder/ui-ux-pro-max-skill`
-`design-system/scripts/{generate-tokens,validate-tokens,embed-tokens}.cjs`
-@ b7e3af80f6e331f6fb456667b82b12cade7c9d35 · MIT · last checked 2026-06-07.
-The HTML surface of `html-token-validator.py` is folded into `validate`
-(one token-discipline linter, not two).
-
-Usage (skill-relative; works from any cwd):
-  python3 tokens.py generate --config tokens.json [-o out.css] [--format css|tailwind]
-  python3 tokens.py validate --dir src/ [--ignore extra_dir] [--json]
-  python3 tokens.py embed --tokens assets/design-tokens.css [--minimal] [--style]
-
-Pure stdlib · read-only except `generate -o` · no network · no subprocess.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-
-# --------------------------------------------------------------- generate
-def resolve_reference(value: object, tokens: dict) -> object:
-    """Resolve `{primitive.color.blue.600}`-style references recursively."""
-    if not isinstance(value, str) or not value.startswith("{"):
-        return value
-    path = value.strip("{}").split(".")
-    node: object = tokens
-    for key in path:
-        if not isinstance(node, dict):
-            return value
-        node = node.get(key)
-        if node is None:
-            return value
-    if isinstance(node, dict) and "$value" in node:
-        return resolve_reference(node["$value"], tokens)
-    return node if node is not None else value
-
-
-def flatten_tokens(obj: dict, tokens: dict, prefix: list | None = None,
-                   result: dict | None = None) -> dict:
-    """Flatten a DTCG token tree into `--css-var → resolved value`."""
-    prefix = prefix or []
-    result = result if result is not None else {}
-    for key, value in obj.items():
-        current = prefix + [key]
-        if isinstance(value, dict):
-            if "$value" in value:
-                css_var = "--" + "-".join(current).replace(".", "-")
-                result[css_var] = resolve_reference(value["$value"], tokens)
-            else:
-                flatten_tokens(value, tokens, current, result)
-    return result
-
-
-def generate_css(tokens: dict) -> str:
-    primitive = flatten_tokens(tokens.get("primitive") or {}, tokens, ["primitive"])
-    semantic = flatten_tokens(tokens.get("semantic") or {}, tokens, [])
-    component = flatten_tokens(tokens.get("component") or {}, tokens, [])
-    dark = flatten_tokens((tokens.get("dark") or {}).get("semantic") or {}, tokens, [])
-
-    def block(entries: dict) -> str:
-        return "\n".join(f"  {k}: {v};" for k, v in entries.items())
-
-    css = (
-        "/* Design Tokens - Auto-generated */\n"
-        "/* Do not edit directly - modify tokens.json instead */\n\n"
-        f"/* === PRIMITIVES === */\n:root {{\n{block(primitive)}\n}}\n\n"
-        f"/* === SEMANTIC === */\n:root {{\n{block(semantic)}\n}}\n\n"
-        f"/* === COMPONENTS === */\n:root {{\n{block(component)}\n}}\n"
-    )
-    if dark:
-        css += f"\n/* === DARK MODE === */\n.dark {{\n{block(dark)}\n}}\n"
-    return css
-
-
-def generate_tailwind(tokens: dict) -> str:
-    semantic = flatten_tokens(tokens.get("semantic") or {}, tokens, [])
-    colors = {
-        key.replace("--color-", "").replace("-", "."): f"var({key})"
-        for key in semantic
-        if "color" in key
-    }
-    body = json.dumps(colors, indent=2).replace('"', "'")
-    return (
-        "// Tailwind color config - Auto-generated\n"
-        "// Add to tailwind.config.ts theme.extend.colors\n\n"
-        f"module.exports = {{\n  colors: {body}\n}};\n"
-    )
-
-
-# --------------------------------------------------------------- validate
-PATTERNS = {
-    "hexColor": (
-        re.compile(r"#([0-9A-Fa-f]{3}){1,2}\b"),
-        "Hardcoded hex color", "Use var(--color-*) token",
-    ),
-    "rgbColor": (
-        re.compile(r"rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(?:,\s*[\d.]+\s*)?\)", re.I),
-        "Hardcoded RGB(A) color", "Use var(--color-*) token",
-    ),
-    "pixelValue": (
-        re.compile(r":\s*(\d{2,})px"),
-        "Hardcoded pixel value", "Use var(--space-*) or var(--radius-*) token",
-    ),
-    "remValue": (
-        re.compile(r":\s*\d+\.?\d*rem"),
-        "Hardcoded rem value", "Use var(--space-*) or var(--font-size-*) token",
-    ),
-}
-EXTENSIONS = {".css", ".scss", ".tsx", ".jsx", ".ts", ".js", ".vue",
-              ".svelte", ".html", ".blade.php"}
-SKIP_FILE_PATTERNS = (
-    re.compile(r"\.min\.(css|js)$"),
-    re.compile(r"tailwind\.config"),
-    re.compile(r"globals\.css"),
-    re.compile(r"tokens\.(css|json)"),
-)
-HEX_EXCEPTIONS = {"#000", "#FFF", "#000000", "#FFFFFF"}
-DEFAULT_IGNORE = {"node_modules", ".git", "dist", "build", ".next", "vendor"}
-ALLOWED_HOST_HINTS = ("fonts.googleapis.com", "fonts.gstatic.com",
-                      "unsplash.com", "pexels.com")
-
-
-def _iter_files(root: Path, ignore: set) -> list:
-    files: list[Path] = []
-    for path in sorted(root.rglob("*")):
-        if any(part in ignore for part in path.parts):
-            continue
-        suffix = "".join(path.suffixes[-2:]) if path.name.endswith(".blade.php") else path.suffix
-        if path.is_file() and suffix in EXTENSIONS:
-            if any(p.search(str(path)) for p in SKIP_FILE_PATTERNS):
-                continue
-            files.append(path)
-    return files
-
-
-def scan_file(path: Path) -> list:
-    violations = []
-    try:
-        lines = path.read_text(encoding="utf-8", errors="replace").split("\n")
-    except OSError:
-        return violations
-    for lineno, line in enumerate(lines, 1):
-        stripped = line.strip()
-        if stripped.startswith(("//", "/*", "*")) or "var(--" in line:
-            continue
-        if any(host in line for host in ALLOWED_HOST_HINTS):
-            continue
-        for kind, (regex, message, suggestion) in PATTERNS.items():
-            for match in regex.findall(line):
-                value = match if isinstance(match, str) else regex.search(line).group(0)
-                if kind == "hexColor":
-                    whole = regex.search(line).group(0)
-                    if whole.upper() in HEX_EXCEPTIONS:
-                        continue
-                    value = whole
-                violations.append({
-                    "file": str(path), "line": lineno, "type": kind,
-                    "value": value, "message": message,
-                    "suggestion": suggestion,
-                    "context": stripped[:80],
-                    # Maps onto the UI directive set's finding kind so the
-                    # polish step can auto-convert against audit tokens.
-                    "kind": "token_violation",
-                })
-                break  # one finding per pattern per line is enough
-    return violations
-
-
-def format_report(violations: list) -> str:
-    if not violations:
-        return "✅ No token violations found"
-    out = [f"⚠️  Found {len(violations)} potential token violations:", ""]
-    by_file: dict = {}
-    for v in violations:
-        by_file.setdefault(v["file"], []).append(v)
-    for file, items in by_file.items():
-        out.append(f"📁 {file}")
-        for v in items:
-            out += [
-                f"   Line {v['line']}: {v['message']}",
-                f"   Found: {v['value']}",
-                f"   Suggestion: {v['suggestion']}",
-                f"   Context: {v['context']}", "",
-            ]
-    counts: dict = {}
-    for v in violations:
-        counts[v["message"]] = counts.get(v["message"], 0) + 1
-    out.append("📊 Summary:")
-    out += [f"   {msg}: {n}" for msg, n in counts.items()]
-    return "\n".join(out)
-
-
-# --------------------------------------------------------------- embed
-MINIMAL_TOKEN_PREFIXES = (
-    "--primitive-spacing-", "--primitive-fontSize-", "--primitive-fontWeight-",
-    "--primitive-lineHeight-", "--primitive-radius-", "--primitive-shadow-glow-",
-    "--primitive-gradient-", "--primitive-duration-", "--color-primary",
-    "--color-secondary", "--color-accent", "--color-background",
-    "--color-surface", "--color-foreground", "--color-border",
-    "--typography-font-", "--card-",
-)
-
-
-def extract_tokens(css: str, minimal: bool = False) -> str:
-    blocks = re.findall(r":root\s*\{([^}]+)\}", css)
-    all_vars: list[str] = []
-    for block in blocks:
-        all_vars += re.findall(r"--[\w-]+:\s*[^;]+;", block)
-    if minimal:
-        all_vars = [v for v in all_vars
-                    if any(p in v for p in MINIMAL_TOKEN_PREFIXES)]
-    seen: list[str] = []
-    for v in all_vars:
-        if v not in seen:
-            seen.append(v)
-    return ":root {\n  " + "\n  ".join(seen) + "\n}"
-
-
-# --------------------------------------------------------------- CLI
-def main(argv: list | None = None) -> int:
-    parser = argparse.ArgumentParser(prog="tokens", description=__doc__)
-    sub = parser.add_subparsers(dest="op", required=True)
-
-    p_gen = sub.add_parser("generate", help="tokens.json → CSS vars / Tailwind colors")
-    p_gen.add_argument("--config", "-c", required=True)
-    p_gen.add_argument("--output", "-o", default=None)
-    p_gen.add_argument("--format", "-f", choices=["css", "tailwind"], default="css")
-
-    p_val = sub.add_parser("validate", help="find hardcoded values that should be tokens")
-    p_val.add_argument("--dir", "-d", required=True)
-    p_val.add_argument("--ignore", "-i", action="append", default=[])
-    p_val.add_argument("--json", action="store_true",
-                       help="Emit findings as JSON (kind=token_violation)")
-
-    p_emb = sub.add_parser("embed", help="emit embeddable inline CSS from a tokens.css")
-    p_emb.add_argument("--tokens", "-t", required=True,
-                       help="Path to the generated design-tokens.css")
-    p_emb.add_argument("--minimal", action="store_true")
-    p_emb.add_argument("--style", action="store_true", help="Wrap in <style> tags")
-
-    args = parser.parse_args(argv)
-
-    if args.op == "generate":
-        config = Path(args.config)
-        if not config.exists():
-            print(f"Error: Config file not found: {config}", file=sys.stderr)
-            return 1
-        tokens = json.loads(config.read_text(encoding="utf-8"))
-        output = generate_tailwind(tokens) if args.format == "tailwind" else generate_css(tokens)
-        if args.output:
-            out = Path(args.output)
-            out.parent.mkdir(parents=True, exist_ok=True)
-            out.write_text(output, encoding="utf-8")
-            print(f"Generated: {out}")
-        else:
-            print(output)
-        return 0
-
-    if args.op == "validate":
-        root = Path(args.dir)
-        if not root.exists():
-            print(f"Error: Directory not found: {root}", file=sys.stderr)
-            return 1
-        ignore = DEFAULT_IGNORE | set(args.ignore)
-        violations: list = []
-        for file in _iter_files(root, ignore):
-            violations += scan_file(file)
-        if args.json:
-            print(json.dumps(violations, indent=2))
-        else:
-            print(format_report(violations))
-        return 1 if violations else 0
-
-    # embed
-    tokens_path = Path(args.tokens)
-    if not tokens_path.exists():
-        print(f"Error: tokens css not found: {tokens_path}", file=sys.stderr)
-        return 1
-    output = extract_tokens(tokens_path.read_text(encoding="utf-8"), args.minimal)
-    header = "/* Design Tokens (embedded for standalone HTML) */"
-    if args.style:
-        print(f"<style>\n{header}\n{output}\n</style>")
-    else:
-        print(f"{header}\n{output}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())