rpi-kit 1.0.0

package/commands/rpi/plan.md

@@ -0,0 +1,175 @@
+---
+name: rpi:plan
+description: Generate adaptive plan artifacts from research. Creates PLAN.md with task checklist, eng.md, and optionally pm.md and ux.md.
+argument-hint: "<feature-slug> [--force] [--skip-pm] [--skip-ux]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+  - AskUserQuestion
+---
+
+<objective>
+Generate implementation plan artifacts from the research output. Adapts which artifacts to create based on feature type.
+</objective>
+
+<process>
+
+## 1. Load config and parse arguments
+
+Read `.rpi.yaml` for configuration.
+Parse `$ARGUMENTS`:
+- First argument: `{feature-slug}` (required)
+- `--force`: proceed even if research verdict was NO-GO
+- `--skip-pm`: don't generate pm.md
+- `--skip-ux`: don't generate ux.md
+
+## 2. Validate prerequisites
+
+Read `{folder}/{feature-slug}/research/RESEARCH.md`. If missing:
+```
+Research not found. Run /rpi:research {feature-slug} first.
+```
+
+Check the verdict in RESEARCH.md. If NO-GO and no `--force` flag:
+```
+Research verdict is NO-GO. Review alternatives in RESEARCH.md.
+To proceed anyway: /rpi:plan {feature-slug} --force
+```
+
+If plan artifacts already exist, ask: "Plan already exists. Overwrite?"
+
+## 3. Detect feature type and confirm artifacts
+
+Analyze RESEARCH.md to detect feature type:
+- Has UI components, user flows, or frontend files → suggest pm.md + ux.md
+- Backend only, API, or infrastructure → suggest skipping ux.md
+- Simple utility or refactor → suggest skipping pm.md + ux.md
+
+Present detection to user with AskUserQuestion:
+"Based on the research, this looks like a {type} feature. I'll generate:"
+- Options showing which artifacts will be created
+- Let user confirm or adjust
+
+Apply any `--skip-pm` or `--skip-ux` flags as overrides.
+
+## 4. Generate eng.md (always)
+
+Launch senior-engineer agent:
+```
+You are planning the technical implementation for a feature.
+
+Read these files:
+- {folder}/{feature-slug}/REQUEST.md
+- {folder}/{feature-slug}/research/RESEARCH.md
+
+Produce eng.md — a technical specification covering:
+1. Architecture overview (how it fits into existing codebase)
+2. Dependencies (new packages, existing modules to extend)
+3. Data models (schema changes, new types)
+4. API design (endpoints, contracts, error handling)
+5. File structure (new files to create, existing files to modify)
+6. Testing strategy (what to test, how)
+
+Be concrete. Cite existing codebase files and patterns from the research.
+Follow senior-engineer rules from RPI agent guidelines.
+```
+
+## 5. Generate pm.md (if not skipped)
+
+Launch product-manager agent:
+```
+You are creating product requirements for a feature.
+
+Read these files:
+- {folder}/{feature-slug}/REQUEST.md
+- {folder}/{feature-slug}/research/RESEARCH.md
+
+Produce pm.md — product requirements covering:
+1. User stories with acceptance criteria
+2. Scope definition with effort estimates (S/M/L/XL per item)
+3. Out of scope (what this feature does NOT do)
+4. Success metrics (how to measure if the feature works)
+5. Edge cases and error scenarios
+
+Follow product-manager rules from RPI agent guidelines.
+```
+
+## 6. Generate ux.md (if not skipped)
+
+Launch ux-designer agent:
+```
+You are designing the user experience for a feature.
+
+Read these files:
+- {folder}/{feature-slug}/REQUEST.md
+- {folder}/{feature-slug}/research/RESEARCH.md
+
+Produce ux.md — UX design covering:
+1. User journey (step-by-step flow from entry to completion)
+2. Interaction patterns (what the user sees and does at each step)
+3. Edge cases (errors, empty states, loading, permissions)
+4. Existing components to reuse (cite from codebase research)
+5. Accessibility considerations
+
+Follow ux-designer rules from RPI agent guidelines.
+```
+
+## 7. Generate PLAN.md
+
+After all agents complete (eng.md is required, pm.md and ux.md may be parallel), launch senior-engineer agent again to create the task breakdown:
+
+```
+You are creating an implementation plan from the technical spec.
+
+Read these files:
+- {folder}/{feature-slug}/REQUEST.md
+- {folder}/{feature-slug}/research/RESEARCH.md
+- {folder}/{feature-slug}/plan/eng.md
+- {folder}/{feature-slug}/plan/pm.md (if exists)
+- {folder}/{feature-slug}/plan/ux.md (if exists)
+
+Produce PLAN.md — an ordered task checklist organized by phases.
+
+Format for each task:
+- [ ] **{phase}.{task}** {Task description}
+  Effort: S | M | L | XL | Deps: {task IDs or "none"}
+  Files: {files to create or modify}
+  Test: {what to test — behavior assertion in plain language}
+
+Group tasks into logical phases (e.g., Phase 1: Data Layer, Phase 2: Business Logic, Phase 3: UI, Phase 4: Integration).
+
+Rules:
+- Every task should be completable in one focused session
+- L or XL tasks should be broken into smaller subtasks
+- Dependencies must be explicit — no circular deps
+- Files listed must be specific paths, not directories
+- Every task must have a Test field describing what behavior to verify
+- Test descriptions should be assertions, not vague: "returns 404 for missing user" not "test error handling"
+```
+
+## 8. Write all artifacts
+
+Write all generated files to `{folder}/{feature-slug}/plan/`:
+- `PLAN.md` (always)
+- `eng.md` (always)
+- `pm.md` (if generated)
+- `ux.md` (if generated)
+
+## 9. Present plan summary
+
+Output:
+```
+Plan created for {feature-slug}:
+- PLAN.md: {N} tasks across {M} phases
+- eng.md: Technical specification
+{- pm.md: Product requirements (if generated)}
+{- ux.md: UX design (if generated)}
+
+Next: /rpi:implement {feature-slug}
+```
+
+</process>

