rpi-kit 1.4.0 → 2.0.0

package/commands/rpi/simplify.md

@@ -1,7 +1,7 @@
 ---
 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>"
+description: Razor analyzes the implementation for reuse, quality, and efficiency improvements.
+argument-hint: "<feature-name>"
 allowed-tools:
   - Read
   - Write
@@ -12,120 +12,183 @@ allowed-tools:
   - Agent
 ---
 
-<objective>
-Run 3 parallel code review sub-agents (reuse, quality, efficiency) on the implementation changes, aggregate findings, and fix issues directly.
-</objective>
+# /rpi:simplify — Simplify Phase
 
-<process>
+Razor analyzes the full implementation diff across 3 dimensions — reuse, quality, and efficiency — and applies improvements directly. Tests must pass before and after.
 
-## 1. Load config, resolve path, and identify changes
-
-Read `.rpi.yaml` for folder path. Also read `profile` and `models` keys.
-
-Parse `{feature-slug}` from arguments.
-
-**Resolution order:**
-1. Check if `{folder}/{feature-slug}/` exists → type = "feature", path = `{folder}/{feature-slug}`
-2. If not, Glob `{folder}/*/changes/{feature-slug}/` → if found, type = "change", path = matched path, parent_path = parent directory
-3. If multiple matches → AskUserQuestion listing all matches with full paths
-4. If no match → error: `Feature not found: {feature-slug}`
+---
 
-Read `{path}/implement/IMPLEMENT.md` to identify what was implemented.
+## 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:
 
-Get the diff of all implementation changes:
-```bash
-git diff HEAD~{number_of_commits}
 ```
+You are Razor. Simplify the implementation for feature: {slug}
 
-If no git history, use the files listed in IMPLEMENT.md tasks and read them directly.
-
-## 1b. Resolve model
-
-Resolve the model for the `implement` phase following the Model Resolution Algorithm in the rpi-workflow skill. Store as `{resolved_model}`. If a model is resolved, output the status message before agent spawns.
+## Implementation Diff
+{$IMPL_DIFF}
 
-## 2. Launch 3 parallel sub-agents
+## Changed Files
+{$CHANGED_FILES}
 
-Use the Agent tool to launch all 3 concurrently in a single message. If a model was resolved in Step 1b, include `model: "{resolved_model}"` in each Agent tool call.
+## Engineering Spec
+{$ENG}
 
-### Agent 1: Reuse Checker
+## Project Context
+{$CONTEXT}
 
-```
-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}`
-```
+Your task — analyze the implementation across 3 dimensions IN PARALLEL:
 
-### Agent 2: Quality Checker
+### 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
 
-```
-You are checking code quality in recent changes.
+### 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?
 
-Here is the diff of recent changes:
-{diff}
+### 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
 
-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
+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:
-## Quality Findings
-- {file}:{line} — {pattern}: {description}
+## Changes Applied
+- {file}: {what changed} — {why}
+
+## Metrics
+- Reuse: {N} fixes
+- Quality: {N} fixes
+- Efficiency: {N} fixes
+- Lines removed: {N}
+- Lines added: {N}
 ```
 
-### Agent 3: Efficiency Checker
-
+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}
 ```
-You are checking code efficiency in recent changes.
 
-Here is the diff of recent changes:
-{diff}
+## Step 9: Output summary
 
-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}
 ```
+Simplify complete: {slug}
 
-## 3. Aggregate and fix
-
-After all 3 agents complete:
+Razor applied {total} fixes:
+  - Reuse: {N}
+  - Quality: {N}
+  - Efficiency: {N}
 
-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
+Tests: all passing
+Commit: {$SIMPLIFY_COMMIT}
 
-## 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."}
+Next: /rpi {slug}
+Or explicitly: /rpi:review {slug}
 ```
-
-After finishing, update IMPLEMENT.md `## Simplify Findings` section with the results.
-
-</process>

package/commands/rpi/status.md

@@ -1,154 +1,131 @@
 ---
 name: rpi:status
-description: Show all RPI features and their current phase, progress, and status.
-argument-hint: "[feature-slug]"
+description: Show all features, their current phase, and progress.
+argument-hint: "[feature-name]"
 allowed-tools:
   - Read
   - Glob
   - Bash
 ---
 
-<objective>
-Display detailed status cards for all features (or a specific feature) in the RPI workflow.
-</objective>
+# /rpi:status — Feature Status Dashboard
 
-<process>
+Show all active features with their current phase, verdict, and progress. Optionally show detailed view for a specific feature.
 
-## 1. Load config
-
-Read `.rpi.yaml` for folder path. Default to `rpi/` if not found. Also read `profile` and `models` keys.
-
-## 2. Discover features and changes
+---
 
-Use Glob to find all top-level `REQUEST.md` files:
-```
-{folder}/*/REQUEST.md
-```
+## Step 1: Load config
 
-Each parent directory is a feature slug.
+Read `.rpi.yaml` for config. Apply defaults if missing:
+- `folder`: `rpi/features`
 
-Also find all change `REQUEST.md` files:
-```
-{folder}/*/changes/*/REQUEST.md
-```
+Parse `$ARGUMENTS` to extract optional `{slug}` for detailed view.
 
-Parse each match to extract parent_slug and change_slug.
+## Step 2: Find all features
 
