rpi-kit 2.2.2 → 2.5.0

package/.gemini/commands/rpi/rpi.toml

@@ -0,0 +1,114 @@
+description = "Auto-progress a feature to its next phase. Detects current state and runs the appropriate step."
+
+prompt = """
+# /rpi — Auto-Flow
+
+Detects the current phase of a feature and runs the next step automatically.
+
+---
+
+## Step 1: Load config and parse arguments
+
+1. Read `.rpi.yaml` for config. Apply defaults if missing:
+   - `folder`: `rpi/features`
+2. Parse `$ARGUMENTS` to extract:
+   - `{slug}` — the feature name (required)
+   - `--skip=phase` — skip a specific phase and detect the next one
+   - `--from=phase` — override detection, start from this phase
+   - `--force` — pass through to the delegated command
+
+If `{slug}` is not provided, ask with AskUserQuestion: "Which feature? Provide the slug (e.g. 'oauth', 'dark-mode')."
+
+## Step 2: Validate feature exists
+
+Check if `rpi/features/{slug}/` exists and contains `REQUEST.md`.
+
+If the directory does not exist:
+```
+Feature '{slug}' not found. Run /rpi:new {slug} to start.
+```
+Stop.
+
+If the directory exists but `REQUEST.md` is missing:
+```
+Feature '{slug}' has no REQUEST.md. This shouldn't happen. Run /rpi:new {slug} to recreate it.
+```
+Stop.
+
+## Step 3: Detect current phase
+
+Check which artifacts exist to determine the next phase:
+
+1. Has `REQUEST.md`, no `research/RESEARCH.md` AND no `plan/PLAN.md` → next = **research**
+2. Has `research/RESEARCH.md`, no `plan/PLAN.md` → next = **plan**
+3. Has `plan/PLAN.md`, no `implement/IMPLEMENT.md` → next = **implement**
+4. Has `implement/IMPLEMENT.md` but NOT all tasks checked (`- [x]`) → next = **implement** (with `--resume`)
+5. Has `implement/IMPLEMENT.md` with all tasks complete, no "## Simplify" section in IMPLEMENT.md → next = **simplify**
+6. Has simplify done, no "## Review Verdict" section in IMPLEMENT.md → next = **review**
+7. Has "## Review Verdict" with PASS, no `docs/` output generated → next = **docs**
+8. Everything done → feature is complete
+
+### Detection details
+
+For step 4: Read `implement/IMPLEMENT.md` and check if any `- [ ]` (unchecked tasks) remain. If all tasks are `- [x]`, the implementation is complete.
+
+For step 5: Check if IMPLEMENT.md contains a `## Simplify` section. If not, simplify has not been run yet.
+
+For step 6: Check if IMPLEMENT.md contains a `## Review Verdict` section. If not, review has not been run yet.
+
+For step 7: Check if IMPLEMENT.md contains a `## Review Verdict` section with "PASS". Then check if docs have been generated (look for mention of docs completion in IMPLEMENT.md or a generated docs artifact).
+
+## Step 4: Apply --skip flag
+
+If `--skip=phase` was provided:
+- If the detected next phase matches the skipped phase, advance to the phase after it using the same detection logic.
+- Valid phase names: `research`, `plan`, `implement`, `simplify`, `review`, `docs`.
+- If the skip target is invalid, inform the user and stop.
+
+## Step 5: Apply --from flag
+
+If `--from=phase` was provided:
+- Override the detected phase. Set next = the specified phase.
+- Valid phase names: `research`, `plan`, `implement`, `simplify`, `review`, `docs`.
+- If the from target is invalid, inform the user and stop.
+- This is useful for re-running a phase (e.g., after fixing issues).
+
+## Step 6: Handle completion
+
+If no next phase was detected (everything is done):
+```
+{slug} is complete! All phases done.
+
+To archive: /rpi:archive {slug}
+To re-run a phase: /rpi {slug} --from=phase
+```
+Stop.
+
+## Step 7: Announce and delegate
+
+Output what is about to happen:
+
+```
+{slug} -> next: {phase}
+Starting {phase} phase...
+```
+
+Then delegate to the appropriate command:
+
+1. Read `commands/rpi/{phase}.md`
+2. Follow its process section exactly, passing through the `{slug}` and any relevant flags (like `--force`, `--resume`)
+
+The auto-flow command does NOT duplicate phase logic. It detects the state, announces the next step, and then executes the full process defined in the corresponding command file.
+
+### Phase-to-command mapping
+
+| Phase      | Command file          | Key artifacts                    |
+|------------|-----------------------|----------------------------------|
+| REQUEST    | `commands/rpi/new.md` | `REQUEST.md`                     |
+| RESEARCH   | `commands/rpi/research.md` | `research/RESEARCH.md`      |
+| PLAN       | `commands/rpi/plan.md`     | `plan/PLAN.md`              |
+| IMPLEMENT  | `commands/rpi/implement.md`| `implement/IMPLEMENT.md`    |
+| simplify   | `commands/rpi/simplify.md` | Simplify section in IMPLEMENT.md |
+| review     | `commands/rpi/review.md`   | Review Verdict in IMPLEMENT.md   |
+| docs       | `commands/rpi/docs.md`     | Generated documentation          |
+"""

