rpi-kit 2.2.2 → 2.5.0

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

@@ -0,0 +1,290 @@
+description = "Quick bugfix — Luna interviews, Mestre plans (max 3 tasks), Forge implements. One command."
+
+prompt = """
+# /rpi:fix — Quick Bugfix
+
+Runs Luna → Mestre → Forge in one step for bugfixes. Creates compact artifacts with max 3 tasks. Each task generates a commit.
+
+---
+
+## Step 1: Load config and parse arguments
+
+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}` — the bug name (required)
+   - `--resume`: continue from last completed task if IMPLEMENT.md exists
+   - `--force`: restart from scratch (overwrites existing artifacts)
+3. If `{slug}` is not provided, ask with AskUserQuestion: "What's the bug? Give it a short slug (e.g. 'login-crash', 'missing-validation')."
+4. Convert slug to kebab-case (lowercase, spaces/underscores become hyphens, strip special chars).
+
+## Step 2: Check for existing feature
+
+Check if `{folder}/{slug}/` already exists.
+
+If it exists and `--force` was NOT passed:
+- Check if `implement/IMPLEMENT.md` exists:
+  - If yes and `--resume` was passed (or default): skip to Step 6 (resume implementation).
+  - If yes and `--force` was NOT passed: ask the user: "Feature '{slug}' already exists. Resume implementation (--resume) or start over (--force)?"
+- If no IMPLEMENT.md: ask the user: "Feature '{slug}' already exists but implementation hasn't started. Overwrite? (yes/no)"
+
+If it exists and `--force` was passed: proceed (will overwrite).
+
+## Step 3: Create directory structure
+
+```bash
+mkdir -p {folder}/{slug}/plan
+mkdir -p {folder}/{slug}/implement
+```
+
+No `research/` directory. No `delta/` directories.
+
+## Step 4: Luna — Bugfix Interview
+
+Adopt Luna's persona. This is a bugfix interview — fast and focused.
+
+### If slug is descriptive (e.g. `login-crash`, `null-pointer-auth`):
+
+Ask one question with AskUserQuestion:
+> "Descreve o bug: o que acontece, o que deveria acontecer, e onde se manifesta (ficheiro, endpoint, componente — se souberes)."
+
+### If slug is vague (e.g. `fix1`, `bug`):
+
+Ask two questions with AskUserQuestion:
+> 1. "Qual é o bug?"
+> 2. "Onde se manifesta? (ficheiro, endpoint, componente — se souberes)"
+
+### Generate REQUEST.md
+
+Write `{folder}/{slug}/REQUEST.md`:
+
+```markdown
+# Fix: {slug}
+
+## Bug Report
+{bug description — what happens vs. what should happen}
+
+## Location
+{where it manifests — file, module, endpoint, or "Unknown"}
+
+## Constraints
+- {constraint if any, or "None identified"}
+
+## Unknowns
+- {at least one — e.g., "Root cause not confirmed"}
+
+## Complexity Estimate
+S — bugfix
+
+## Quick Flow
+This is a bugfix. Skipping research phase.
+```
+
+Output:
+```
+REQUEST.md created: {folder}/{slug}/REQUEST.md
+Starting plan phase...
+```
+
+## Step 5: Mestre — Compact Plan
+
+Launch Mestre agent with this prompt:
+
+```
+You are Mestre. Generate a compact bugfix plan for: {slug}
+
+## Bug Report (REQUEST.md)
+{content of REQUEST.md}
+
+## Project Context
+{content of context.md if it exists, otherwise "No project context file found."}
+
+## Instructions
+1. Read the files mentioned in the Location section of the bug report
+2. Analyze the probable root cause
+3. Generate a PLAN.md with maximum 3 tasks
+4. Each task must list exact files to change and dependencies
+5. Be surgical — only fix the bug, no refactoring, no improvements
+
+IMPORTANT: If you determine this bug needs more than 3 tasks, output ONLY:
+"ESCALATE: This bug is too complex for /rpi:fix. Use /rpi:new {slug} for the full pipeline."
+Do NOT generate a plan in this case.
+
+Output using this format:
+
+# Plan: Fix {slug}
+
+## Analysis
+{2-3 sentences — probable root cause, affected files}
+
+## Tasks
+
+### Task 1: {description}
+- Files: {files to change}
+- Deps: none
+
+### Task 2: {description}
+- Files: {files to change}
+- Deps: [1]
+
+## Risks
+- {if any, or "None — straightforward fix"}
+
+After generating the plan, append your activity to {folder}/{slug}/ACTIVITY.md:
+
+### {current_date} — Mestre (Fix — Compact Plan)
+- **Action:** Compact bugfix plan for {slug}
+- **Tasks:** {count}
+- **Quality:** {your quality gate result}
+```
+
+### Handle Mestre's response
+
+If Mestre outputs `ESCALATE:`:
+```
+This bug needs more than 3 tasks — too complex for /rpi:fix.
+
+Use the full pipeline: /rpi:new {slug}
+```
+Stop.
+
+If Mestre outputs a valid plan:
+1. Write `{folder}/{slug}/plan/PLAN.md` with Mestre's output.
+2. Output:
+   ```
+   PLAN.md created: {folder}/{slug}/plan/PLAN.md ({N} tasks)
+   Starting implementation...
+   ```
+
+## Step 6: Forge — Implementation
+
+For each task in PLAN.md order, respecting dependency ordering:
+
+### Step 6a: Initialize IMPLEMENT.md (if not resuming)
+
+Write `{folder}/{slug}/implement/IMPLEMENT.md`:
+
+```markdown
+# Implementation: Fix {slug}
+
+Started: {YYYY-MM-DD}
+Plan: {folder}/{slug}/plan/PLAN.md
+
+## Tasks
+
+- [ ] Task {1}: {description}
+- [ ] Task {2}: {description}
+- ...
+
+## Execution Log
+```
+
+### Step 6b: Handle resume
+
+If resuming (IMPLEMENT.md exists):
+1. Read IMPLEMENT.md, find next unchecked task `- [ ]`.
+2. Output: `Resuming '{slug}' from task {next_task_id}. ({completed}/{total} tasks done)`
+
+### Step 6c: Execute each task
+
+Launch Forge agent for each task:
+
+```
+You are Forge. Implement task {task_id} for bugfix: {slug}
+
+## Task
+{task description from PLAN.md}
+
+## Target Files
+{files listed for this task}
+
+## Dependencies Completed
+{list of completed task IDs and their descriptions}
+
+## Bug Report
+{content of REQUEST.md}
+
+## Project Context
+{content of context.md if it exists}
+
+CRITICAL RULES:
+1. CONTEXT_READ: You MUST read ALL target files before writing ANY code
+2. Match existing patterns — naming, error handling, imports, style
+3. Only touch files listed in the task unless absolutely necessary
+4. Commit your changes with a conventional commit message
+5. Report: DONE | BLOCKED | DEVIATED
+
+After completing the task, append your activity to {folder}/{slug}/ACTIVITY.md:
+
+### {current_date} — Forge (Fix — Task {task_id})
+- **Action:** Implemented task {task_id} for {slug}
+- **Files changed:** {list}
+- **Status:** {DONE|BLOCKED|DEVIATED}
+- **Quality:** {your quality gate result}
+```
+
+### Step 6d: Parse Forge response
+
+**DONE:**
+1. Update IMPLEMENT.md: `- [ ] Task {id}` → `- [x] Task {id}`
+2. Append to Execution Log:
+   ```
+   ### Task {id}: {description}
+   - Status: DONE
+   - Commit: {hash}
+   - Files: {list of files changed}
+   ```
+3. Continue to next task.
+
+**BLOCKED:**
+1. Update IMPLEMENT.md with blocker.
+2. Output:
+   ```
+   Fix blocked at task {id}: {description}
+
+   Blocker: {reason}
+
+   Options:
+   - Fix the blocker and run: /rpi:fix {slug} --resume
+   - Use the full pipeline: /rpi:new {slug}
+   ```
+3. Stop.
+
+**DEVIATED:**
+1. Cosmetic: log it, continue automatically.
+2. Interface/scope: warn the user, ask to accept or revert.
+3. If accepted: update IMPLEMENT.md as DONE with deviation noted.
+4. If reverted: git revert, task stays unchecked. Stop.
+
+## Step 7: Completion summary
+
+After all tasks completed, output:
+
+```
+Fix complete: {slug}
+
+Tasks: {completed}/{total}
+Commits:
+- {hash1}: {task 1 description}
+- {hash2}: {task 2 description}
+
+Next:
+- Review: /rpi:review {slug}
+- Archive: /rpi:archive {slug}
+- Full pipeline on this: /rpi {slug} --from=simplify
+```
+
+Update IMPLEMENT.md with a final section:
+
+```markdown
+## Summary
+
+- Total tasks: {N}
+- Completed: {N}
+- Blocked: {N}
+- Deviations: {N}
+- Completed: {YYYY-MM-DD}
+```
+"""

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