package/commands/rpi/research.md

@@ -0,0 +1,142 @@
+---
+name: rpi:research
+description: Run research phase on a feature. Parallel agent analysis produces RESEARCH.md with GO/NO-GO verdict. Supports tiers (--quick, --standard, --deep).
+argument-hint: "<feature-slug> [--quick|--standard|--deep] [--force]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+  - AskUserQuestion
+---
+
+<objective>
+Run parallel research agents on a feature's REQUEST.md, synthesize findings into RESEARCH.md with a GO/NO-GO verdict.
+</objective>
+
+<process>
+
+## 1. Load config and parse arguments
+
+Read `.rpi.yaml` for folder path and default tier.
+Parse `$ARGUMENTS`:
+- First argument: `{feature-slug}` (required)
+- Flags: `--quick`, `--standard`, `--deep` (override config tier)
+- Flag: `--force` (proceed even if previous research exists)
+
+## 2. Validate feature
+
+Read `{folder}/{feature-slug}/REQUEST.md`. If it doesn't exist, error:
+```
+Feature not found: {folder}/{feature-slug}/REQUEST.md
+Run /rpi:new {feature-slug} first.
+```
+
+If `{folder}/{feature-slug}/research/RESEARCH.md` already exists and `--force` not set, ask user:
+"Research already exists for this feature. Overwrite?"
+
+## 3. Determine agent composition by tier
+
+**--quick (2 agents):**
+- requirement-parser
+- explore-codebase
+
+**--standard (4 agents):**
+- requirement-parser
+- explore-codebase
+- product-manager
+- senior-engineer
+
+**--deep (6 agents):**
+- requirement-parser
+- explore-codebase
+- product-manager
+- senior-engineer
+- cto-advisor
+- ux-designer (only if REQUEST.md suggests UI involvement)
+
+## 4. Launch research agents in parallel
+
+Use the Agent tool to launch ALL selected agents concurrently in a single message.
+
+Each agent receives this prompt:
+```
+You are the {role-name} agent for the RPI workflow.
+
+Read the following files before analysis:
+- {folder}/{feature-slug}/REQUEST.md
+
+Then analyze the feature from your role's perspective following the RPI agent guidelines.
+
+Your output format:
+## [{Your Role Title}]
+
+### {Section Name}
+Verdict: GO | CONCERN | BLOCK
+{Findings with evidence — cite specific files, deps, patterns}
+
+### {Next Section}
+...
+
+Estimated Complexity: S | M | L | XL
+
+Follow your role-specific rules as defined in the rpi-agents skill.
+```
+
+For explore-codebase agent, also instruct it to scan the project codebase for relevant files, patterns, and conventions.
+
+## 5. Synthesize into RESEARCH.md
+
+After all agents complete, use the Agent tool to launch the doc-synthesizer agent.
+
+Prompt:
+```
+You are the doc-synthesizer agent for the RPI workflow.
+
+Merge the following research outputs into a single RESEARCH.md:
+
+{paste all agent outputs}
+
+Follow the RPI agent guidelines for doc-synthesizer:
+1. Executive summary first: verdict, complexity, risk in 5 lines
+2. No contradictions left unresolved
+3. Preserve the strongest finding from each agent
+4. If NO-GO, alternatives section is mandatory
+5. Section order: Summary → Requirements → Product → Codebase → Technical → Strategic → Alternatives
+```
+
+## 6. Write RESEARCH.md
+
+Write the synthesized output to `{folder}/{feature-slug}/research/RESEARCH.md`.
+
+## 7. Present verdict
+
+Display the executive summary to the user.
+
+If **GO**:
+```
+Verdict: GO
+Next: /rpi:plan {feature-slug}
+```
+
+If **GO with concerns**:
+```
+Verdict: GO with concerns
+{list concerns}
+Next: /rpi:plan {feature-slug}
+```
+
+If **NO-GO**:
+```
+Verdict: NO-GO
+{reasons}
+
+Alternatives:
+{suggested alternatives from research}
+
+Override: /rpi:plan {feature-slug} --force
+```
+
+</process>

