bps-kit 1.0.7 → 1.0.8

package/templates/skills_basic/lint-and-validate/scripts/lint_runner.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Lint Runner - Unified linting and type checking
+Runs appropriate linters based on project type.
+
+Usage:
+    python lint_runner.py <project_path>
+
+Supports:
+    - Node.js: npm run lint, npx tsc --noEmit
+    - Python: ruff check, mypy
+"""
+
+import subprocess
+import sys
+import json
+from pathlib import Path
+from datetime import datetime
+
+# Fix Windows console encoding
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+except:
+    pass
+
+
+def detect_project_type(project_path: Path) -> dict:
+    """Detect project type and available linters."""
+    result = {
+        "type": "unknown",
+        "linters": []
+    }
+    
+    # Node.js project
+    package_json = project_path / "package.json"
+    if package_json.exists():
+        result["type"] = "node"
+        try:
+            pkg = json.loads(package_json.read_text(encoding='utf-8'))
+            scripts = pkg.get("scripts", {})
+            deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+            
+            # Check for lint script
+            if "lint" in scripts:
+                result["linters"].append({"name": "npm lint", "cmd": ["npm", "run", "lint"]})
+            elif "eslint" in deps:
+                result["linters"].append({"name": "eslint", "cmd": ["npx", "eslint", "."]})
+            
+            # Check for TypeScript
+            if "typescript" in deps or (project_path / "tsconfig.json").exists():
+                result["linters"].append({"name": "tsc", "cmd": ["npx", "tsc", "--noEmit"]})
+                
+        except:
+            pass
+    
+    # Python project
+    if (project_path / "pyproject.toml").exists() or (project_path / "requirements.txt").exists():
+        result["type"] = "python"
+        
+        # Check for ruff
+        result["linters"].append({"name": "ruff", "cmd": ["ruff", "check", "."]})
+        
+        # Check for mypy
+        if (project_path / "mypy.ini").exists() or (project_path / "pyproject.toml").exists():
+            result["linters"].append({"name": "mypy", "cmd": ["mypy", "."]})
+    
+    return result
+
+
+def run_linter(linter: dict, cwd: Path) -> dict:
+    """Run a single linter and return results."""
+    result = {
+        "name": linter["name"],
+        "passed": False,
+        "output": "",
+        "error": ""
+    }
+    
+    try:
+        proc = subprocess.run(
+            linter["cmd"],
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            encoding='utf-8',
+            errors='replace',
+            timeout=120
+        )
+        
+        result["output"] = proc.stdout[:2000] if proc.stdout else ""
+        result["error"] = proc.stderr[:500] if proc.stderr else ""
+        result["passed"] = proc.returncode == 0
+        
+    except FileNotFoundError:
+        result["error"] = f"Command not found: {linter['cmd'][0]}"
+    except subprocess.TimeoutExpired:
+        result["error"] = "Timeout after 120s"
+    except Exception as e:
+        result["error"] = str(e)
+    
+    return result
+
+
+def main():
+    project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
+    
+    print(f"\n{'='*60}")
+    print(f"[LINT RUNNER] Unified Linting")
+    print(f"{'='*60}")
+    print(f"Project: {project_path}")
+    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    # Detect project type
+    project_info = detect_project_type(project_path)
+    print(f"Type: {project_info['type']}")
+    print(f"Linters: {len(project_info['linters'])}")
+    print("-"*60)
+    
+    if not project_info["linters"]:
+        print("No linters found for this project type.")
+        output = {
+            "script": "lint_runner",
+            "project": str(project_path),
+            "type": project_info["type"],
+            "checks": [],
+            "passed": True,
+            "message": "No linters configured"
+        }
+        print(json.dumps(output, indent=2))
+        sys.exit(0)
+    
+    # Run each linter
+    results = []
+    all_passed = True
+    
+    for linter in project_info["linters"]:
+        print(f"\nRunning: {linter['name']}...")
+        result = run_linter(linter, project_path)
+        results.append(result)
+        
+        if result["passed"]:
+            print(f"  [PASS] {linter['name']}")
+        else:
+            print(f"  [FAIL] {linter['name']}")
+            if result["error"]:
+                print(f"  Error: {result['error'][:200]}")
+            all_passed = False
+    
+    # Summary
+    print("\n" + "="*60)
+    print("SUMMARY")
+    print("="*60)
+    
+    for r in results:
+        icon = "[PASS]" if r["passed"] else "[FAIL]"
+        print(f"{icon} {r['name']}")
+    
+    output = {
+        "script": "lint_runner",
+        "project": str(project_path),
+        "type": project_info["type"],
+        "checks": results,
+        "passed": all_passed
+    }
+    
+    print("\n" + json.dumps(output, indent=2))
+    
+    sys.exit(0 if all_passed else 1)
+
+
+if __name__ == "__main__":
+    main()

package/templates/skills_basic/lint-and-validate/scripts/type_coverage.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+Type Coverage Checker - Measures TypeScript/Python type coverage.
+Identifies untyped functions, any usage, and type safety issues.
+"""
+import sys
+import re
+import subprocess
+from pathlib import Path
+
+# Fix Windows console encoding for Unicode output
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+except AttributeError:
+    pass  # Python < 3.7
+
+def check_typescript_coverage(project_path: Path) -> dict:
+    """Check TypeScript type coverage."""
+    issues = []
+    passed = []
+    stats = {'any_count': 0, 'untyped_functions': 0, 'total_functions': 0}
+    
+    ts_files = list(project_path.rglob("*.ts")) + list(project_path.rglob("*.tsx"))
+    ts_files = [f for f in ts_files if 'node_modules' not in str(f) and '.d.ts' not in str(f)]
+    
+    if not ts_files:
+        return {'type': 'typescript', 'files': 0, 'passed': [], 'issues': ["[!] No TypeScript files found"], 'stats': stats}
+    
+    for file_path in ts_files[:30]:  # Limit
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+            
+            # Count 'any' usage
+            any_matches = re.findall(r':\s*any\b', content)
+            stats['any_count'] += len(any_matches)
+            
+            # Find functions without return types
+            # function name(params) { - no return type
+            untyped = re.findall(r'function\s+\w+\s*\([^)]*\)\s*{', content)
+            # Arrow functions without types: const fn = (x) => or (x) =>
+            untyped += re.findall(r'=\s*\([^:)]*\)\s*=>', content)
+            stats['untyped_functions'] += len(untyped)
+            
+            # Count typed functions
+            typed = re.findall(r'function\s+\w+\s*\([^)]*\)\s*:\s*\w+', content)
+            typed += re.findall(r':\s*\([^)]*\)\s*=>\s*\w+', content)
+            stats['total_functions'] += len(typed) + len(untyped)
+            
+        except Exception:
+            continue
+    
+    # Analyze results
+    if stats['any_count'] == 0:
+        passed.append("[OK] No 'any' types found")
+    elif stats['any_count'] <= 5:
+        issues.append(f"[!] {stats['any_count']} 'any' types found (acceptable)")
+    else:
+        issues.append(f"[X] {stats['any_count']} 'any' types found (too many)")
+    
+    if stats['total_functions'] > 0:
+        typed_ratio = (stats['total_functions'] - stats['untyped_functions']) / stats['total_functions'] * 100
+        if typed_ratio >= 80:
+            passed.append(f"[OK] Type coverage: {typed_ratio:.0f}%")
+        elif typed_ratio >= 50:
+            issues.append(f"[!] Type coverage: {typed_ratio:.0f}% (improve)")
+        else:
+            issues.append(f"[X] Type coverage: {typed_ratio:.0f}% (too low)")
+    
+    passed.append(f"[OK] Analyzed {len(ts_files)} TypeScript files")
+    
+    return {'type': 'typescript', 'files': len(ts_files), 'passed': passed, 'issues': issues, 'stats': stats}
+
+def check_python_coverage(project_path: Path) -> dict:
+    """Check Python type hints coverage."""
+    issues = []
+    passed = []
+    stats = {'untyped_functions': 0, 'typed_functions': 0, 'any_count': 0}
+    
+    py_files = list(project_path.rglob("*.py"))
+    py_files = [f for f in py_files if not any(x in str(f) for x in ['venv', '__pycache__', '.git', 'node_modules'])]
+    
+    if not py_files:
+        return {'type': 'python', 'files': 0, 'passed': [], 'issues': ["[!] No Python files found"], 'stats': stats}
+    
+    for file_path in py_files[:30]:  # Limit
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+            
+            # Count Any usage
+            any_matches = re.findall(r':\s*Any\b', content)
+            stats['any_count'] += len(any_matches)
+            
+            # Find functions with type hints
+            typed_funcs = re.findall(r'def\s+\w+\s*\([^)]*:[^)]+\)', content)
+            typed_funcs += re.findall(r'def\s+\w+\s*\([^)]*\)\s*->', content)
+            stats['typed_functions'] += len(typed_funcs)
+            
+            # Find functions without type hints
+            all_funcs = re.findall(r'def\s+\w+\s*\(', content)
+            stats['untyped_functions'] += len(all_funcs) - len(typed_funcs)
+            
+        except Exception:
+            continue
+    
+    total = stats['typed_functions'] + stats['untyped_functions']
+    
+    if total > 0:
+        typed_ratio = stats['typed_functions'] / total * 100
+        if typed_ratio >= 70:
+            passed.append(f"[OK] Type hints coverage: {typed_ratio:.0f}%")
+        elif typed_ratio >= 40:
+            issues.append(f"[!] Type hints coverage: {typed_ratio:.0f}%")
+        else:
+            issues.append(f"[X] Type hints coverage: {typed_ratio:.0f}% (add type hints)")
+    
+    if stats['any_count'] == 0:
+        passed.append("[OK] No 'Any' types found")
+    elif stats['any_count'] <= 3:
+        issues.append(f"[!] {stats['any_count']} 'Any' types found")
+    else:
+        issues.append(f"[X] {stats['any_count']} 'Any' types found")
+    
+    passed.append(f"[OK] Analyzed {len(py_files)} Python files")
+    
+    return {'type': 'python', 'files': len(py_files), 'passed': passed, 'issues': issues, 'stats': stats}
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "."
+    project_path = Path(target)
+    
+    print("\n" + "=" * 60)
+    print("  TYPE COVERAGE CHECKER")
+    print("=" * 60 + "\n")
+    
+    results = []
+    
+    # Check TypeScript
+    ts_result = check_typescript_coverage(project_path)
+    if ts_result['files'] > 0:
+        results.append(ts_result)
+    
+    # Check Python
+    py_result = check_python_coverage(project_path)
+    if py_result['files'] > 0:
+        results.append(py_result)
+    
+    if not results:
+        print("[!] No TypeScript or Python files found.")
+        sys.exit(0)
+    
+    # Print results
+    critical_issues = 0
+    for result in results:
+        print(f"\n[{result['type'].upper()}]")
+        print("-" * 40)
+        for item in result['passed']:
+            print(f"  {item}")
+        for item in result['issues']:
+            print(f"  {item}")
+            if item.startswith("[X]"):
+                critical_issues += 1
+    
+    print("\n" + "=" * 60)
+    if critical_issues == 0:
+        print("[OK] TYPE COVERAGE: ACCEPTABLE")
+        sys.exit(0)
+    else:
+        print(f"[X] TYPE COVERAGE: {critical_issues} critical issues")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/templates/skills_basic/plan-writing/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: plan-writing
+description: "Structured task planning with clear breakdowns, dependencies, and verification criteria. Use when implementing features, refactoring, or any multi-step work."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Plan Writing
+
+> Source: obra/superpowers
+
+## Overview
+This skill provides a framework for breaking down work into clear, actionable tasks with verification criteria.
+
+## Task Breakdown Principles
+
+### 1. Small, Focused Tasks
+- Each task should take 2-5 minutes
+- One clear outcome per task
+- Independently verifiable
+
+### 2. Clear Verification
+- How do you know it's done?
+- What can you check/test?
+- What's the expected output?
+
+### 3. Logical Ordering
+- Dependencies identified
+- Parallel work where possible
+- Critical path highlighted
+- **Phase X: Verification is always LAST**
+
+### 4. Dynamic Naming in Project Root
+- Plan files are saved as `{task-slug}.md` in the PROJECT ROOT
+- Name derived from task (e.g., "add auth" → `auth-feature.md`)
+- **NEVER** inside `.claude/`, `docs/`, or temp folders
+
+## Planning Principles (NOT Templates!)
+
+> 🔴 **NO fixed templates. Each plan is UNIQUE to the task.**
+
+### Principle 1: Keep It SHORT
+
+| ❌ Wrong | ✅ Right |
+|----------|----------|
+| 50 tasks with sub-sub-tasks | 5-10 clear tasks max |
+| Every micro-step listed | Only actionable items |
+| Verbose descriptions | One-line per task |
+
+> **Rule:** If plan is longer than 1 page, it's too long. Simplify.
+
+---
+
+### Principle 2: Be SPECIFIC, Not Generic
+
+| ❌ Wrong | ✅ Right |
+|----------|----------|
+| "Set up project" | "Run `npx create-next-app`" |
+| "Add authentication" | "Install next-auth, create `/api/auth/[...nextauth].ts`" |
+| "Style the UI" | "Add Tailwind classes to `Header.tsx`" |
+
+> **Rule:** Each task should have a clear, verifiable outcome.
+
+---
+
+### Principle 3: Dynamic Content Based on Project Type
+
+**For NEW PROJECT:**
+- What tech stack? (decide first)
+- What's the MVP? (minimal features)
+- What's the file structure?
+
+**For FEATURE ADDITION:**
+- Which files are affected?
+- What dependencies needed?
+- How to verify it works?
+
+**For BUG FIX:**
+- What's the root cause?
+- What file/line to change?
+- How to test the fix?
+
+---
+
+### Principle 4: Scripts Are Project-Specific
+
+> 🔴 **DO NOT copy-paste script commands. Choose based on project type.**
+
+| Project Type | Relevant Scripts |
+|--------------|------------------|
+| Frontend/React | `ux_audit.py`, `accessibility_checker.py` |
+| Backend/API | `api_validator.py`, `security_scan.py` |
+| Mobile | `mobile_audit.py` |
+| Database | `schema_validator.py` |
+| Full-stack | Mix of above based on what you touched |
+
+**Wrong:** Adding all scripts to every plan
+**Right:** Only scripts relevant to THIS task
+
+---
+
+### Principle 5: Verification is Simple
+
+| ❌ Wrong | ✅ Right |
+|----------|----------|
+| "Verify the component works correctly" | "Run `npm run dev`, click button, see toast" |
+| "Test the API" | "curl localhost:3000/api/users returns 200" |
+| "Check styles" | "Open browser, verify dark mode toggle works" |
+
+---
+
+## Plan Structure (Flexible, Not Fixed!)
+
+```
+# [Task Name]
+
+## Goal
+One sentence: What are we building/fixing?
+
+## Tasks
+- [ ] Task 1: [Specific action] → Verify: [How to check]
+- [ ] Task 2: [Specific action] → Verify: [How to check]
+- [ ] Task 3: [Specific action] → Verify: [How to check]
+
+## Done When
+- [ ] [Main success criteria]
+```
+
+> **That's it.** No phases, no sub-sections unless truly needed.
+> Keep it minimal. Add complexity only when required.
+
+## Notes
+[Any important considerations]
+```
+
+---
+
+## Best Practices (Quick Reference)
+
+1. **Start with goal** - What are we building/fixing?
+2. **Max 10 tasks** - If more, break into multiple plans
+3. **Each task verifiable** - Clear "done" criteria
+4. **Project-specific** - No copy-paste templates
+5. **Update as you go** - Mark `[x]` when complete
+
+---
+
+## When to Use
+
+- New project from scratch
+- Adding a feature
+- Fixing a bug (if complex)
+- Refactoring multiple files

package/templates/skills_basic/systematic-debugging/CREATION-LOG.md

@@ -0,0 +1,119 @@
+# Creation Log: Systematic Debugging Skill
+
+Reference example of extracting, structuring, and bulletproofing a critical skill.
+
+## Source Material
+
+Extracted debugging framework from `/Users/jesse/.claude/CLAUDE.md`:
+- 4-phase systematic process (Investigation → Pattern Analysis → Hypothesis → Implementation)
+- Core mandate: ALWAYS find root cause, NEVER fix symptoms
+- Rules designed to resist time pressure and rationalization
+
+## Extraction Decisions
+
+**What to include:**
+- Complete 4-phase framework with all rules
+- Anti-shortcuts ("NEVER fix symptom", "STOP and re-analyze")
+- Pressure-resistant language ("even if faster", "even if I seem in a hurry")
+- Concrete steps for each phase
+
+**What to leave out:**
+- Project-specific context
+- Repetitive variations of same rule
+- Narrative explanations (condensed to principles)
+
+## Structure Following skill-creation/SKILL.md
+
+1. **Rich when_to_use** - Included symptoms and anti-patterns
+2. **Type: technique** - Concrete process with steps
+3. **Keywords** - "root cause", "symptom", "workaround", "debugging", "investigation"
+4. **Flowchart** - Decision point for "fix failed" → re-analyze vs add more fixes
+5. **Phase-by-phase breakdown** - Scannable checklist format
+6. **Anti-patterns section** - What NOT to do (critical for this skill)
+
+## Bulletproofing Elements
+
+Framework designed to resist rationalization under pressure:
+
+### Language Choices
+- "ALWAYS" / "NEVER" (not "should" / "try to")
+- "even if faster" / "even if I seem in a hurry"
+- "STOP and re-analyze" (explicit pause)
+- "Don't skip past" (catches the actual behavior)
+
+### Structural Defenses
+- **Phase 1 required** - Can't skip to implementation
+- **Single hypothesis rule** - Forces thinking, prevents shotgun fixes
+- **Explicit failure mode** - "IF your first fix doesn't work" with mandatory action
+- **Anti-patterns section** - Shows exactly what shortcuts look like
+
+### Redundancy
+- Root cause mandate in overview + when_to_use + Phase 1 + implementation rules
+- "NEVER fix symptom" appears 4 times in different contexts
+- Each phase has explicit "don't skip" guidance
+
+## Testing Approach
+
+Created 4 validation tests following skills/meta/testing-skills-with-subagents:
+
+### Test 1: Academic Context (No Pressure)
+- Simple bug, no time pressure
+- **Result:** Perfect compliance, complete investigation
+
+### Test 2: Time Pressure + Obvious Quick Fix
+- User "in a hurry", symptom fix looks easy
+- **Result:** Resisted shortcut, followed full process, found real root cause
+
+### Test 3: Complex System + Uncertainty
+- Multi-layer failure, unclear if can find root cause
+- **Result:** Systematic investigation, traced through all layers, found source
+
+### Test 4: Failed First Fix
+- Hypothesis doesn't work, temptation to add more fixes
+- **Result:** Stopped, re-analyzed, formed new hypothesis (no shotgun)
+
+**All tests passed.** No rationalizations found.
+
+## Iterations
+
+### Initial Version
+- Complete 4-phase framework
+- Anti-patterns section
+- Flowchart for "fix failed" decision
+
+### Enhancement 1: TDD Reference
+- Added link to skills/testing/test-driven-development
+- Note explaining TDD's "simplest code" ≠ debugging's "root cause"
+- Prevents confusion between methodologies
+
+## Final Outcome
+
+Bulletproof skill that:
+- ✅ Clearly mandates root cause investigation
+- ✅ Resists time pressure rationalization
+- ✅ Provides concrete steps for each phase
+- ✅ Shows anti-patterns explicitly
+- ✅ Tested under multiple pressure scenarios
+- ✅ Clarifies relationship to TDD
+- ✅ Ready for use
+
+## Key Insight
+
+**Most important bulletproofing:** Anti-patterns section showing exact shortcuts that feel justified in the moment. When Claude thinks "I'll just add this one quick fix", seeing that exact pattern listed as wrong creates cognitive friction.
+
+## Usage Example
+
+When encountering a bug:
+1. Load skill: skills/debugging/systematic-debugging
+2. Read overview (10 sec) - reminded of mandate
+3. Follow Phase 1 checklist - forced investigation
+4. If tempted to skip - see anti-pattern, stop
+5. Complete all phases - root cause found
+
+**Time investment:** 5-10 minutes
+**Time saved:** Hours of symptom-whack-a-mole
+
+---
+
+*Created: 2025-10-03*
+*Purpose: Reference example for skill extraction and bulletproofing*