claudecode-omc 4.8.3 → 4.8.4

package/skills/planning-with-files/scripts/init-session.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Initialize planning files in the current project root.
+# Usage: bash skills/planning-with-files/scripts/init-session.sh [project-name]
+
+set -euo pipefail
+
+PROJECT_NAME="${1:-project}"
+DATE="$(date +%Y-%m-%d)"
+
+echo "Initializing planning files for: ${PROJECT_NAME}"
+
+if [[ ! -f task_plan.md ]]; then
+  cp skills/planning-with-files/templates/task_plan.md task_plan.md
+  echo "Created task_plan.md"
+else
+  echo "task_plan.md already exists, skipping"
+fi
+
+if [[ ! -f findings.md ]]; then
+  cp skills/planning-with-files/templates/findings.md findings.md
+  echo "Created findings.md"
+else
+  echo "findings.md already exists, skipping"
+fi
+
+if [[ ! -f progress.md ]]; then
+  cp skills/planning-with-files/templates/progress.md progress.md
+  # Replace session token with current date for convenience.
+  sed -i.bak "s/\\[DATE\\]/${DATE}/g" progress.md && rm -f progress.md.bak
+  echo "Created progress.md"
+else
+  echo "progress.md already exists, skipping"
+fi
+
+echo "Planning files initialized."
+

package/skills/planning-with-files/scripts/session-catchup.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+Session catchup helper for planning-with-files.
+
+Checks if planning files were updated long ago while the working tree changed,
+and prints a lightweight catchup reminder.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+PLANNING_FILES = ("task_plan.md", "findings.md", "progress.md")
+
+
+def run(cmd: list[str], cwd: Path) -> str:
+    try:
+        out = subprocess.check_output(cmd, cwd=str(cwd), stderr=subprocess.STDOUT, text=True)
+        return out.strip()
+    except Exception:
+        return ""
+
+
+def newest_planning_mtime(root: Path) -> float:
+    mtimes = []
+    for name in PLANNING_FILES:
+        p = root / name
+        if p.exists():
+            mtimes.append(p.stat().st_mtime)
+    return max(mtimes) if mtimes else 0.0
+
+
+def main() -> int:
+    root = Path(sys.argv[1]).resolve() if len(sys.argv) > 1 else Path.cwd().resolve()
+    if not (root / ".git").exists():
+        return 0
+
+    planning_mtime = newest_planning_mtime(root)
+    if planning_mtime == 0:
+        return 0
+
+    diff_stat = run(["git", "diff", "--stat"], root)
+    if not diff_stat:
+        return 0
+
+    now = datetime.now().timestamp()
+    age_hours = (now - planning_mtime) / 3600
+    if age_hours < 1:
+        return 0
+
+    print("[planning-with-files] Catchup reminder")
+    print("Detected git changes after last planning file update.")
+    print("Recommended next steps:")
+    print("1. Read task_plan.md, findings.md, progress.md")
+    print("2. Run: git diff --stat")
+    print("3. Sync planning files with current code changes")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

package/skills/planning-with-files/templates/findings.md

@@ -0,0 +1,24 @@
+# Findings and Decisions
+
+## Requirements
+-
+
+## Research Findings
+-
+
+## Technical Decisions
+| Decision | Rationale |
+|----------|-----------|
+|          |           |
+
+## Issues Encountered
+| Issue | Resolution |
+|-------|------------|
+|       |            |
+
+## Resources
+-
+
+## Visual or Browser Findings
+-
+

package/skills/planning-with-files/templates/progress.md

@@ -0,0 +1,38 @@
+# Progress Log
+
+## Session: [DATE]
+
+### Phase 1: [Title]
+- **Status:** in_progress
+- **Started:** [timestamp]
+- Actions taken:
+  -
+- Files created or modified:
+  -
+
+### Phase 2: [Title]
+- **Status:** pending
+- Actions taken:
+  -
+- Files created or modified:
+  -
+
+## Test Results
+| Test | Input | Expected | Actual | Status |
+|------|-------|----------|--------|--------|
+|      |       |          |        |        |
+
+## Error Log
+| Timestamp | Error | Attempt | Resolution |
+|-----------|-------|---------|------------|
+|           |       | 1       |            |
+
+## Reboot Check
+| Question | Answer |
+|----------|--------|
+| Where am I? | Phase X |
+| Where am I going? | Remaining phases |
+| What is the goal? | See task_plan.md |
+| What have I learned? | See findings.md |
+| What have I done? | See this file |
+

package/skills/planning-with-files/templates/task_plan.md

@@ -0,0 +1,53 @@
+# Task Plan: [Brief Description]
+
+## Goal
+[One sentence describing the end state]
+
+## Current Phase
+Phase 1
+
+## Phases
+
+### Phase 1: Requirements and Discovery
+- [ ] Understand user intent
+- [ ] Identify constraints and requirements
+- [ ] Document findings in findings.md
+- **Status:** in_progress
+
+### Phase 2: Planning and Structure
+- [ ] Define technical approach
+- [ ] Create project structure if needed
+- [ ] Document major decisions
+- **Status:** pending
+
+### Phase 3: Implementation
+- [ ] Execute plan in small steps
+- [ ] Keep changes reversible
+- [ ] Verify incrementally
+- **Status:** pending
+
+### Phase 4: Testing and Verification
+- [ ] Verify requirements are met
+- [ ] Log test results in progress.md
+- [ ] Fix issues found
+- **Status:** pending
+
+### Phase 5: Delivery
+- [ ] Review output quality
+- [ ] Summarize results and residual risks
+- **Status:** pending
+
+## Key Questions
+1. [Question to answer]
+2. [Question to answer]
+
+## Decisions Made
+| Decision | Rationale |
+|----------|-----------|
+|          |           |
+
+## Errors Encountered
+| Error | Attempt | Resolution |
+|-------|---------|------------|
+|       | 1       |            |
+