package/.gemini/commands/rpi/simplify.toml

@@ -0,0 +1,214 @@
+description = "Razor analyzes the implementation for reuse, quality, and efficiency improvements."
+
+prompt = """
+# /rpi:simplify — Simplify Phase
+
+Razor analyzes the full implementation diff across 3 dimensions — reuse, quality, and efficiency — and applies improvements directly. Tests must pass before and after.
+
+---
+
+## Step 1: Load config and validate
+
+1. Read `.rpi.yaml` for config. Apply defaults if missing:
+   - `folder`: `rpi/features`
+   - `context_file`: `rpi/context.md`
+   - `commit_style`: `conventional`
+2. Parse `$ARGUMENTS` to extract `{slug}`.
+3. Validate `rpi/features/{slug}/implement/IMPLEMENT.md` exists. If not:
+   ```
+   IMPLEMENT.md not found for '{slug}'. Run /rpi:implement {slug} first.
+   ```
+   Stop.
+4. Read `rpi/features/{slug}/implement/IMPLEMENT.md`. Verify all tasks are marked `[x]` (done). If any task is `[ ]` (pending) or `BLOCKED`:
+   ```
+   Implementation is not complete for '{slug}'. {N} tasks remaining.
+   Complete all tasks before simplifying: /rpi:implement {slug}
+   ```
+   Stop.
+
+## Step 2: Get implementation diff
+
+1. Read `rpi/features/{slug}/implement/IMPLEMENT.md` — extract all commit hashes from the Execution Log.
+2. Use git to get the combined diff of all implementation commits:
+   ```bash
+   git diff {first_commit}^..{last_commit}
+   ```
+3. Store the diff as `$IMPL_DIFF`.
+4. Collect the list of all files changed — store as `$CHANGED_FILES`.
+
+## Step 3: Gather context
+
+1. Read `rpi/features/{slug}/plan/eng.md` if it exists — store as `$ENG`.
+2. Read `rpi/context.md` (project context) if it exists — store as `$CONTEXT`.
+
+## Step 4: Run tests (baseline)
+
+1. Run the project's test suite to establish baseline:
+   ```bash
+   npm test    # or whatever the project uses
+   ```
+2. If tests fail before simplification:
+   ```
+   Tests are already failing before simplification. Fix failing tests first.
+   ```
+   Stop.
+3. Store the test output as `$BASELINE_TESTS`.
+
+## Step 5: Launch Razor with 3 parallel sub-checks
+
+Launch Razor agent with this prompt:
+
+```
+You are Razor. Simplify the implementation for feature: {slug}
+
+## Implementation Diff
+{$IMPL_DIFF}
+
+## Changed Files
+{$CHANGED_FILES}
+
+## Engineering Spec
+{$ENG}
+
+## Project Context
+{$CONTEXT}
+
+Your task — analyze the implementation across 3 dimensions IN PARALLEL:
+
+### 1. Reuse
+- Scan for duplicated code within the changed files
+- Scan for duplication against existing codebase utilities
+- Identify extraction opportunities (shared functions, constants, types)
+- Check for reimplemented functionality that already exists in the project
+
+### 2. Quality
+- Naming: unclear variable/function names, inconsistent conventions
+- Complexity: functions doing too much, deep nesting, long parameter lists
+- Code smells: magic numbers, dead code, commented-out code, unnecessary abstractions
+- Consistency: does the new code match the patterns in context.md?
+
+### 3. Efficiency
+- Algorithm choices: O(n^2) where O(n) is possible, unnecessary iterations
+- Database/API queries: N+1 problems, missing batching, redundant calls
+- Imports: unused imports, heavy imports where lighter alternatives exist
+- Memory: unnecessary copies, large objects held in scope too long
+
+RULES:
+1. Read ALL changed files before making any modifications
+2. Apply fixes directly to the code — do not just list suggestions
+3. Each fix must preserve existing behavior (no functional changes)
+4. Match the project's existing style and patterns
+5. Do NOT over-abstract — only extract if there are 3+ duplications
+6. After all fixes, list what you changed and why
+
+Output format:
+## Changes Applied
+- {file}: {what changed} — {why}
+
+## Metrics
+- Reuse: {N} fixes
+- Quality: {N} fixes
+- Efficiency: {N} fixes
+- Lines removed: {N}
+- Lines added: {N}
+
+After simplification, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Razor (Simplify)
+- **Action:** Simplified implementation for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Reuse fixes:** {count}
+- **Quality fixes:** {count}
+- **Efficiency fixes:** {count}
+- **Lines removed:** {count}
+- **Quality:** {your quality gate result}
+```
+
+Store Razor's output as `$RAZOR_OUTPUT`.
+
+## Step 6: Run tests (verification)
+
+1. Run the project's test suite again:
+   ```bash
+   npm test
+   ```
+2. If tests fail after Razor's changes:
+   - Show the failing tests to the user.
+   - Revert Razor's changes: `git checkout -- .`
+   - Inform the user:
+     ```
+     Razor's changes broke {N} tests. Changes have been reverted.
+     Review the failures and re-run: /rpi:simplify {slug}
+     ```
+   - Stop.
+3. If all tests pass: continue.
+
+## Step 7: Commit simplification changes
+
+1. Stage all modified files:
+   ```bash
+   git add {list of files Razor modified}
+   ```
+2. Commit with a descriptive message following `commit_style` from config:
+   ```bash
+   git commit -m "refactor({slug}): simplify implementation — Razor"
+   ```
+3. Store the commit hash as `$SIMPLIFY_COMMIT`.
+
+## Step 8: Update IMPLEMENT.md
+
+Append a simplification results section to `rpi/features/{slug}/implement/IMPLEMENT.md`:
+
+```markdown
+## Simplify
+
+Agent: Razor
+Date: {YYYY-MM-DD}
+Commit: {$SIMPLIFY_COMMIT}
+
+### Changes
+{list of changes from $RAZOR_OUTPUT}
+
+### Metrics
+- Reuse fixes: {N}
+- Quality fixes: {N}
+- Efficiency fixes: {N}
+- Net lines: {+/-N}
+```
+
+## Step 9: Consolidate decisions to DECISIONS.md
+
+1. Read `rpi/features/{slug}/ACTIVITY.md`.
+2. Extract all `<decision>` tags from entries belonging to the Simplify phase (Razor entries from this run).
+3. If no decisions found, skip this step.
+4. Read `rpi/features/{slug}/DECISIONS.md` if it exists (to get the last decision number for sequential numbering).
+5. Append a new section to `rpi/features/{slug}/DECISIONS.md`:
+
+```markdown
+## Simplify Phase
+_Generated: {current_date}_
+
+| # | Type | Decision | Alternatives | Rationale | Impact |
+|---|------|----------|-------------|-----------|--------|
+| {N} | {type} | {summary} | {alternatives} | {rationale} | {impact} |
+```
+
+6. Number decisions sequentially, continuing from the last number in DECISIONS.md.
+
+## Step 10: Output summary
+
+```
+Simplify complete: {slug}
+
+Razor applied {total} fixes:
+  - Reuse: {N}
+  - Quality: {N}
+  - Efficiency: {N}
+
+Tests: all passing
+Commit: {$SIMPLIFY_COMMIT}
+
+Next: /rpi {slug}
+Or explicitly: /rpi:review {slug}
+```
+"""

