oh-my-claudecode-opencode 0.2.1 → 0.4.0

package/assets/skills/ralph.md

@@ -0,0 +1,136 @@
+---
+name: ralph
+description: Self-referential loop until task completion with architect verification
+user-invocable: true
+---
+
+# Ralph Skill
+
+[RALPH + ULTRAWORK - ITERATION {{ITERATION}}/{{MAX}}]
+
+Your previous attempt did not output the completion promise. Continue working on the task.
+
+## ULTRAWORK MODE (AUTO-ACTIVATED)
+
+Ralph automatically activates Ultrawork for maximum parallel execution. You MUST follow these rules:
+
+### Parallel Execution Rules
+- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially
+- **BACKGROUND FIRST**: Use Task(run_in_background=true) for long operations (10+ concurrent)
+- **DELEGATE**: Route tasks to specialist agents immediately
+
+### Smart Model Routing (SAVE TOKENS)
+
+| Task Complexity | Tier | Examples |
+|-----------------|------|----------|
+| Simple lookups | LOW (haiku) | "What does this function return?", "Find where X is defined" |
+| Standard work | MEDIUM (sonnet) | "Add error handling", "Implement this feature" |
+| Complex analysis | HIGH (opus) | "Debug this race condition", "Refactor auth module" |
+
+### Available Agents by Tier
+
+| Domain | LOW (Haiku) | MEDIUM (Sonnet) | HIGH (Opus) |
+|--------|-------------|-----------------|-------------|
+| **Analysis** | `architect-low` | `architect-medium` | `architect` |
+| **Execution** | `executor-low` | `executor` | `executor-high` |
+| **Search** | `explore` | `explore-medium` | - |
+| **Research** | `researcher-low` | `researcher` | - |
+| **Frontend** | `designer-low` | `designer` | `designer-high` |
+| **Docs** | `writer` | - | - |
+| **Visual** | - | `vision` | - |
+| **Planning** | - | - | `planner` |
+| **Critique** | - | - | `critic` |
+| **Pre-Planning** | - | - | `analyst` |
+| **Testing** | - | `qa-tester` | - |
+| **Security** | `security-reviewer-low` | - | `security-reviewer` |
+| **Build** | `build-fixer-low` | `build-fixer` | - |
+| **TDD** | `tdd-guide-low` | `tdd-guide` | - |
+| **Code Review** | `code-reviewer-low` | - | `code-reviewer` |
+
+**CRITICAL: Always pass `model` parameter explicitly!**
+```
+Task(subagent_type="oh-my-claudecode:architect-low", model="haiku", prompt="...")
+Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="...")
+Task(subagent_type="oh-my-claudecode:architect", model="opus", prompt="...")
+```
+
+### Background Execution Rules
+
+**Run in Background** (set `run_in_background: true`):
+- Package installation: npm install, pip install, cargo build
+- Build processes: npm run build, make, tsc
+- Test suites: npm test, pytest, cargo test
+- Docker operations: docker build, docker pull
+
+**Run Blocking** (foreground):
+- Quick status checks: git status, ls, pwd
+- File reads, edits
+- Simple commands
+
+## COMPLETION REQUIREMENTS
+
+Before claiming completion, you MUST:
+1. Verify ALL requirements from the original task are met
+2. Ensure no partial implementations
+3. Check that code compiles/runs without errors
+4. Verify tests pass (if applicable)
+5. TODO LIST: Zero pending/in_progress tasks
+
+## VERIFICATION BEFORE COMPLETION (IRON LAW)
+
+**NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE**
+
+Before outputting the completion promise:
+
+### Steps (MANDATORY)
+1. **IDENTIFY**: What command proves the task is complete?
+2. **RUN**: Execute verification (test, build, lint)
+3. **READ**: Check output - did it actually pass?
+4. **ONLY THEN**: Proceed to Architect verification
+
+### Red Flags (STOP and verify)
+- Using "should", "probably", "seems to"
+- About to output completion without fresh evidence
+- Expressing satisfaction before verification
+
+### Evidence Chain
+1. Fresh test run output showing pass
+2. Fresh build output showing success
+3. lsp_diagnostics showing 0 errors
+4. THEN Architect verification
+5. THEN completion promise
+
+**Skipping verification = Task NOT complete**
+
+## ARCHITECT VERIFICATION (MANDATORY)
+
+When you believe the task is complete:
+1. **First**, spawn Architect to verify your work (ALWAYS pass model explicitly!):
+   ```
+   Task(subagent_type="oh-my-claudecode:architect", model="opus", prompt="Verify this implementation is complete: [describe what you did]")
+   ```
+
+2. **Wait for Architect's assessment**
+
+3. **If Architect approves**: Output `<promise>{{PROMISE}}</promise>`
+4. **If Architect finds issues**: Fix them, then repeat verification
+
+DO NOT output the completion promise without Architect verification.
+
+## ZERO TOLERANCE
+
+- NO Scope Reduction - deliver FULL implementation
+- NO Partial Completion - finish 100%
+- NO Premature Stopping - ALL TODOs must be complete
+- NO TEST DELETION - fix code, not tests
+
+## INSTRUCTIONS
+
+- Review your progress so far
+- Continue from where you left off
+- Use parallel execution and background tasks
+- When FULLY complete AND Architect verified, output: <promise>{{PROMISE}}</promise>
+- Do not stop until the task is truly done
+
+Original task:
+{{PROMPT}}