package/commands/rpi/review.md

@@ -0,0 +1,131 @@
+---
+name: rpi:review
+description: Run code review against the implementation plan. Checks that all tasks are implemented, deviations are justified, and requirements are met.
+argument-hint: "<feature-slug>"
+allowed-tools:
+  - Read
+  - Glob
+  - Grep
+  - Bash
+  - Agent
+  - Write
+---
+
+<objective>
+Review the implementation against the plan. Check completeness, correctness, and plan alignment. Output PASS or FAIL with specific findings.
+</objective>
+
+<process>
+
+## 1. Load config and validate
+
+Read `.rpi.yaml` for folder path.
+Validate that all required files exist:
+- `{folder}/{feature-slug}/plan/PLAN.md`
+- `{folder}/{feature-slug}/plan/eng.md`
+- `{folder}/{feature-slug}/implement/IMPLEMENT.md`
+
+If any missing, error with guidance on which command to run.
+
+## 2. Gather context
+
+Read all plan and implementation files:
+- REQUEST.md (original requirements)
+- RESEARCH.md (research findings)
+- PLAN.md (task checklist)
+- eng.md (technical spec)
+- pm.md (if exists — acceptance criteria)
+- ux.md (if exists — UX requirements)
+- IMPLEMENT.md (implementation record)
+
+## 3. Launch code-reviewer agent
+
+```
+You are the code-reviewer agent for the RPI workflow.
+
+Read these files for the complete feature context:
+- {folder}/{feature-slug}/REQUEST.md
+- {folder}/{feature-slug}/research/RESEARCH.md
+- {folder}/{feature-slug}/plan/PLAN.md
+- {folder}/{feature-slug}/plan/eng.md
+{- {folder}/{feature-slug}/plan/pm.md (if exists)}
+{- {folder}/{feature-slug}/plan/ux.md (if exists)}
+- {folder}/{feature-slug}/implement/IMPLEMENT.md
+
+Then review the actual code changes. Use Grep and Glob to find the files listed in the plan and verify the implementation.
+
+Your review must check:
+
+### 1. Completeness
+- Are all tasks from PLAN.md implemented? List any missing tasks.
+- Are all files from eng.md created/modified as specified?
+
+### 2. Correctness
+- Does the implementation match the technical approach in eng.md?
+- If pm.md exists: are acceptance criteria met?
+- If ux.md exists: are user flows implemented correctly?
+
+### 3. Deviations
+- Read the Deviations section of IMPLEMENT.md
+- Are listed deviations justified?
+- Are there unlisted deviations (implementation differs from plan but not recorded)?
+
+### 4. Test coverage
+- Does every task have at least one test?
+- Do tests exercise real code through public interfaces (no mocks unless external dependency)?
+- Do test names describe behavior clearly?
+- Are edge cases from eng.md covered?
+- If TDD was enabled: verify tests were written before implementation (check git log order)
+
+### 5. Code quality
+- Any obvious bugs or logic errors?
+- Security concerns (injection, auth bypass, data exposure)?
+
+### Output format:
+
+## Review: {feature-slug}
+
+### Verdict: {PASS|FAIL}
+
+### Completeness
+- {task_id}: {status} — {details}
+
+### Correctness
+- {finding with file:line reference}
+
+### Deviations
+- {deviation}: {justified|unjustified} — {reason}
+
+### Issues (if any)
+- [{severity}] {file}:{line} — {description}
+
+Follow code-reviewer rules from RPI agent guidelines:
+- Every finding cites a plan requirement or coding standard
+- No style nitpicks — focus on correctness, completeness, plan alignment
+- Verdict is PASS only if all requirements are met
+```
+
+## 4. Update IMPLEMENT.md
+
+Write the review results into the `## Review` section of IMPLEMENT.md.
+
+## 5. Present verdict
+
+If PASS:
+```
+Review: PASS
+All {N} tasks implemented. Requirements met.
+Feature {feature-slug} is complete.
+```
+
+If FAIL:
+```
+Review: FAIL
+{list specific gaps}
+
+Options:
+- Fix the issues and re-run: /rpi:review {feature-slug}
+- Accept as-is: mark complete manually in IMPLEMENT.md
+```
+
+</process>