package/.gemini/commands/rpi/status.toml

@@ -0,0 +1,194 @@
+description = "Show all features, their current phase, and progress."
+
+prompt = """
+# /rpi:status — Feature Status Dashboard
+
+Show all active features with their current phase, verdict, and progress. Optionally show detailed view for a specific feature.
+
+---
+
+## Step 1: Load config
+
+Read `.rpi.yaml` for config. Apply defaults if missing:
+- `folder`: `rpi/features`
+
+Parse `$ARGUMENTS` to extract optional `{slug}` for detailed view.
+
+## Step 2: Find all features
+
+Glob `{folder}/*/REQUEST.md` to find all active features.
+
+If no features found:
+```
+No features found. Run /rpi:new to start.
+```
+Stop.
+
+## Step 3: Detect phase for each feature
+
+For each feature directory found, determine the current phase by checking which artifacts exist:
+
+1. Has `REQUEST.md`, no `research/RESEARCH.md` → phase = **request** (next: research)
+2. Has `research/RESEARCH.md`, no `plan/PLAN.md` → phase = **research** (next: plan)
+3. Has `plan/PLAN.md`, no `implement/IMPLEMENT.md` → phase = **plan** (next: implement)
+4. Has `implement/IMPLEMENT.md` with unchecked tasks (`- [ ]`) → phase = **implement** (in progress)
+5. Has `implement/IMPLEMENT.md` with all tasks checked, no "## Simplify" section → phase = **implement** (next: simplify)
+6. Has "## Simplify" section, no "## Review Verdict" section → phase = **simplify** (next: review)
+7. Has "## Review Verdict" with PASS → phase = **review** (next: docs)
+8. Everything done → phase = **complete**
+
+## Step 4: Gather metadata per feature
+
+For each feature:
+
+### Verdict
+- Read `research/RESEARCH.md` if it exists. Look for `## Verdict` section. Extract: GO | GO with concerns | NO-GO.
+- If no RESEARCH.md: verdict = "pending"
+
+### Complexity
+- Read `REQUEST.md`. Look for `## Complexity Estimate` section. Extract: S | M | L | XL.
+- If not found: complexity = "unknown"
+
+### Task progress (if plan/implement exists)
+- Read `plan/PLAN.md` if it exists. Count total tasks (lines matching `- [ ]` or `- [x]` pattern).
+- Read `implement/IMPLEMENT.md` if it exists. Count completed tasks (`- [x]`) vs total.
+- Express as: `{completed}/{total} tasks`
+
+### Activity Log
+- Read `{feature_dir}/ACTIVITY.md` if it exists.
+- Extract the last 3 activity entries.
+- Extract quality scores from all entries — build a quality summary per phase:
+  - Research: {PASS|WEAK|FAIL|pending} (Atlas, Scout, Nexus scores)
+  - Plan: {PASS|WEAK|FAIL|pending} (Nexus interview, Mestre, Clara, adversarial scores)
+  - Implement: {PASS|WEAK|FAIL|pending} (Forge per-task scores)
+  - Simplify: {PASS|WEAK|FAIL|pending} (Razor score)
+  - Review: {PASS|WEAK|FAIL|pending} (Hawk, Shield, Sage, Nexus scores)
+  - Docs: {PASS|WEAK|FAIL|pending} (Quill score)
+- Identify any WEAK or FAIL scores for alerts.
+- Extract last activity timestamp for "last activity" display.
+
+### Decisions
+- Read `{feature_dir}/DECISIONS.md` if it exists.
+- Count total decisions, count by impact (HIGH, MEDIUM, LOW).
+- Extract the last 5 decisions (most recent = bottom of the file).
+
+## Step 5: Display status
+
+### If no specific feature requested (overview mode)
+
+Output a status card per feature, sorted by phase (most advanced first):
+
+```
+# RPI Status
+
+## {feature-slug}
+Phase: {phase} {task_progress if applicable}
+Verdict: {verdict}
+Complexity: {complexity}
+Last activity: {relative time, e.g. "2h ago" or "3 days ago"}
+Quality: {phase_quality_summary, e.g. "Research PASS | Plan PASS | Implement 3/7"}
+Decisions: {total} ({HIGH_count} HIGH, {MEDIUM_count} MEDIUM, {LOW_count} LOW)
+
+## {feature-slug-2}
+Phase: {phase}
+Verdict: {verdict}
+Complexity: {complexity}
+Last activity: {relative time, e.g. "2h ago" or "3 days ago"}
+Quality: {phase_quality_summary, e.g. "Research PASS | Plan PASS | Implement 3/7"}
+Decisions: {total} ({HIGH_count} HIGH, {MEDIUM_count} MEDIUM, {LOW_count} LOW)
+
+---
+{total_count} feature(s) active
+```
+
+### Quality Alerts
+
+After the feature cards, if any feature has WEAK or FAIL quality scores:
+
+```
+## Alerts
+
+- {feature}: {phase} quality WEAK — {agent} ({reason from activity log})
+  Suggestion: {actionable suggestion, e.g. "Re-run /rpi:research" or "Add context to REQUEST.md"}
+
+- {feature}: {phase} quality FAIL — {agent} ({reason})
+  Suggestion: {actionable suggestion}
+```
+
+If no alerts: omit this section entirely.
+
+Phase display format:
+- `request` → "request (awaiting research)"
+- `research` → "research (awaiting plan)"
+- `plan` → "plan (awaiting implement)"
+- `implement` → "implement ({completed}/{total} tasks)"
+- `simplify` → "simplify (awaiting review)"
+- `review` → "review (awaiting docs)"
+- `complete` → "complete"
+
+### If specific feature requested (detailed mode)
+
+If `{slug}` was provided in arguments, show detailed view for that feature:
+
+```
+# RPI Status: {slug}
+
+Phase: {phase} {task_progress}
+Verdict: {verdict}
+Complexity: {complexity}
+
+## Artifacts
+- REQUEST.md: {exists/missing}
+- research/RESEARCH.md: {exists/missing}
+- plan/PLAN.md: {exists/missing}
+- plan/eng.md: {exists/missing}
+- plan/pm.md: {exists/missing}
+- plan/ux.md: {exists/missing}
+- implement/IMPLEMENT.md: {exists/missing}
+- DECISIONS.md: {exists/missing}
+- delta/: {count of files in ADDED + MODIFIED + REMOVED}
+
+## Tasks
+{If PLAN.md exists, list all tasks with their status: [x] or [ ]}
+
+## Review
+{If Review Verdict exists in IMPLEMENT.md, show verdict and finding counts}
+
+## Next
+{Suggest the next command to run, e.g. "/rpi {slug}" or "/rpi:archive {slug}" if complete}
+
+## Activity Log (last 5 entries)
+{If ACTIVITY.md exists, show last 5 entries in reverse chronological order}
+{If no ACTIVITY.md: "No activity log yet."}
+
+## Key Decisions (last 5)
+{If DECISIONS.md exists:}
+| # | Phase | Decision | Impact |
+|---|-------|----------|--------|
+| {N} | {phase} | {summary} | {impact} |
+
+Total: {N} decisions ({HIGH_count} HIGH, {MEDIUM_count} MEDIUM, {LOW_count} LOW)
+Full log: rpi/features/{slug}/DECISIONS.md
+
+{If no DECISIONS.md: "No decisions logged yet."}
+
+## Quality Summary
+{For each completed phase, show quality scores:}
+- Research: Atlas {score} | Scout {score} | Nexus {score}
+- Plan: Interview {score} | Mestre {score} | Clara {score} | Adversarial {score}
+- Implement: {N}/{total} tasks, Forge avg quality {score}
+- Simplify: Razor {score}
+- Review: Hawk {score} | Shield {score} | Sage {score}
+- Docs: Quill {score}
+
+## Session Resume
+Last activity: {timestamp and description of last logged action}
+Next step: {suggest the next command based on current phase}
+```
+
+If the requested feature does not exist:
+```
+Feature '{slug}' not found. Available features:
+- {list of existing feature slugs}
+```
+"""