-If `$ARGUMENTS` specifies a slug:
-1. Check if it matches a top-level feature → show that feature and its changes
-2. If not, check if it matches a change slug → show just that change (with parent context)
-3. Resolution follows the shared Resolve Feature Path logic:
-   - Check `{folder}/{slug}/` exists → type = "feature"
-   - Glob `{folder}/*/changes/{slug}/` → type = "change"
-   - Multiple matches → AskUserQuestion
+Glob `{folder}/*/REQUEST.md` to find all active features.
 
 If no features found:
 ```
-No RPI features found in {folder}/.
-Run /rpi:new to start your first feature.
+No features found. Run /rpi:new to start.
 ```
+Stop.
 
-## 3. Determine phase for each feature
-
-For each feature slug, check which files exist:
+## Step 3: Detect phase for each feature
 
-- `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**
+For each feature directory found, determine the current phase by checking which artifacts exist:
 
-For each change, determine phase using the same logic as features,
-but looking in `{folder}/{parent_slug}/changes/{change_slug}/` instead.
+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**
 
-## 4. Gather details per feature
+## Step 4: Gather metadata per feature
 
-For each feature, read the relevant files to extract:
+For each feature:
 
-**If researched or later:**
-- Read RESEARCH.md executive summary for verdict and complexity
+### 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"
 
-**If planned or later:**
-- Read PLAN.md to count total tasks and phases
+### Complexity
+- Read `REQUEST.md`. Look for `## Complexity Estimate` section. Extract: S | M | L | XL.
+- If not found: complexity = "unknown"
 
-**If implementing:**
-- Check for checkpoint files in `{folder}/{slug}/implement/checkpoints/`
-- If checkpoints exist:
-  - Read each checkpoint file, parse status and task_id
-  - Count done / blocked / deviated / rolled_back
-  - Identify current task (first unchecked in PLAN.md order that has no checkpoint)
-  - Read latest session file in `sessions/` for session count and tier
-- If no checkpoints (old-style):
-  - Fall back to reading IMPLEMENT.md for `[x]` vs `[ ]` counts
-- Check for review verdict in IMPLEMENT.md
+### 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`
 
-**If complete:**
-- Read IMPLEMENT.md for final review verdict and completion timestamp
+## Step 5: Display status
 
-## 5. Display detailed cards
+### If no specific feature requested (overview mode)
 
-First, display the active profile at the top of the output. Resolve the effective model for each phase using the Model Resolution Algorithm in the rpi-workflow skill:
-- With profile: `Profile: {profile} (research: {model}, plan: {model}, implement: {model}, review: {model})`
-- With overrides, mark overridden phases with `*`: `Profile: balanced (research: opus, plan: opus, implement: opus*, review: opus)`
-- No profile: `Profile: none (inheriting parent model)`
+Output a status card per feature, sorted by phase (most advanced first):
 
-Then 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)}
-{Tier: 1|2|3 (context weight: {weight}) (if implementing)}
-{Sessions: {count} (if implementing with checkpoints)}
-{Current: Task {id} — {name} (if implementing)}
-{Blocked: Task {id} — {reason} (if any blocked)}
-{Review: PASS|FAIL (if reviewed)}
 ```
+# RPI Status
 
-### Example output:
+## {feature-slug}
+Phase: {phase} {task_progress if applicable}
+Verdict: {verdict}
+Complexity: {complexity}
 
-```markdown
-# RPI Status
+## {feature-slug-2}
+Phase: {phase}
+Verdict: {verdict}
+Complexity: {complexity}
 
-Profile: balanced (research: opus, plan: opus, implement: sonnet, review: opus)
-
-## oauth2-auth
-Phase: implement (6/9 tasks)
-Verdict: GO
-Complexity: M
-Tier: 2 (context weight: 14.5)
-Sessions: 2
-Current: Task 2.1 — Login component
-  └─ add-social-login  [research: GO]
-  └─ fix-token-refresh  [new]
-
-## payment-system
-Phase: research
-Verdict: pending
-Complexity: —
-
-## dark-mode
-Phase: plan (ready to implement)
-Verdict: GO
-Complexity: S
-
-## csv-export
-Phase: new
-Verdict: —
+---
+{total_count} feature(s) active
 ```
 
-Changes are displayed indented under their parent feature with `└─` prefix.
-Each change shows its own phase status using the same rules as features.
+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"
 
-## 6. Suggest next action
+### If specific feature requested (detailed mode)
 
-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}`
+If `{slug}` was provided in arguments, show detailed view for that feature:
 
-</process>
+```
+# 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}
+- 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}
+```
+
+If the requested feature does not exist:
+```
+Feature '{slug}' not found. Available features:
+- {list of existing feature slugs}
+```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rpi-kit",
-  "version": "1.4.0",
-  "description": "Research → Plan → Implement. A systematic feature development workflow for Claude Code.",
+  "version": "2.0.0",
+  "description": "Research → Plan → Implement. AI-assisted feature development with 13 named agents, delta specs, and knowledge compounding.",
   "license": "MIT",
   "author": "Daniel Mendes",
   "repository": {
@@ -28,12 +28,16 @@
     "agents/",
     "skills/",
     "AGENTS.md",
-    "codex.md",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "test": "node --test test/cli.test.js test/commands.test.js",
     "postinstall": "node bin/cli.js install --silent"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "picocolors": "^1.1.1"
   }
 }