package/assets/skills/ralplan.md

@@ -0,0 +1,272 @@
+---
+name: ralplan
+description: Iterative planning with Planner, Architect, and Critic until consensus
+user-invocable: true
+---
+
+# Ralplan Skill
+
+## Overview
+
+Ralplan orchestrates three specialized agents—Planner, Architect, and Critic—in an iterative loop until consensus is reached on a comprehensive work plan. This skill ensures plans are strategically sound, architecturally valid, and thoroughly reviewed before execution.
+
+## The Planning Triad
+
+Three agents collaborate in structured phases to validate and refine work plans:
+
+| Agent | Role | Output |
+|-------|------|--------|
+| **Planner** | Strategic Planner | Creates/refines the work plan |
+| **Architect** | Strategic Advisor | Answers questions, validates architecture |
+| **Critic** | Ruthless Reviewer | Critiques and identifies gaps |
+
+## The Iteration Loop
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                       RALPLAN LOOP                              │
+│                                                                 │
+│    ┌──────────────┐                                             │
+│    │   PLANNER    │◄────────────────────────────────┐           │
+│    │   (Plans)    │                                 │           │
+│    └──────┬───────┘                                 │           │
+│           │                                         │           │
+│           ▼                                         │           │
+│    ┌──────────────┐     Questions?    ┌───────────┐ │           │
+│    │   Has open   │─────────────────► │ ARCHITECT │ │           │
+│    │  questions?  │                   │ (Advises) │ │           │
+│    └──────┬───────┘                   └─────┬─────┘ │           │
+│           │                                 │       │           │
+│           │ No questions                    │       │           │
+│           ▼                                 ▼       │           │
+│    ┌──────────────┐                  ┌──────────┐   │           │
+│    │    CRITIC    │◄─────────────────│ Answers  │   │           │
+│    │  (Reviews)   │                  └──────────┘   │           │
+│    └──────┬───────┘                                 │           │
+│           │                                         │           │
+│           ▼                                         │           │
+│    ┌──────────────┐     REJECT      ┌──────────────┐│           │
+│    │   Verdict?   │─────────────────►│  Feedback   ││           │
+│    └──────┬───────┘                  │ to Planner  │┘           │
+│           │                          └─────────────┘            │
+│           │ OKAY                                                │
+│           ▼                                                     │
+│    ┌──────────────────────────────────────────────────────────┐ │
+│    │                  PLAN APPROVED                           │ │
+│    │           Ready for /ralph execution                     │ │
+│    └──────────────────────────────────────────────────────────┘ │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## State Management
+
+Ralplan maintains persistent state in `.omc/ralplan-state.json` to track progress and enable recovery across interruptions:
+
+```json
+{
+  "active": true,
+  "mode": "ralplan",
+  "iteration": 1,
+  "max_iterations": 5,
+  "plan_path": ".omc/plans/[feature].md",
+  "current_phase": "planner_planning",
+  "started_at": "ISO-timestamp",
+  "task_description": "[original task]"
+}
+```
+
+**Phases**: `planner_planning` → `architect_consultation` → `critic_review` → `handling_verdict` → `complete`
+
+## Plan Mode Interaction (CRITICAL)
+
+**When ralplan is invoked while Plan mode is active:**
+
+The Planner agent has a PHASE 3.5 (CONFIRMATION) that normally requires user confirmation before proceeding. **This MUST be bypassed within ralplan because the Critic serves as the reviewer, not the user.**
+
+### Mandatory Constraints
+
+| Constraint | Rationale |
+|------------|-----------|
+| **Planner MUST skip PHASE 3.5 confirmation** | Critic reviews the plan, not the user |
+| **Critic MUST run before any plan approval** | No plan is approved without Critic verdict |
+| **DO NOT exit plan mode until Critic has rendered verdict** | Premature exit skips the review step |
+| **Log `[RALPLAN] Critic review required before approval`** | Observability for debugging |
+
+### Flow When Plan Mode Is Active
+
+```
+1. Orchestrator invokes ralplan skill
+2. Log: [RALPLAN] Starting - Critic review will be required
+3. Spawn Planner in DIRECT PLANNING MODE (no interview, no confirmation)
+4. Planner outputs PLAN_READY: <path>
+5. Log: [RALPLAN] Plan ready, invoking Critic for review
+6. Spawn Critic with plan path  <-- MUST HAPPEN
+7. Critic renders OKAY or REJECT
+8. ONLY THEN can plan be approved or refined
+```
+
+**CRITICAL: The Critic invocation is MANDATORY. If the Planner completes and signals plan ready, the orchestrator MUST invoke the Critic before any form of plan approval or user confirmation.**
+
+---
+
+## Execution Protocol
+
+### Initialization
+
+The skill begins by establishing the planning environment:
+
+1. Create `.omc/plans/` directory if it doesn't exist
+2. Read task description from user input
+3. Create `ralplan-state.json` with initial values:
+   - `active: true`
+   - `iteration: 0`
+   - `max_iterations: 5`
+   - `current_phase: "planner_planning"`
+   - `started_at`: Current ISO timestamp
+   - `task_description`: User's task description
+
+### Planner Planning Phase
+
+The Planner creates an initial plan based on task context:
+
+- Invoke Planner in **direct planning mode** (bypassing interview since task context is pre-gathered)
+- **CRITICAL: Planner MUST skip PHASE 3.5 (CONFIRMATION)** - the Critic will review, not the user
+- Planner receives task context directly without preliminary questioning
+- Planner mandatorily consults with Metis for gap detection
+- Planner generates plan directly to `.omc/plans/[feature-name].md`
+- Plan includes: requirements summary, concrete acceptance criteria, specific implementation steps with file references, risk identification with mitigations, and verification steps
+- Signal completion with `PLAN_READY: .omc/plans/[filename].md`
+- **After PLAN_READY: DO NOT approve or confirm the plan. Proceed to Critic Review.**
+- Extract plan path from completion signal and update state
+- Log: `[RALPLAN] Critic review required before approval`
+
+### Architect Consultation (Conditional)
+
+The Architect provides strategic guidance in two scenarios:
+
+1. **After Planner**: If Planner raises architectural questions needing strategic input
+2. **After Critic rejection**: If Critic identifies questions requiring expert guidance
+
+When invoked, the Architect receives file paths to read for analysis, not summaries. This enables thorough examination of the existing codebase context before providing recommendations.
+
+### Critic Review (MANDATORY - CANNOT BE SKIPPED)
+
+**CRITICAL: This phase MUST execute. The Critic is the gatekeeper for plan approval.**
+
+Log at start: `[RALPLAN] Invoking Critic for plan review`
+
+The Critic examines the plan against quality standards:
+
+- Critic receives the plan file path (per its design)
+- Critic conducts thorough review of plan completeness and feasibility
+- Critic emits verdict: either `OKAY` (approval) or `REJECT` with specific issues
+
+**Enforcement Rules:**
+1. If Planner signals PLAN_READY, Critic MUST be invoked immediately
+2. DO NOT exit ralplan loop before Critic verdict
+3. DO NOT request user confirmation before Critic verdict
+4. DO NOT trigger any plan mode exit behavior before Critic verdict
+
+Log after Critic completes: `[RALPLAN] Critic verdict: <OKAY|REJECT>`
+
+### Verdict Handling and Iteration
+
+Based on Critic's verdict, the skill either approves the plan or continues iteration:
+
+**If verdict is OKAY:**
+- Mark plan as approved
+- Log approval with iteration count
+- Prepare plan for execution with `/oh-my-claudecode:ralph` or manual orchestration
+- Set state `active: false, current_phase: "complete"`
+
+**If verdict is REJECT:**
+- Extract Critic feedback with specific issues
+- Increment iteration counter
+- If `iteration >= max_iterations` (5):
+  - Force approval with warning about unresolved concerns
+  - Recommend manual review before execution
+- Otherwise:
+  - Feed Critic feedback back to Planner
+  - Return to Planner Planning phase for refinement
+
+## Iteration Rules
+
+| Rule | Description |
+|------|-------------|
+| **Max 5 iterations** | Safety limit prevents infinite loops |
+| **Planner owns plan** | Only Planner writes to plan file |
+| **Architect provides wisdom** | Architect reads and advises, never modifies |
+| **Critic has final say** | Plan approved only when Critic signals OKAY |
+| **Feedback is specific** | Each rejection includes actionable improvements |
+| **State persists** | Progress survives session interruptions |
+
+## Quality Gates
+
+The orchestrator must verify these gates before invoking Critic for each review:
+
+1. **Plan file exists** at the path specified in state
+2. **File references are valid** - Verify all mentioned files exist in codebase
+3. **Acceptance criteria are concrete** - No vague "improve" or "optimize" without measurable metrics
+4. **No ambiguous language** - Each task clearly specifies what to do
+
+If any gate fails, return to Planner with specific failure feedback for remediation.
+
+## Agent Communication Protocol
+
+### Planner to Architect Questions
+
+```
+ARCHITECT_QUESTION:
+- Topic: [Architecture/Performance/Security/Pattern]
+- Context: [What we're planning]
+- Files to examine: [specific paths]
+- Specific Question: [What we need answered]
+```
+
+### Architect to Planner Answers
+
+```
+ARCHITECT_ANSWER:
+- Topic: [Matching topic]
+- Analysis: [What Architect found after reading files]
+- Recommendation: [Specific guidance]
+- Trade-offs: [What to consider]
+- References: [file:line citations from codebase]
+```
+
+### Critic to Planner Feedback
+
+```
+CRITIC_FEEDBACK:
+- Verdict: REJECT
+- Critical Issues:
+  1. [Issue with specific fix required]
+  2. [Issue with specific fix required]
+- Minor Issues:
+  1. [Nice to fix]
+- Questions for Architect (if any):
+  1. [Architectural question needing expert input]
+```
+
+## Cancellation
+
+To stop an active ralplan session:
+
+- Use `/oh-my-claudecode:cancel-ralph` (automatically detects ralplan via state file)
+- Or manually delete `.omc/ralplan-state.json`
+
+## Skill Workflow
+
+1. **Initialize state** and log: `[RALPLAN Iteration 0/5] Initializing...`
+2. **Parse task** from user input
+3. **Spawn Planner** in direct planning mode (SKIP Planner's PHASE 3.5 confirmation)
+4. **Wait for PLAN_READY** signal from Planner
+5. **Log:** `[RALPLAN] Critic review required before approval`
+6. **Invoke Critic** with plan file path (MANDATORY - CANNOT BE SKIPPED)
+7. **Log:** `[RALPLAN] Critic verdict: <verdict>`
+8. **Handle verdict** - if REJECT, loop back to step 3 with feedback
+9. **Complete** ONLY when Critic approves or max iterations reached with warnings
+
+**HARD RULE:** Steps 5-7 are NON-NEGOTIABLE. No plan approval, user confirmation, or plan mode exit can occur before the Critic has rendered its verdict. This prevents the plan mode confirmation flow from short-circuiting the ralplan review loop.
+
+The iterative loop refines the plan until it meets the rigorous standards of all three agents, ensuring comprehensive, architecturally sound work plans ready for execution.

package/assets/skills/release.md

@@ -0,0 +1,84 @@
+---
+name: release
+description: Automated release workflow for oh-my-claudecode
+user-invocable: true
+---
+
+# Release Skill
+
+Automate the release process for oh-my-claudecode.
+
+## Usage
+
+```
+/oh-my-claudecode:release <version>
+```
+
+Example: `/oh-my-claudecode:release 2.4.0` or `/oh-my-claudecode:release patch` or `/oh-my-claudecode:release minor`
+
+## Release Checklist
+
+Execute these steps in order:
+
+### 1. Version Bump
+Update version in all locations:
+- `package.json`
+- `src/installer/index.ts` (VERSION constant)
+- `src/__tests__/installer.test.ts` (expected version)
+- `.claude-plugin/plugin.json`
+- `README.md` (version badge and title)
+
+### 2. Run Tests
+```bash
+npm run test:run
+```
+All 231+ tests must pass before proceeding.
+
+### 3. Commit Version Bump
+```bash
+git add -A
+git commit -m "chore: Bump version to <version>"
+```
+
+### 4. Create & Push Tag
+```bash
+git tag v<version>
+git push origin main
+git push origin v<version>
+```
+
+### 5. Publish to npm
+```bash
+npm publish --access public
+```
+
+### 6. Create GitHub Release
+```bash
+gh release create v<version> --title "v<version> - <title>" --notes "<release notes>"
+```
+
+### 7. Verify
+- [ ] npm: https://www.npmjs.com/package/oh-my-claudecode
+- [ ] GitHub: https://github.com/Yeachan-Heo/oh-my-claudecode/releases
+
+## Version Files Reference
+
+| File | Field/Line |
+|------|------------|
+| `package.json` | `"version": "X.Y.Z"` |
+| `src/installer/index.ts` | `export const VERSION = 'X.Y.Z'` |
+| `src/__tests__/installer.test.ts` | `expect(VERSION).toBe('X.Y.Z')` |
+| `.claude-plugin/plugin.json` | `"version": "X.Y.Z"` |
+| `README.md` | Title + version badge |
+
+## Semantic Versioning
+
+- **patch** (X.Y.Z+1): Bug fixes, minor improvements
+- **minor** (X.Y+1.0): New features, backward compatible
+- **major** (X+1.0.0): Breaking changes
+
+## Notes
+
+- Always run tests before publishing
+- Create release notes summarizing changes
+- Plugin marketplace syncs automatically from GitHub releases