prizmkit 1.1.7 → 1.1.9

package/bundled/skills/prizmkit-verify/scripts/verify-light.py

@@ -1,402 +0,0 @@
-#!/usr/bin/env python3
-"""PrizmKit Light Verification Script — static checks for framework integrity.
-
-Usage:
-    python3 verify-light.py                    # Run all rounds
-    python3 verify-light.py --round R1         # Run specific round
-    python3 verify-light.py --round R1 R2 R4   # Run multiple rounds
-"""
-
-import argparse
-import json
-import os
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-# --- Configuration ---
-
-PROJECT_ROOT = Path(__file__).resolve().parents[5]  # core/skills/prizmkit-skill/prizmkit-verify/scripts/verify-light.py → root (5 levels up)
-
-SKILL_LAYER_DIR = PROJECT_ROOT / "core" / "skills" / "prizmkit-skill"
-PIPELINE_LAYER_DIR = PROJECT_ROOT / "core" / "skills" / "orchestration-skill" / "pipelines"
-WORKFLOW_LAYER_DIR = PROJECT_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
-DEV_PIPELINE_DIR = PROJECT_ROOT / "dev-pipeline"
-ALL_SKILLS_DIR = PROJECT_ROOT / "core" / "skills"
-
-# Expected items per layer
-EXPECTED_PIPELINE_SKILLS = {
-    "app-planner", "feature-planner", "bug-planner", "refactor-planner",
-    "feature-pipeline-launcher", "bugfix-pipeline-launcher", "refactor-pipeline-launcher",
-}
-EXPECTED_WORKFLOW_SKILLS = {
-    "feature-workflow", "bug-fix-workflow", "refactor-workflow", "recovery-workflow",
-}
-
-# --- Helpers ---
-
-class Result:
-    def __init__(self):
-        self.passed = 0
-        self.warned = 0
-        self.failed = 0
-        self.details = []
-
-    def ok(self, msg):
-        self.passed += 1
-        self.details.append(("PASS", msg))
-
-    def warn(self, msg):
-        self.warned += 1
-        self.details.append(("WARN", msg))
-
-    def fail(self, msg):
-        self.failed += 1
-        self.details.append(("FAIL", msg))
-
-    @property
-    def status(self):
-        if self.failed > 0:
-            return "FAIL"
-        if self.warned > 0:
-            return "WARN"
-        return "PASS"
-
-    def summary(self):
-        return f"PASS={self.passed} WARN={self.warned} FAIL={self.failed}"
-
-
-def parse_frontmatter(skill_md_path):
-    """Extract YAML frontmatter from SKILL.md."""
-    text = skill_md_path.read_text(encoding="utf-8")
-    match = re.match(r"^---\n(.*?)\n---", text, re.DOTALL)
-    if not match:
-        return {}
-    fm = {}
-    for line in match.group(1).split("\n"):
-        if ":" in line:
-            key, val = line.split(":", 1)
-            fm[key.strip()] = val.strip().strip('"').strip("'")
-    return fm
-
-
-def find_skill_dirs(base_dir):
-    """Find all directories containing SKILL.md under base_dir."""
-    return sorted(
-        d for d in base_dir.iterdir()
-        if d.is_dir() and (d / "SKILL.md").exists()
-    )
-
-
-def collect_all_skill_names():
-    """Collect all known skill names across all categories."""
-    names = set()
-    for category_dir in ALL_SKILLS_DIR.iterdir():
-        if not category_dir.is_dir() or category_dir.name.startswith("."):
-            continue
-        # Direct skill dirs
-        for d in category_dir.iterdir():
-            if d.is_dir() and (d / "SKILL.md").exists():
-                names.add(d.name)
-            # Nested (pipelines/, workflows/)
-            if d.is_dir() and not (d / "SKILL.md").exists():
-                for sub in d.iterdir():
-                    if sub.is_dir() and (sub / "SKILL.md").exists():
-                        names.add(sub.name)
-    return names
-
-
-# --- Round Checks ---
-
-def run_r1(result: Result):
-    """R1: L1 Skill Layer Light checks."""
-    print("\n=== R1: L1 Skill Layer ===")
-    skill_dirs = find_skill_dirs(SKILL_LAYER_DIR)
-    all_skill_names = collect_all_skill_names()
-
-    if not skill_dirs:
-        result.fail("No skill directories found in prizmkit-skill/")
-        return
-
-    print(f"  Found {len(skill_dirs)} skills")
-
-    for skill_dir in skill_dirs:
-        skill_name = skill_dir.name
-        skill_md = skill_dir / "SKILL.md"
-
-        # 1. Frontmatter validation
-        fm = parse_frontmatter(skill_md)
-        if not fm.get("name"):
-            result.fail(f"[{skill_name}] Missing 'name' in frontmatter")
-        elif fm["name"] != skill_name:
-            result.fail(f"[{skill_name}] name '{fm['name']}' != dir '{skill_name}'")
-        else:
-            result.ok(f"[{skill_name}] Frontmatter name OK")
-
-        if not fm.get("description"):
-            result.fail(f"[{skill_name}] Missing 'description' in frontmatter")
-        else:
-            result.ok(f"[{skill_name}] Frontmatter description OK")
-
-        # 2. ${SKILL_DIR} reference resolution
-        content = skill_md.read_text(encoding="utf-8")
-        refs = re.findall(r'\$\{SKILL_DIR\}/([^\s`"\')]+)', content)
-        for ref in refs:
-            resolved = skill_dir / ref
-            if resolved.exists():
-                result.ok(f"[{skill_name}] Asset ref '{ref}' exists")
-            else:
-                result.fail(f"[{skill_name}] Asset ref '{ref}' NOT FOUND at {resolved}")
-
-        # 3. Cross-skill references
-        cross_refs = re.findall(r'(?<!\w)/prizmkit-[\w-]+(?=[\s`"\',\)])', content)
-        for ref in cross_refs:
-            ref_name = ref.lstrip("/")
-            if ref_name in all_skill_names:
-                result.ok(f"[{skill_name}] Cross-ref '{ref_name}' exists")
-            else:
-                result.warn(f"[{skill_name}] Cross-ref '{ref_name}' not found as skill dir")
-
-    # 4. ESLint
-    try:
-        lint_result = subprocess.run(
-            ["npm", "run", "lint"], capture_output=True, text=True,
-            cwd=str(PROJECT_ROOT), timeout=30,
-        )
-        errors = len(re.findall(r"(\d+) error[^s]", lint_result.stdout + lint_result.stderr))
-        if lint_result.returncode == 0 or errors == 0:
-            result.ok("ESLint: 0 errors")
-        else:
-            result.fail(f"ESLint: {errors} errors found")
-    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
-        result.warn(f"ESLint: could not run ({e})")
-
-    # 5. Ruff
-    try:
-        ruff_result = subprocess.run(
-            ["npm", "run", "lint:py"], capture_output=True, text=True,
-            cwd=str(PROJECT_ROOT), timeout=30,
-        )
-        if ruff_result.returncode == 0:
-            result.ok("Ruff: all checks passed")
-        else:
-            result.fail(f"Ruff: {ruff_result.stdout.strip()}")
-    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
-        result.warn(f"Ruff: could not run ({e})")
-
-
-def run_r2(result: Result):
-    """R2: L2 Pipeline Layer Light checks."""
-    print("\n=== R2: L2 Pipeline Layer ===")
-    skill_dirs = find_skill_dirs(PIPELINE_LAYER_DIR)
-    found_names = {d.name for d in skill_dirs}
-
-    # Check expected skills present
-    for expected in EXPECTED_PIPELINE_SKILLS:
-        if expected in found_names:
-            result.ok(f"[{expected}] Skill exists")
-        else:
-            result.fail(f"[{expected}] Expected skill NOT FOUND")
-
-    # Frontmatter validation
-    for skill_dir in skill_dirs:
-        fm = parse_frontmatter(skill_dir / "SKILL.md")
-        if fm.get("name") == skill_dir.name and fm.get("description"):
-            result.ok(f"[{skill_dir.name}] Frontmatter OK")
-        else:
-            result.fail(f"[{skill_dir.name}] Frontmatter invalid: {fm}")
-
-    # Schema version consistency
-    scenarios = [
-        ("feature", "feature-list-schema.json", "init-pipeline.py"),
-        ("bugfix", "bug-fix-list-schema.json", "init-bugfix-pipeline.py"),
-        ("refactor", "refactor-list-schema.json", "init-refactor-pipeline.py"),
-    ]
-    for scenario, schema_file, init_script in scenarios:
-        schema_path = DEV_PIPELINE_DIR / "templates" / schema_file
-        init_path = DEV_PIPELINE_DIR / "scripts" / init_script
-
-        if not schema_path.exists():
-            result.fail(f"[{scenario}] Schema file missing: {schema_file}")
-            continue
-        if not init_path.exists():
-            result.fail(f"[{scenario}] Init script missing: {init_script}")
-            continue
-
-        # Extract schema const value
-        try:
-            schema_data = json.loads(schema_path.read_text())
-            schema_const = (
-                schema_data.get("properties", {})
-                .get("$schema", {})
-                .get("const", "NOT_FOUND")
-            )
-        except json.JSONDecodeError:
-            result.fail(f"[{scenario}] Schema file is not valid JSON")
-            continue
-
-        # Extract expected schema from init script
-        init_content = init_path.read_text()
-        match = re.search(r'EXPECTED_SCHEMA\s*=\s*["\']([^"\']+)', init_content)
-        init_expected = match.group(1) if match else "NOT_FOUND"
-
-        if schema_const == init_expected:
-            result.ok(f"[{scenario}] Schema version match: {schema_const}")
-        else:
-            result.fail(f"[{scenario}] Schema version MISMATCH: template={schema_const}, init={init_expected}")
-
-    # Launcher script path references
-    for scenario, script in [("feature", "run-feature.sh"), ("bugfix", "run-bugfix.sh"), ("refactor", "run-refactor.sh")]:
-        script_path = DEV_PIPELINE_DIR / script
-        if script_path.exists() and os.access(script_path, os.X_OK):
-            result.ok(f"[{scenario}] Script {script} exists and executable")
-        elif script_path.exists():
-            result.warn(f"[{scenario}] Script {script} exists but NOT executable")
-        else:
-            result.fail(f"[{scenario}] Script {script} NOT FOUND")
-
-
-def run_r3(result: Result):
-    """R3: L3 Workflow Layer Light checks."""
-    print("\n=== R3: L3 Workflow Layer ===")
-    skill_dirs = find_skill_dirs(WORKFLOW_LAYER_DIR)
-    found_names = {d.name for d in skill_dirs}
-    pipeline_names = {d.name for d in find_skill_dirs(PIPELINE_LAYER_DIR)}
-
-    # Check expected skills
-    for expected in EXPECTED_WORKFLOW_SKILLS:
-        if expected in found_names:
-            result.ok(f"[{expected}] Workflow exists")
-        else:
-            result.fail(f"[{expected}] Expected workflow NOT FOUND")
-
-    for skill_dir in skill_dirs:
-        skill_name = skill_dir.name
-        skill_md = skill_dir / "SKILL.md"
-
-        # Frontmatter
-        fm = parse_frontmatter(skill_md)
-        if fm.get("name") == skill_name and fm.get("description"):
-            result.ok(f"[{skill_name}] Frontmatter OK")
-        else:
-            result.fail(f"[{skill_name}] Frontmatter invalid")
-
-        # Pipeline skill references
-        content = skill_md.read_text(encoding="utf-8")
-        for pipeline_ref in re.findall(r'`([\w-]+-planner|[\w-]+-pipeline-launcher)`', content):
-            if pipeline_ref in pipeline_names:
-                result.ok(f"[{skill_name}] Pipeline ref '{pipeline_ref}' exists")
-            else:
-                result.warn(f"[{skill_name}] Pipeline ref '{pipeline_ref}' not found")
-
-        # Checkpoint naming
-        checkpoints = re.findall(r'CP-\w+-\d+', content)
-        if checkpoints:
-            result.ok(f"[{skill_name}] {len(checkpoints)} checkpoints found (CP-*-N pattern)")
-        else:
-            result.warn(f"[{skill_name}] No checkpoint markers found")
-
-
-def run_r4(result: Result):
-    """R4: L4 Script Layer Light checks."""
-    print("\n=== R4: L4 Script Layer ===")
-
-    # 1. Shell scripts executable
-    for sh_file in sorted(DEV_PIPELINE_DIR.glob("*.sh")):
-        if os.access(sh_file, os.X_OK):
-            result.ok(f"[{sh_file.name}] Executable")
-        else:
-            result.fail(f"[{sh_file.name}] NOT executable")
-
-    # 2. Python scripts compile
-    scripts_dir = DEV_PIPELINE_DIR / "scripts"
-    if scripts_dir.exists():
-        for py_file in sorted(scripts_dir.glob("*.py")):
-            try:
-                subprocess.run(
-                    [sys.executable, "-m", "py_compile", str(py_file)],
-                    capture_output=True, text=True, timeout=10,
-                )
-                result.ok(f"[{py_file.name}] Compiles OK")
-            except subprocess.TimeoutExpired:
-                result.warn(f"[{py_file.name}] Compile check timed out")
-
-    # 3. Bash lib sourcing
-    for run_script in ["run-feature.sh", "run-bugfix.sh", "run-refactor.sh"]:
-        script_path = DEV_PIPELINE_DIR / run_script
-        if not script_path.exists():
-            result.fail(f"[{run_script}] NOT FOUND")
-            continue
-        content = script_path.read_text(encoding="utf-8")
-        for lib in ["common.sh", "heartbeat.sh", "branch.sh"]:
-            if lib in content:
-                result.ok(f"[{run_script}] Sources {lib}")
-            else:
-                result.fail(f"[{run_script}] Does NOT source {lib}")
-
-    # 4. JSON templates valid
-    templates_dir = DEV_PIPELINE_DIR / "templates"
-    if templates_dir.exists():
-        for json_file in sorted(templates_dir.glob("*.json")):
-            try:
-                json.loads(json_file.read_text())
-                result.ok(f"[{json_file.name}] Valid JSON")
-            except json.JSONDecodeError as e:
-                result.fail(f"[{json_file.name}] Invalid JSON: {e}")
-
-    # 5. Test file existence
-    tests_dir = DEV_PIPELINE_DIR / "tests"
-    if tests_dir.exists():
-        test_files = list(tests_dir.glob("test_*.py"))
-        if test_files:
-            result.ok(f"Test files found: {len(test_files)}")
-        else:
-            result.warn("No test_*.py files found in dev-pipeline/tests/")
-    else:
-        result.warn("dev-pipeline/tests/ directory not found")
-
-
-# --- Main ---
-
-def main():
-    parser = argparse.ArgumentParser(description="PrizmKit Light Verification")
-    parser.add_argument("--round", nargs="*", default=["R1", "R2", "R3", "R4"],
-                        help="Rounds to run (R1, R2, R3, R4)")
-    args = parser.parse_args()
-
-    rounds_to_run = [r.upper() for r in args.round]
-    result = Result()
-
-    round_map = {"R1": run_r1, "R2": run_r2, "R3": run_r3, "R4": run_r4}
-
-    for round_name in rounds_to_run:
-        if round_name in round_map:
-            round_map[round_name](result)
-        else:
-            print(f"  Unknown round: {round_name}")
-
-    # Print results
-    print("\n" + "=" * 60)
-    print(f"  RESULT: {result.status}")
-    print(f"  {result.summary()}")
-    print("=" * 60)
-
-    if result.failed > 0:
-        print("\n  FAILURES:")
-        for status, msg in result.details:
-            if status == "FAIL":
-                print(f"    {msg}")
-
-    if result.warned > 0:
-        print("\n  WARNINGS:")
-        for status, msg in result.details:
-            if status == "WARN":
-                print(f"    {msg}")
-
-    print()
-    return 0 if result.failed == 0 else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())