package/skills/start-dev/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: start-dev
+description: Adaptive development workflow that runs discover -> research -> plan -> implement -> verify with explicit quality gates.
+---
+
+# start-dev
+
+Use this skill as a practical default for non-trivial feature delivery.
+
+## Goal
+
+Move from request to verified implementation with minimal rework.
+
+## Workflow
+
+1. Discover:
+   - Map affected modules
+   - Identify constraints and existing patterns
+2. Research:
+   - Validate version-sensitive APIs and framework behavior from official docs
+3. Plan:
+   - Define smallest reversible change
+   - List files and risks
+4. Implement:
+   - Execute in small increments
+   - Keep tests and build green
+5. Verify:
+   - Run targeted tests, then broader checks
+   - Summarize residual risk honestly
+
+## Delegation Pattern
+
+- `explore` for codebase mapping
+- `architect` for design tradeoffs
+- `executor` for implementation
+- `test-engineer` for test strategy
+- `code-reviewer` or `verifier` for final quality pass
+
+## Quality Gates
+
+- Requirements are explicit before coding.
+- Plan includes rollback strategy.
+- Verification commands and results are captured.
+- No completion claim without evidence.
+

package/skills/tdd-generator/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: tdd-generator
+description: Test-driven workflow for unit, component, and E2E testing. Enforces Red-Green-Refactor and generates the right test type for changed code.
+---
+
+# TDD Generator
+
+Use this skill to drive implementation through tests first.
+
+## Workflow
+
+1. Detect target type:
+   - Pure logic -> unit tests
+   - UI behavior -> component/integration tests
+   - User journeys -> E2E tests
+2. RED:
+   - Write failing test first
+3. GREEN:
+   - Implement minimal code to pass
+4. REFACTOR:
+   - Improve structure while keeping tests green
+5. Add regression cases for discovered bugs and edges.
+
+## Recommended Stack
+
+- Unit/component: Vitest + Testing Library
+- E2E: Playwright
+
+## E2E Agent Option
+
+For large journey suites, you can run Playwright test agents:
+
+```bash
+npx playwright test --init-agents
+npx playwright test --agent=planner
+npx playwright test --agent=generator
+npx playwright test --agent=healer --repeat
+```
+
+## Quality Rules
+
+- Test behavior, not private implementation details.
+- Prefer semantic queries (`getByRole`, `getByLabelText`) for UI tests.
+- Keep one assertion intent per test case.
+- Add explicit edge cases and failure-path coverage.
+
+## References
+
+- Playwright best practices: https://playwright.dev/docs/best-practices
+- Vitest guide: https://vitest.dev/guide/
+

package/skills/test-coverage/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: test-coverage
+description: Analyze coverage, prioritize untested risk hotspots, generate missing tests, and verify threshold improvements.
+---
+
+# Test Coverage
+
+Use this skill to close meaningful coverage gaps, not just raise percentages.
+
+## Workflow
+
+1. Run coverage:
+   - `pnpm test --coverage` or `npx vitest run --coverage`
+2. Parse summary and rank low-coverage files by risk:
+   - Business-critical logic
+   - Error handling paths
+   - Security-sensitive branches
+3. Generate targeted tests:
+   - Unit for pure functions
+   - Integration for service/API boundaries
+   - E2E for critical user journeys
+4. Re-run coverage and report before/after delta.
+
+## Coverage Rules
+
+- Use thresholds per project policy; default target can start at 80%.
+- Cover meaningful branches and failure modes, not only statements.
+- Exclude generated/build/vendor files explicitly.
+- Enable all-file analysis when feasible to avoid hidden zero-coverage files.
+
+## Vitest Guidance
+
+- Default provider is V8; use Istanbul if project requires instrumentation parity.
+- Configure `coverage.include`, `coverage.exclude`, and `coverage.thresholds`.
+
+## References
+
+- Vitest coverage guide: https://vitest.dev/guide/coverage.html
+- Vitest coverage config: https://vitest.dev/config/#coverage
+

package/skills/test-gen/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: test-gen
+description: Post-change intelligent test generation workflow that detects stack, analyzes changed files, and produces acceptance plus regression tests.
+---
+
+# Test Generation Workflow
+
+Use this skill after code changes to generate the right tests quickly.
+
+## Workflow
+
+### Phase 1: Detect context
+
+```bash
+omc test detect-stack
+omc test changed
+omc test analyze path/to/file
+```
+
+Prefer `omc test changed` when the goal is to cover the current diff.
+
+### Phase 2: Generate testing pack
+
+```bash
+omc test gen path/to/file
+```
+
+Expected artifacts:
+
+- test plan
+- acceptance checklist
+- regression checklist
+
+### Phase 3: Write or update tests
+
+Choose test depth by risk:
+
+- Pure logic -> unit tests
+- UI behavior -> component/integration tests
+- Async I/O or cross-boundary behavior -> integration tests
+- Critical user flows -> E2E tests
+
+### Phase 4: Verify
+
+Run the smallest targeted test command first, then broaden if needed.
+
+If higher orchestration is needed, combine with:
+
+- `/oh-my-claudecode:tdd-generator`
+- `/oh-my-claudecode:test-coverage`
+- `/oh-my-claudecode:ultraqa`
+
+## Rules
+
+- Do not stop at happy-path-only coverage.
+- Add regression assertions for risk signals.
+- Avoid implementation-detail-only tests.
+- If no safe automated test can be added, provide a concrete manual regression checklist.
+
+## Output
+
+Always report:
+
+1. analyzed target files
+2. generated/updated test files
+3. acceptance items covered
+4. regression items covered
+5. commands executed
+6. remaining gaps
+