@@ -0,0 +1,272 @@
+description = "Execute the plan task by task with Forge. Sage assists with tests if TDD enabled."
+
+prompt = """
+# /rpi:implement — Implement Phase
+
+Execute PLAN.md task by task. Forge implements each task with strict CONTEXT_READ discipline. If TDD is enabled, Sage writes failing tests before Forge implements.
+
+---
+
+## Step 1: Load config and validate
+
+1. Read `.rpi.yaml` for config. Apply defaults if missing:
+   - `folder`: `rpi/features`
+   - `context_file`: `rpi/context.md`
+   - `tdd`: `false`
+   - `commit_style`: `conventional`
+2. Parse `$ARGUMENTS` to extract `{slug}` and optional flags:
+   - `--resume`: continue from last completed task (default behavior when IMPLEMENT.md exists)
+   - `--force`: restart implementation from scratch even if IMPLEMENT.md exists
+3. Validate `rpi/features/{slug}/plan/PLAN.md` exists. If not:
+   ```
+   PLAN.md not found for '{slug}'. Run /rpi:plan {slug} first.
+   ```
+   Stop.
+
+## Step 2: Gather context
+
+1. Read `rpi/features/{slug}/plan/PLAN.md` — store as `$PLAN`.
+2. Read `rpi/features/{slug}/plan/eng.md` if it exists — store as `$ENG`.
+3. Read `rpi/context.md` (project context) if it exists — store as `$CONTEXT`.
+4. Parse `$PLAN` to extract the ordered task list. Each task should have:
+   - `task_id`: task number/identifier
+   - `description`: what to implement
+   - `files`: target files to create or modify
+   - `deps`: dependencies on other tasks (must be completed first)
+
+## Step 3: Handle resume vs fresh start
+
+### If IMPLEMENT.md exists and `--force` was NOT passed:
+
+1. Read `rpi/features/{slug}/implement/IMPLEMENT.md`.
+2. Parse completed tasks: lines matching `- [x]` are done, `- [ ]` are pending.
+3. Find the next incomplete task — this is where execution resumes.
+4. Inform the user:
+   ```
+   Resuming '{slug}' from task {next_task_id}. ({completed}/{total} tasks done)
+   ```
+5. Skip to Step 5 starting from the next incomplete task.
+
+### If IMPLEMENT.md exists and `--force` was passed:
+
+1. Ask the user: "IMPLEMENT.md already exists for '{slug}'. This will restart from scratch. Continue? (yes/no)"
+2. If no: stop.
+3. If yes: proceed to Step 4 (will overwrite).
+
+### If IMPLEMENT.md does not exist:
+
+Proceed to Step 4.
+
+## Step 4: Initialize IMPLEMENT.md
+
+1. Ensure directory exists: `rpi/features/{slug}/implement/`
+2. Write `rpi/features/{slug}/implement/IMPLEMENT.md` with all tasks unchecked:
+
+```markdown
+# Implementation: {Feature Title}
+
+Started: {YYYY-MM-DD}
+Plan: rpi/features/{slug}/plan/PLAN.md
+
+## Tasks
+
+- [ ] Task {1}: {description}
+- [ ] Task {2}: {description}
+- ...
+
+## Execution Log
+```
+
+## Step 5: Execute tasks in order
+
+For each task in PLAN.md order, respecting dependency ordering (a task's deps must all be `[x]` before it runs):
+
+### Step 5a: TDD — Sage writes tests (if `tdd: true` in config)
+
+Launch Sage agent with this prompt:
+
+```
+You are Sage. Write failing tests for task {task_id} of feature: {slug}
+
+## Task
+{task description from PLAN.md}
+
+## Target Files
+{files listed for this task}
+
+## Engineering Spec
+{$ENG}
+
+## Project Context
+{$CONTEXT}
+
+Your task:
+1. Read existing test files and test patterns in the project
+2. Write tests that verify the expected behavior for this task
+3. Tests MUST fail right now (the implementation doesn't exist yet)
+4. Cover: happy path, error path, at least one edge case
+5. Run the tests and confirm they fail
+6. Output: test file path, test code, and the failing test output
+
+After writing tests, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Sage (Implement — TDD for Task {task_id})
+- **Action:** Wrote failing tests for task {task_id}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Tests written:** {count}
+- **Edge cases covered:** {count}
+- **Quality:** {your quality gate result}
+```
+
+Wait for Sage to complete. Store the test output as `$SAGE_TESTS`. Verify the tests actually fail — if they pass, something is wrong (the behavior may already exist). Inform the user and ask how to proceed.
+
+### Step 5b: Launch Forge to implement
+
+Launch Forge agent with this prompt:
+
+```
+You are Forge. Implement task {task_id} for feature: {slug}
+
+## Task
+{task description from PLAN.md}
+
+## Target Files
+{files listed for this task}
+
+## Dependencies Completed
+{list of completed task IDs and their descriptions}
+
+## Engineering Spec
+{$ENG}
+
+## Project Context
+{$CONTEXT}
+
+## Tests to Pass
+{$SAGE_TESTS if TDD enabled, otherwise "No TDD tests — follow the plan."}
+
+CRITICAL RULES:
+1. CONTEXT_READ: You MUST read ALL target files before writing ANY code
+2. Match existing patterns — naming, error handling, imports, style
+3. Only touch files listed in the task unless absolutely necessary
+4. If TDD: make the failing tests pass
+5. Commit your changes with a conventional commit message
+6. Report: DONE | BLOCKED | DEVIATED
+
+After completing the task, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Forge (Implement — Task {task_id})
+- **Action:** Implemented task {task_id} for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Files changed:** {list}
+- **Status:** {DONE|BLOCKED|DEVIATED}
+- **Quality:** {your quality gate result}
+```
+
+### Step 5c: Parse Forge response
+
+Forge will respond with one of three statuses:
+
+#### DONE
+
+1. Task completed successfully.
+2. Extract the commit hash from Forge's commit.
+3. If TDD enabled: verify tests now pass. If tests still fail, inform the user and ask how to proceed.
+4. Update IMPLEMENT.md: change `- [ ] Task {id}` to `- [x] Task {id}` and append to Execution Log:
+   ```
+   ### Task {id}: {description}
+   - Status: DONE
+   - Commit: {hash}
+   - Files: {list of files changed}
+   ```
+5. Continue to next task.
+
+#### BLOCKED
+
+1. Forge could not complete the task.
+2. Update IMPLEMENT.md with blocker details:
+   ```
+   ### Task {id}: {description}
+   - Status: BLOCKED
+   - Reason: {blocker description from Forge}
+   ```
+3. Stop execution. Inform the user:
+   ```
+   Implementation blocked at task {id}: {description}
+
+   Blocker: {reason}
+
+   Options:
+   - Fix the blocker and run: /rpi:implement {slug} --resume
+   - Skip this task and continue: /rpi:implement {slug} (after manually marking task as skipped)
+   - Re-plan: /rpi:plan {slug} --force
+   ```
+4. Do NOT continue to the next task.
+
+#### DEVIATED
+
+1. Forge deviated from the plan.
+2. Check the deviation severity:
+   - **cosmetic** (naming, formatting): log it, continue automatically.
+   - **interface** (API changes, function signatures): warn the user, ask to accept or revert.
+   - **scope** (extra features, different approach): stop execution, ask the user to accept or revert.
+3. If accepted: update IMPLEMENT.md as DONE with deviation noted:
+   ```
+   ### Task {id}: {description}
+   - Status: DONE (with deviation)
+   - Commit: {hash}
+   - Deviation: {severity} — {description}
+   - Files: {list of files changed}
+   ```
+4. If reverted: Forge's changes are reverted (git revert), task stays unchecked. Inform the user and stop.
+
+## Step 6: Completion summary
+
+After all tasks are completed, output:
+
+```
+Implementation complete: {slug}
+
+Tasks: {completed}/{total}
+Commits:
+- {hash1}: {task 1 description}
+- {hash2}: {task 2 description}
+- ...
+
+{If any deviations: list them here}
+
+Next: /rpi {slug}
+Or explicitly: /rpi:simplify {slug}
+```
+
+Update IMPLEMENT.md with a final section:
+
+```markdown
+## Summary
+
+- Total tasks: {N}
+- Completed: {N}
+- Blocked: {N}
+- Deviations: {N} ({list severities})
+- Completed: {YYYY-MM-DD}
+```
+
+## Step 7: Consolidate decisions to DECISIONS.md
+
+1. Read `rpi/features/{slug}/ACTIVITY.md`.
+2. Extract all `<decision>` tags from entries belonging to the Implement phase (Sage and Forge 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
+## Implement 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.
+"""