package/commands/rpi/simplify.md

@@ -0,0 +1,118 @@
+---
+name: rpi:simplify
+description: Run code simplification on a feature's implementation. Checks for reuse opportunities, quality issues, and efficiency problems, then fixes them.
+argument-hint: "<feature-slug>"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+---
+
+<objective>
+Run 3 parallel code review sub-agents (reuse, quality, efficiency) on the implementation changes, aggregate findings, and fix issues directly.
+</objective>
+
+<process>
+
+## 1. Load config and identify changes
+
+Read `.rpi.yaml` for folder path.
+Read `{folder}/{feature-slug}/implement/IMPLEMENT.md` to identify what was implemented.
+
+Get the diff of all implementation changes:
+```bash
+git diff HEAD~{number_of_commits}
+```
+
+If no git history, use the files listed in IMPLEMENT.md tasks and read them directly.
+
+## 2. Launch 3 parallel sub-agents
+
+Use the Agent tool to launch all 3 concurrently in a single message.
+
+### Agent 1: Reuse Checker
+
+```
+You are checking code for reuse opportunities.
+
+Here is the diff of recent changes:
+{diff}
+
+For each change:
+1. Search the codebase for existing utilities and helpers that could replace newly written code. Use Grep to find similar patterns — check utility directories, shared modules, and adjacent files.
+2. Flag any new function that duplicates existing functionality. Cite the existing function.
+3. Flag inline logic that could use an existing utility — hand-rolled string manipulation, manual path handling, custom type guards.
+
+Output format:
+## Reuse Findings
+- {file}:{line} — {description} → Use existing `{function}` from `{path}`
+```
+
+### Agent 2: Quality Checker
+
+```
+You are checking code quality in recent changes.
+
+Here is the diff of recent changes:
+{diff}
+
+Check for:
+1. Redundant state — state that duplicates existing state, cached values that could be derived
+2. Parameter sprawl — adding parameters instead of restructuring
+3. Copy-paste with slight variation — near-duplicate blocks that should be unified
+4. Leaky abstractions — exposing internals, breaking abstraction boundaries
+5. Stringly-typed code — raw strings where constants or enums exist
+
+Output format:
+## Quality Findings
+- {file}:{line} — {pattern}: {description}
+```
+
+### Agent 3: Efficiency Checker
+
+```
+You are checking code efficiency in recent changes.
+
+Here is the diff of recent changes:
+{diff}
+
+Check for:
+1. Unnecessary work — redundant computations, repeated reads, duplicate API calls, N+1 patterns
+2. Missed concurrency — independent operations run sequentially
+3. Hot-path bloat — blocking work on startup or per-request paths
+4. Unnecessary existence checks — TOCTOU anti-pattern
+5. Memory — unbounded structures, missing cleanup, listener leaks
+6. Overly broad operations — reading entire files when portion needed
+
+Output format:
+## Efficiency Findings
+- {file}:{line} — {pattern}: {description}
+```
+
+## 3. Aggregate and fix
+
+After all 3 agents complete:
+
+1. Collect all findings
+2. Skip false positives — if a finding doesn't apply or isn't worth fixing, skip silently
+3. Fix each valid issue directly using Edit tool
+4. For each fix, note what was changed
+
+## 4. Output summary
+
+```
+Simplify complete for {feature-slug}:
+- Reuse: {N} findings, {M} fixed
+- Quality: {N} findings, {M} fixed
+- Efficiency: {N} findings, {M} fixed
+
+{Or: "Code was already clean — no issues found."}
+```
+
+If called from /rpi:implement, return findings for recording in IMPLEMENT.md.
+
+</process>