package/.gemini/commands/rpi/update.toml

@@ -0,0 +1,107 @@
+description = "Update RPIKit plugin to the latest version from the remote repository."
+
+prompt = """
+# /rpi:update — Update RPIKit
+
+Pull the latest version of RPIKit from the remote repository and clear the plugin cache.
+
+---
+
+## Step 1: Find the installed plugin directory
+
+Search for the RPIKit installation:
+
+```bash
+find ~/.claude/plugins -name "plugin.json" -path "*/rpi-kit/*" 2>/dev/null
+```
+
+From the results, determine the plugin root directory (the parent of `.claude-plugin/`).
+
+If not found:
+```
+RPIKit installation not found in ~/.claude/plugins/.
+Re-install from the marketplace or run:
+  claude plugin add git@github.com:dmend3z/rpi-kit.git
+```
+Stop.
+
+Store the plugin root path as `$PLUGIN_DIR`.
+
+## Step 2: Show current version
+
+Read `$PLUGIN_DIR/.claude-plugin/plugin.json` and extract the current `version` field.
+Store as `$CURRENT_VERSION`.
+
+Also get the current git commit:
+
+```bash
+cd $PLUGIN_DIR && git rev-parse --short HEAD
+```
+
+Store as `$CURRENT_COMMIT`.
+
+## Step 3: Pull latest changes
+
+Run git pull in the plugin directory:
+
+```bash
+cd $PLUGIN_DIR && git pull origin main 2>&1
+```
+
+If it fails:
+- If "not a git repository": report the error and suggest re-installing.
+- If merge conflict: report the error and suggest `cd $PLUGIN_DIR && git reset --hard origin/main` (ask user first — this discards local changes).
+- If network error: report "Could not reach remote. Check your connection."
+- Stop on any error.
+
+If output says "Already up to date.":
+```
+RPIKit is already up to date (v{$CURRENT_VERSION}, {$CURRENT_COMMIT}).
+```
+Stop.
+
+## Step 4: Show what changed
+
+Get the new version:
+
+```bash
+cd $PLUGIN_DIR && cat .claude-plugin/plugin.json | grep '"version"'
+```
+
+Store as `$NEW_VERSION`.
+
+Get the new commit:
+
+```bash
+cd $PLUGIN_DIR && git rev-parse --short HEAD
+```
+
+Store as `$NEW_COMMIT`.
+
+Show the changelog between old and new commits:
+
+```bash
+cd $PLUGIN_DIR && git log --oneline $CURRENT_COMMIT..$NEW_COMMIT
+```
+
+## Step 5: Clear plugin cache
+
+Remove cached versions so Claude Code picks up the new files:
+
+```bash
+rm -rf ~/.claude/plugins/cache/rpi-kit 2>/dev/null
+```
+
+## Step 6: Output summary
+
+```
+RPIKit updated!
+
+{$CURRENT_VERSION} ({$CURRENT_COMMIT}) → {$NEW_VERSION} ({$NEW_COMMIT})
+
+Changes:
+{git log output from step 4}
+
+Restart Claude Code to load the new version.
+```
+"""