rpi-kit 1.4.0 → 2.0.0

package/bin/cli.js

@@ -25,6 +25,11 @@ function hasCodex() {
   return result.status === 0;
 }
 
+function hasGeminiCLI() {
+  const result = spawnSync("gemini", ["--version"], { stdio: "pipe" });
+  return result.status === 0;
+}
+
 function installClaude() {
   log("Installing RPIKit for Claude Code...");
   try {
@@ -46,7 +51,7 @@ function installCodex() {
 
   if (fs.existsSync(dest)) {
     const existing = fs.readFileSync(dest, "utf8");
-    if (existing.includes("RPI Agent Definitions")) {
+    if (existing.includes("RPIKit Agents")) {
       log("Codex: AGENTS.md already contains RPI definitions.");
       return true;
     }
@@ -62,6 +67,12 @@ function installCodex() {
   return true;
 }
 
+function installGeminiCLI() {
+  log("Installing RPIKit for Gemini CLI...");
+  log("Gemini CLI: coming soon. Please see documentation for manual setup.");
+  return true;
+}
+
 function uninstallClaude() {
   log("Removing RPIKit from Claude Code...");
   try {
@@ -78,82 +89,178 @@ function uninstallClaude() {
 
 function printHelp() {
   console.log(`
-RPIKit — Research → Plan → Implement
+RPIKit v2 — Research → Plan → Implement
+
+  7-phase workflow with 13 named agents, delta specs,
+  and knowledge compounding for AI-assisted feature development.
 
 Usage:
-  rpi-kit install            Install for detected tools (Claude Code + Codex)
+  rpi-kit install            Interactive setup for AI tools
   rpi-kit install --claude   Install for Claude Code only
   rpi-kit install --codex    Install for Codex only (copies AGENTS.md to cwd)
+  rpi-kit install --gemini   Install for Gemini CLI only
   rpi-kit uninstall          Remove from Claude Code
   rpi-kit onboarding         Interactive walkthrough of the workflow
   rpi-kit help               Show this help
 
-After install, use in Claude Code:
-  /rpi:init                  Configure for your project
-  /rpi:new <feature>         Start a new feature
-  /rpi:research <feature>    Research feasibility
-  /rpi:plan <feature>        Generate implementation plan
-  /rpi:implement <feature>   Build it
-  /rpi:docs <feature>        Document the code
-  /rpi:status                Show all features
+Commands (14):
+  /rpi:new <feature>         Describe your feature → REQUEST.md
+  /rpi:research <feature>    Parallel agent analysis → RESEARCH.md
+  /rpi:plan <feature>        Generate specs + tasks → PLAN.md
+  /rpi:implement <feature>   Execute tasks with tracking → IMPLEMENT.md
+  /rpi:simplify <feature>    Code quality checks → auto-fix issues
+  /rpi:review <feature>      Review against plan → PASS / FAIL
+  /rpi:docs <feature>        Document the code → DOCS.md + changelog
+
+  /rpi:init                  Configure RPIKit for your project
+  /rpi:status                Show all features and their phases
+  /rpi <feature>             Auto-progress to next phase
+  /rpi:onboarding            Guided first-time setup
+  /rpi:learn [description]   Capture a solution to knowledge base
+  /rpi:archive <feature>     Archive a completed feature
+  /rpi:party                 Multi-agent debate on any topic
+
+Agents (13):
+  Luna (Analyst) · Atlas (Explorer) · Scout (Researcher) · Nexus (Synthesizer)
+  Mestre (Architect) · Clara (PM) · Pixel (UX) · Forge (Builder)
+  Sage (Tester) · Razor (Simplifier) · Hawk (Reviewer) · Shield (Security)
+  Quill (Doc Writer)
 `);
 }
 
-switch (command) {
-  case "install": {
-    const claudeOnly = flags.includes("--claude");
-    const codexOnly = flags.includes("--codex");
+async function run() {
+  switch (command) {
+    case "install": {
+      const claudeOnly = flags.includes("--claude");
+      const codexOnly = flags.includes("--codex");
+      const geminiOnly = flags.includes("--gemini");
 
-    if (claudeOnly) {
-      installClaude();
-    } else if (codexOnly) {
-      installCodex();
-    } else {
-      let installed = false;
+      if (claudeOnly) {
+        installClaude();
+        break;
+      }
+      if (codexOnly) {
+        installCodex();
+        break;
+      }
+      if (geminiOnly) {
+        installGeminiCLI();
+        break;
+      }
+
+      // If silent, use the original auto-install behavior
+      if (silent) {
+        let installed = false;
+        if (hasClaude()) installed = installClaude() || installed;
+        if (hasCodex()) installed = installCodex() || installed;
+        if (hasGeminiCLI()) installed = installGeminiCLI() || installed;
+        if (!installed) {
+          const result = installClaude();
+          if (!result) {
+            log("\nNo supported tool detected (claude, codex, gemini).");
+            log("Run manually after installing Claude Code, Codex, or Gemini CLI:");
+            log("  rpi-kit install --claude");
+            log("  rpi-kit install --codex");
+            log("  rpi-kit install --gemini");
+          }
+        }
+        break;
+      }
+
+      // Interactive prompt
+      let p;
+      let color;
+      try {
+        p = await import("@clack/prompts");
+        color = (await import("picocolors")).default;
+      } catch (e) {
+        console.error("Failed to load interactive prompt dependencies. Falling back to default install.");
+        let installed = false;
+        if (hasClaude()) installed = installClaude() || installed;
+        if (hasCodex()) installed = installCodex() || installed;
+        if (!installed) installClaude();
+        break;
+      }
+
+      console.clear();
+      p.intro(color.bgCyan(color.black(" RPIKit Setup ")));
 
-      if (hasClaude()) {
-        installed = installClaude() || installed;
+      p.log.message(color.dim("RPIKit configured: Claude Code, Codex, Gemini CLI"));
+
+      const options = [
+        { value: "claude", label: "Claude Code", hint: hasClaude() ? "detected" : "" },
+        { value: "codex", label: "Codex", hint: hasCodex() ? "detected" : "" },
+        { value: "gemini", label: "Gemini CLI", hint: hasGeminiCLI() ? "detected" : "" }
+      ];
+
+      const initialValues = options.filter(o => o.hint === "detected").map(o => o.value);
+      if (initialValues.length === 0) {
+        initialValues.push("claude"); // default selection if none detected
       }
 
-      if (hasCodex()) {
-        installed = installCodex() || installed;
+      const selectedTools = await p.multiselect({
+        message: `Select tools to set up (${options.length} available)`,
+        options: options,
+        initialValues,
+        required: false
+      });
+
+      if (p.isCancel(selectedTools)) {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
       }
 
-      if (!installed && !silent) {
-        const result = installClaude();
-        if (!result) {
-          log("\nNo supported tool detected (claude, codex).");
-          log("Run manually after installing Claude Code or Codex:");
-          log("  rpi-kit install --claude");
-          log("  rpi-kit install --codex");
+      if (selectedTools.length === 0) {
+        p.outro("No tools selected.");
+        break;
+      }
+
+      console.log(); // Spacing
+      
+      let installed = false;
+      for (const tool of selectedTools) {
+        if (tool === "claude") {
+          installed = installClaude() || installed;
+        } else if (tool === "codex") {
+          installed = installCodex() || installed;
+        } else if (tool === "gemini") {
+          installed = installGeminiCLI() || installed;
         }
       }
 
-      if (installed && !silent) {
-        log("");
-        log("New to RPIKit? Run: rpi-kit onboarding");
+      if (installed) {
+        console.log();
+        p.outro(color.green("Setup complete! New to RPIKit? Run: rpi-kit onboarding"));
+      } else {
+        p.outro(color.yellow("Setup finished with some issues."));
       }
+      
+      break;
     }
-    break;
-  }
 
-  case "onboarding": {
-    const { run } = require("./onboarding");
-    run();
-    break;
-  }
+    case "onboarding": {
+      const { run } = require("./onboarding");
+      run();
+      break;
+    }
 
-  case "uninstall":
-    uninstallClaude();
-    break;
+    case "uninstall":
+      uninstallClaude();
+      break;
 
-  case "help":
-  case "--help":
-  case "-h":
-    printHelp();
-    break;
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
 
-  default:
-    if (!silent) printHelp();
-    break;
+    default:
+      if (!silent) printHelp();
+      break;
+  }
 }
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/bin/onboarding.js

@@ -9,27 +9,28 @@ const RESET = "\x1b[0m";
 
 const steps = [
   {
-    title: "Welcome to RPIKit",
+    title: "Welcome to RPIKit v2",
     body: `
 ${BOLD}Research → Plan → Implement${RESET}
 
-RPIKit is a structured feature development workflow for Claude Code and Codex.
-It guides you through 3 phases with validation gates, so you research before
-you plan, and plan before you code.
+RPIKit v2 is a structured feature development workflow for Claude Code and Codex.
+It guides you through ${CYAN}7 phases${RESET} with validation gates, delta specs, and
+knowledge compounding — so you research before you plan, and plan before you code.
 
-${DIM}12 specialized agents simulate a product team:
-engineers, PMs, designers, reviewers — all working in parallel.${RESET}`,
+${DIM}13 named agents simulate a product team:
+Luna (Analyst), Atlas (Explorer), Scout (Researcher), Forge (Builder),
+Hawk (Reviewer), Shield (Security), Quill (Doc Writer), and more.${RESET}`,
   },
   {
-    title: "The Pipeline",
+    title: "The 7-Phase Pipeline",
     body: `
-${DIM}Your feature flows through these phases:${RESET}
+${DIM}Your feature flows through 7 phases:${RESET}
 
   ${CYAN}/rpi:new${RESET}        Describe your feature → ${BOLD}REQUEST.md${RESET}
        │
   ${CYAN}/rpi:research${RESET}   Parallel agent analysis → ${BOLD}RESEARCH.md${RESET} + GO/NO-GO
        │
-  ${CYAN}/rpi:plan${RESET}       Generate specs + tasks → ${BOLD}PLAN.md${RESET} + eng/pm/ux.md
+  ${CYAN}/rpi:plan${RESET}       Generate delta specs + tasks → ${BOLD}PLAN.md${RESET} + eng/pm/ux.md
        │
   ${CYAN}/rpi:implement${RESET}  Execute tasks with tracking → ${BOLD}IMPLEMENT.md${RESET}
        │
@@ -37,25 +38,34 @@ ${DIM}Your feature flows through these phases:${RESET}
        │
   ${CYAN}/rpi:review${RESET}     Review against plan → PASS / FAIL
        │
-  ${CYAN}/rpi:docs${RESET}       Document the code → inline docs + changelog`,
+  ${CYAN}/rpi:docs${RESET}       Document the code → ${BOLD}DOCS.md${RESET} + changelog
+
+${DIM}Plus: /rpi:learn for knowledge compounding, /rpi:archive to wrap up.${RESET}`,
   },
   {
-    title: "Research Tiers",
+    title: "Key v2 Concepts",
     body: `
-${DIM}Control depth and cost with tier flags:${RESET}
-
-  ${GREEN}--quick${RESET}      2 agents    Fast feasibility check
-  ${YELLOW}--standard${RESET}   4 agents    Scope + technical approach ${DIM}(default)${RESET}
-  ${CYAN}--deep${RESET}       6 agents    Full strategic analysis
-
-${DIM}Agents run in parallel — deep research doesn't mean slow research.${RESET}`,
+${BOLD}Delta Specs${RESET}
+${DIM}Specs capture system state. Features only record what changes:${RESET}
+  rpi/specs/              ${DIM}Source of truth${RESET}
+  rpi/features/{slug}/delta/
+    ├── ADDED/            ${DIM}New spec files${RESET}
+    ├── MODIFIED/         ${DIM}Changes to existing specs${RESET}
+    └── REMOVED/          ${DIM}Specs being deleted${RESET}
+
+${BOLD}Knowledge Compounding${RESET}
+${DIM}A persistent knowledge base that grows with every feature:${RESET}
+  ${CYAN}/rpi:learn${RESET}             ${DIM}Manually capture lessons${RESET}
+  ${CYAN}/rpi:archive${RESET}           ${DIM}Merge delta into specs, clean up${RESET}
+
+${DIM}Scout checks past solutions before external research.${RESET}`,
   },
   {
     title: "Feature Folder Structure",
     body: `
 ${DIM}Each feature gets its own folder with all artifacts:${RESET}
 
-  rpi/
+  rpi/features/
   └── ${BOLD}your-feature/${RESET}
       ├── REQUEST.md              ${DIM}What and why${RESET}
       ├── research/
@@ -65,24 +75,32 @@ ${DIM}Each feature gets its own folder with all artifacts:${RESET}
       │   ├── eng.md              ${DIM}Technical spec${RESET}
       │   ├── pm.md               ${DIM}Product requirements${RESET}
       │   └── ux.md               ${DIM}UX design${RESET}
+      ├── delta/                  ${DIM}What changes (specs diff)${RESET}
+      │   ├── ADDED/
+      │   ├── MODIFIED/
+      │   └── REMOVED/
       └── implement/
           ├── IMPLEMENT.md        ${DIM}Execution audit trail${RESET}
           └── DOCS.md             ${DIM}Documentation summary${RESET}`,
   },
   {
-    title: "TDD Support",
+    title: "Quick Flow & Flags",
     body: `
-${DIM}RPIKit supports strict Test-Driven Development per task:${RESET}
+${BOLD}Quick Flow${RESET} ${DIM}— for small features${RESET}
+
+  ${CYAN}/rpi:new my-feature --quick${RESET}
+
+  Luna asks 1-2 questions → compact REQUEST.md → Forge implements
+  directly with a mini-plan (3-5 tasks). Skips research and full plan.
 
-  ${CYAN}RED${RESET}      → Write one failing test
-  ${GREEN}GREEN${RESET}    → Write minimal code to pass
-  ${YELLOW}REFACTOR${RESET} → Clean up, re-run tests
+${BOLD}Global Flags${RESET}
 
-${DIM}Enable in .rpi.yaml:${RESET}
-  tdd: true
-  test_runner: auto
+  ${GREEN}--quick${RESET}          Skip research + full plan
+  ${YELLOW}--force${RESET}          Re-run a phase even if artifacts exist
+  ${CYAN}--skip=phase${RESET}     Skip specific phase(s)
+  ${CYAN}--from=phase${RESET}     Start from a specific phase
 
-${DIM}Or run standalone:${RESET}  /rpi:test your-feature --task 1.2`,
+${DIM}TDD is also supported — enable in .rpi.yaml with tdd: true${RESET}`,
   },
   {
     title: "Get Started",

package/commands/rpi/archive.md

@@ -0,0 +1,149 @@
+---
+name: rpi:archive
+description: Merge delta specs into main specs and clean up the feature directory.
+argument-hint: "<feature-name>"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+---
+
+# /rpi:archive — Archive Feature
+
+Merge the feature's delta specs into the main `rpi/specs/` directory, preserve any solutions worth saving, and delete the feature directory. History is preserved in git.
+
+---
+
+## Step 1: Load config and validate
+
+1. Read `.rpi.yaml` for config. Apply defaults if missing:
+   - `folder`: `rpi/features`
+   - `specs_dir`: `rpi/specs`
+   - `solutions_dir`: `rpi/solutions`
+2. Parse `$ARGUMENTS` to extract `{slug}`.
+3. Validate `rpi/features/{slug}/` exists. If not:
+   ```
+   Feature '{slug}' not found. Nothing to archive.
+   ```
+   Stop.
+
+## Step 2: Validate review verdict
+
+1. Read `rpi/features/{slug}/implement/IMPLEMENT.md`.
+2. Look for a `## Review` section with a verdict of `PASS` or `PASS with concerns`.
+3. If verdict is `FAIL`:
+   ```
+   Review verdict is FAIL for '{slug}'.
+   Fix the issues and re-run: /rpi:review {slug}
+   Cannot archive a feature that hasn't passed review.
+   ```
+   Stop.
+4. If no review section or verdict is found:
+   ```
+   No review verdict found for '{slug}'.
+   Run /rpi:review {slug} before archiving.
+   ```
+   Stop.
+
+## Step 3: Read delta contents
+
+1. Scan `rpi/features/{slug}/delta/ADDED/` for all files — store as `$ADDED_FILES`.
+2. Scan `rpi/features/{slug}/delta/MODIFIED/` for all files — store as `$MODIFIED_FILES`.
+3. Scan `rpi/features/{slug}/delta/REMOVED/` for all files — store as `$REMOVED_FILES`.
+4. Read the contents of each file found.
+
+If all three directories are empty:
+```
+No delta specs found for '{slug}'. Skipping specs merge.
+```
+Proceed to Step 5.
+
+## Step 4: Launch Nexus to merge delta into specs
+
+Use the Agent tool to launch Nexus for the merge:
+
+```
+You are Nexus. Merge the delta specs for feature '{slug}' into the main specs directory.
+
+## ADDED Files (copy to rpi/specs/)
+{for each file in $ADDED_FILES: filename and full contents}
+
+## MODIFIED Files (apply changes to existing rpi/specs/ files)
+{for each file in $MODIFIED_FILES: filename, delta contents, and current contents of the target spec file in rpi/specs/}
+
+## REMOVED Files (delete from rpi/specs/)
+{for each file in $REMOVED_FILES: filename}
+
+Your task:
+1. For each ADDED file: determine the correct path under rpi/specs/ and write the file there.
+   - Use the file's content as-is. Preserve the directory structure (e.g. delta/ADDED/auth/oauth.md → rpi/specs/auth/oauth.md).
+2. For each MODIFIED file: read the current spec at rpi/specs/{path}, apply the changes from the delta version.
+   - The delta file contains the updated version of the spec. Merge it intelligently:
+   - Preserve any sections in the original that aren't addressed by the delta
+   - Update sections that the delta modifies
+   - Add new sections from the delta
+3. For each REMOVED file: note the path under rpi/specs/ that should be deleted.
+
+Output format:
+## Merge Plan
+### Files to Write
+- {path}: {action: created | updated} — {brief description}
+
+### Files to Delete
+- {path} — {reason}
+
+### Warnings
+- {any conflicts or issues detected}
+(or "No warnings.")
+```
+
+Store the output as `$NEXUS_MERGE`.
+
+After Nexus responds, execute the merge plan:
+1. **ADDED**: Write each file to `rpi/specs/{path}` (create directories as needed).
+2. **MODIFIED**: Write the merged content to `rpi/specs/{path}`.
+3. **REMOVED**: Delete the files from `rpi/specs/`.
+
+## Step 5: Check for solutions worth saving
+
+1. Read `rpi/features/{slug}/implement/IMPLEMENT.md` for the review section.
+2. If the review flagged solutions saved to `rpi/solutions/`:
+   - Verify each referenced solution file exists in `rpi/solutions/`.
+   - If any are missing, warn:
+     ```
+     Warning: Solution '{path}' referenced in review but not found.
+     ```
+
+## Step 6: Delete feature directory
+
+Remove the entire feature directory:
+
+```bash
+rm -rf rpi/features/{slug}
+```
+
+## Step 7: Commit
+
+Stage all changes and commit:
+
+```bash
+git add -A
+git commit -m "chore: archive {slug} — delta merged, feature complete"
+```
+
+## Step 8: Output summary
+
+```
+Archive complete: {slug}
+
+Specs merged:
+- Added: {N} files
+- Modified: {N} files
+- Removed: {N} files
+
+Feature directory deleted: rpi/features/{slug}/
+History preserved in git.
+```