package/commands/rpi/status.md

@@ -0,0 +1,115 @@
+---
+name: rpi:status
+description: Show all RPI features and their current phase, progress, and status.
+argument-hint: "[feature-slug]"
+allowed-tools:
+  - Read
+  - Glob
+  - Bash
+---
+
+<objective>
+Display detailed status cards for all features (or a specific feature) in the RPI workflow.
+</objective>
+
+<process>
+
+## 1. Load config
+
+Read `.rpi.yaml` for folder path. Default to `rpi/` if not found.
+
+## 2. Discover features
+
+Use Glob to find all `REQUEST.md` files:
+```
+{folder}/*/REQUEST.md
+```
+
+Each parent directory is a feature slug.
+
+If `$ARGUMENTS` specifies a feature slug, filter to that feature only.
+
+If no features found:
+```
+No RPI features found in {folder}/.
+Run /rpi:new to start your first feature.
+```
+
+## 3. Determine phase for each feature
+
+For each feature slug, check which files exist:
+
+- `REQUEST.md` exists, no `research/RESEARCH.md` → Phase: **new**
+- `research/RESEARCH.md` exists, no `plan/PLAN.md` → Phase: **researched**
+- `plan/PLAN.md` exists, no `implement/IMPLEMENT.md` → Phase: **planned**
+- `implement/IMPLEMENT.md` exists → Phase: **implementing** or **complete**
+
+## 4. Gather details per feature
+
+For each feature, read the relevant files to extract:
+
+**If researched or later:**
+- Read RESEARCH.md executive summary for verdict and complexity
+
+**If planned or later:**
+- Read PLAN.md to count total tasks and phases
+
+**If implementing:**
+- Read IMPLEMENT.md to count completed tasks `[x]` vs total `[ ]`
+- Identify current task (first unchecked)
+- Check for review verdict
+
+**If complete:**
+- Read IMPLEMENT.md for final review verdict and completion timestamp
+
+## 5. Display detailed cards
+
+Output a card per feature:
+
+```markdown
+## {feature-slug}
+Phase: {phase} ({progress details})
+Verdict: {GO|GO with concerns|NO-GO|—}
+{Complexity: S|M|L|XL (if known)}
+{Current: Task {id} — {name} (if implementing)}
+{Review: PASS|FAIL (if reviewed)}
+```
+
+### Example output:
+
+```markdown
+# RPI Status
+
+## oauth2-auth
+Phase: implement (6/9 tasks)
+Verdict: GO
+Complexity: M
+Current: Task 2.1 — Login component
+
+## payment-system
+Phase: research
+Verdict: pending
+Complexity: —
+
+## dark-mode
+Phase: plan (ready to implement)
+Verdict: GO
+Complexity: S
+
+## csv-export
+Phase: new
+Verdict: —
+```
+
+## 6. Suggest next action
+
+For each feature, suggest the logical next command:
+- **new** → `/rpi:research {slug}`
+- **researched (GO)** → `/rpi:plan {slug}`
+- **researched (NO-GO)** → Review alternatives or `/rpi:plan {slug} --force`
+- **planned** → `/rpi:implement {slug}`
+- **implementing** → `/rpi:implement {slug} --resume`
+- **complete (PASS)** → Done
+- **complete (FAIL)** → `/rpi:review {slug}`
+
+</process>