rpi-kit 1.0.1 → 1.1.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "rpi-kit",
+  "version": "1.1.0",
+  "description": "Research → Plan → Implement. A systematic feature development workflow with validation gates, multi-role agent teams, and adaptive depth.",
+  "owner": {
+    "name": "Daniel Mendes"
+  },
+  "plugins": [
+    {
+      "name": "rpi-kit",
+      "source": "./",
+      "description": "Research → Plan → Implement. A systematic feature development workflow for Claude Code and Codex.",
+      "version": "1.1.0",
+      "author": {
+        "name": "Daniel Mendes"
+      },
+      "license": "MIT",
+      "keywords": ["workflow", "research", "planning", "implementation", "feature-development", "agents"],
+      "category": "productivity"
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,20 @@
+{
+  "name": "rpi-kit",
+  "version": "1.1.0",
+  "description": "Research → Plan → Implement. A systematic feature development workflow with validation gates, multi-role agent teams, and adaptive depth.",
+  "author": {
+    "name": "Daniel Mendes",
+    "url": "https://github.com/dmend3z"
+  },
+  "repository": "https://github.com/dmend3z/rpi-kit",
+  "license": "MIT",
+  "keywords": [
+    "workflow",
+    "research",
+    "planning",
+    "implementation",
+    "feature-development",
+    "agents",
+    "codex"
+  ]
+}

package/codex.md

@@ -0,0 +1,69 @@
+# RPI Workflow Rules
+
+You follow the RPI (Research → Plan → Implement) workflow for feature development.
+
+## Core Principles
+
+1. **Never implement without research.** Every feature starts with a REQUEST.md and goes through a GO/NO-GO research gate.
+2. **Never code without a plan.** The plan phase produces structured artifacts (PLAN.md, eng.md, and optionally pm.md/ux.md) before any code is written.
+3. **Track every task.** Implementation uses task-level tracking with commits per task and phase checkpoints.
+4. **Simplify before review.** After implementation, run code simplification (reuse, quality, efficiency) before code review.
+5. **Review against the plan.** Code review checks implementation against plan requirements, not just code quality.
+6. **Test before you code (when TDD enabled).** Write one failing test, verify it fails, write minimal code to pass, verify it passes, refactor. No implementation without a failing test first.
+
+## File Conventions
+
+```
+{folder}/{feature-slug}/
+├── REQUEST.md              # Feature description (structured sections)
+├── research/
+│   └── RESEARCH.md         # GO/NO-GO analysis with agent perspectives
+├── plan/
+│   ├── PLAN.md             # Task checklist with effort, deps, files
+│   ├── pm.md               # (adaptive) User stories + acceptance criteria
+│   ├── ux.md               # (adaptive) User flows + interaction patterns
+│   └── eng.md              # Technical architecture + dependencies
+└── implement/
+    └── IMPLEMENT.md        # Full audit trail: tasks, commits, deviations
+```
+
+## Workflow Commands
+
+- `/rpi:init` — Set up RPI config for this project
+- `/rpi:new` — Interactive interview to create a feature REQUEST.md
+- `/rpi:research <feature>` — Research phase with GO/NO-GO verdict
+- `/rpi:plan <feature>` — Generate plan artifacts from research
+- `/rpi:implement <feature>` — Execute plan with task tracking
+- `/rpi:simplify <feature>` — Code simplification (reuse, quality, efficiency)
+- `/rpi:test <feature>` — Run TDD cycles (RED → GREEN → REFACTOR) per task
+- `/rpi:status` — Show all features and their current phase
+- `/rpi:review <feature>` — Code review against plan
+
+## Research Tiers
+
+- `--quick` — Feasibility check only (2 agents: requirements + codebase)
+- `--standard` — Scope + technical approach (4 agents: + PM + engineer)
+- `--deep` — Full analysis with strategic assessment (5-6 agents: + CTO + UX if UI)
+
+## Agent Team
+
+| Role | Perspective |
+|------|-------------|
+| Requirement Parser | Extracts structured requirements, lists unknowns |
+| Product Manager | Scope, user stories, effort, acceptance criteria |
+| UX Designer | User flows, interaction patterns, existing components |
+| Senior Engineer | Technical approach, architecture, dependencies |
+| CTO Advisor | Risk, feasibility, strategic alignment, alternatives |
+| Doc Synthesizer | Merges research into executive summary + verdict |
+| Plan Executor | Implements tasks surgically, one at a time |
+| Code Simplifier | Reuse, quality, efficiency checks with fixes |
+| Code Reviewer | Reviews against plan requirements |
+| Codebase Explorer | Scans existing code for patterns and context |
+| Test Engineer | Writes failing tests before implementation (TDD) |
+
+## GO/NO-GO Verdicts
+
+- **GO** — Feature is feasible, proceed to planning
+- **GO with concerns** — Feasible but has risks that need mitigation
+- **NO-GO** — Not feasible as described; alternatives suggested
+- Override a NO-GO verdict: `/rpi:plan {feature-slug} --force`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rpi-kit",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Research → Plan → Implement. A systematic feature development workflow for Claude Code.",
   "license": "MIT",
   "author": "Daniel Mendes",
@@ -22,10 +22,13 @@
     "rpi-kit": "./bin/cli.js"
   },
   "files": [
+    ".claude-plugin/",
     "bin/",
     "commands/",
     "agents/",
+    "skills/",
     "AGENTS.md",
+    "codex.md",
     "README.md",
     "LICENSE"
   ],

package/skills/rpi-agents/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: rpi-agents
+description: This skill should be used when the user asks about RPI agent behavior, rules, or roles, asks "what agents are involved", "how does the code reviewer work", "what are the agent rules", "customize agent behavior", or mentions agent names like requirement-parser, product-manager, ux-designer, senior-engineer, cto-advisor, doc-synthesizer, plan-executor, code-simplifier, code-reviewer, explore-codebase, or test-engineer.
+version: 1.0.1
+license: MIT
+---
+
+# RPI Agent Guidelines
+
+Behavioral constraints for RPI agents. Every agent follows the general rules below PLUS their role-specific rules.
+
+## General Rules (All Agents)
+
+1. **Cite evidence.** Every claim must reference a specific file, dependency, or codebase pattern. No unsupported statements.
+2. **Name unknowns.** If you're uncertain, say what you don't know. Never fill gaps with assumptions.
+3. **Be concrete.** Anti-pattern: "This could improve performance." Instead: "Batching the 3 API calls reduces round-trips from 3 to 1."
+4. **Stay in scope.** Only analyze what's relevant to the feature. Don't audit the entire codebase.
+5. **Structured output.** Use the section format specified for your role. Include your verdict per section.
+
+## Output Format (Research Agents)
+
+Each research agent outputs markdown sections with verdicts:
+
+```markdown
+## [Section Name]
+Verdict: GO | CONCERN | BLOCK
+
+[Findings with evidence]
+
+### [Sub-section if needed]
+[Details]
+```
+
+End with: `Estimated Complexity: S | M | L | XL`
+
+## Agent Roles
+
+The RPI workflow uses 10 specialized agents. Each has detailed behavioral rules, anti-patterns, and output formats defined in its own file under `agents/`:
+
+| Agent | Role | Phase |
+|-------|------|-------|
+| requirement-parser | Extract structured, testable requirements | Research |
+| product-manager | Scope, user stories, effort, acceptance criteria | Research, Plan |
+| ux-designer | User flows, interaction patterns, UI decisions | Research (deep), Plan |
+| senior-engineer | Technical approach, architecture, dependencies | Research, Plan |
+| cto-advisor | Risk, feasibility, strategic alignment | Research (deep) |
+| doc-synthesizer | Merge research outputs into RESEARCH.md | Research |
+| explore-codebase | Scan codebase for patterns and context | Research |
+| test-engineer | Write failing tests before implementation (TDD) | Implement (TDD), Test |
+| plan-executor | Implement tasks from PLAN.md surgically | Implement |
+| code-simplifier | Check reuse, quality, efficiency and fix | Implement |
+| code-reviewer | Review implementation against plan | Implement, Review |
+
+For full role-specific rules, anti-patterns, and output formats, see the individual agent definitions in `agents/*.md`.
+
+## Related
+
+For the workflow process (phases, commands, configuration), see the **rpi-workflow** skill.

package/skills/rpi-workflow/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: rpi-workflow
+description: This skill should be used when the user wants to develop a feature systematically, asks "how do I start a new feature", "walk me through the workflow", "help me build this step by step", says "research plan implement", mentions TDD or test-driven development, or mentions any RPI command (/rpi:init, /rpi:new, /rpi:research, /rpi:plan, /rpi:implement, /rpi:test, /rpi:simplify, /rpi:status, /rpi:review).
+version: 0.2.0
+license: MIT
+---
+
+# RPI Workflow
+
+RPI (Research → Plan → Implement) is a systematic feature development workflow with validation gates at each phase.
+
+## Workflow Phases
+
+### Phase 0: Init
+Run `/rpi:init` once per project to configure:
+- Feature folder location (default: `rpi/`)
+- Default research tier
+- Parallel threshold, commit style, and other preferences
+- Creates `.rpi.yaml` at project root
+
+### Phase 1: New Feature
+Run `/rpi:new` to start. Adaptive interview:
+- Start with core questions: what feature, what problem it solves
+- Ask follow-ups based on answers (who uses it, complexity, constraints, references)
+- Set up isolation based on `isolation` config:
+  - `none`: work on current branch
+  - `branch`: `git checkout -b feature/{slug}`
+  - `worktree`: create `.worktrees/{slug}` with `git worktree add`
+- Generate `{folder}/{feature-slug}/REQUEST.md` with structured sections
+
+REQUEST.md sections: Summary, Problem, Target Users, Constraints, References, Complexity Estimate.
+
+### Phase 2: Research
+Run `/rpi:research {feature-slug}` with optional tier flag.
+
+Research tiers control agent composition:
+- `--quick`: requirement-parser + explore-codebase (feasibility only)
+- `--standard` (default): + product-manager + senior-engineer (scope + approach)
+- `--deep`: + cto-advisor + ux-designer if UI (full analysis + alternatives)
+
+All selected agents run in **parallel fan-out**. Doc-synthesizer merges outputs into RESEARCH.md.
+
+RESEARCH.md format:
+1. Executive Summary (5 lines: verdict, complexity, risk, recommendation, key finding)
+2. Requirements Analysis
+3. Product Scope
+4. Codebase Context
+5. Technical Analysis
+6. Strategic Assessment (deep tier only)
+7. Alternatives (mandatory if NO-GO)
+
+Verdicts: **GO**, **GO with concerns**, **NO-GO**
+- NO-GO includes alternative approaches and scope reduction suggestions
+- Override with `--force` flag
+
+### Phase 3: Plan
+Run `/rpi:plan {feature-slug}`.
+
+Adaptive artifact generation:
+- Always: PLAN.md (task checklist) + eng.md (technical spec)
+- Adaptive: pm.md (user stories) and ux.md (user flows) — generated based on feature type
+- After research, asks user to confirm which artifacts to generate
+
+PLAN.md task format:
+```markdown
+## Phase 1: Phase Name
+
+- [ ] **1.1** Task description
+  Effort: S | Deps: none
+  Files: src/path/to/file.ts
+  Test: returns 200 for valid request with auth token
+
+- [ ] **1.2** Another task
+  Effort: M | Deps: 1.1
+  Files: src/other/file.ts
+  Test: rejects duplicate entries with 409 conflict
+```
+
+### Standalone: TDD
+Run `/rpi:test {feature-slug}` to run TDD cycles on individual tasks.
+
+- Works independently of `/rpi:implement` — use when you want TDD on specific tasks
+- Strict RED → GREEN → REFACTOR per task, one test at a time
+- Auto-detects test framework and conventions from the project
+- Flags: `--task <id>` for single task, `--all` for all uncompleted tasks
+
+### Phase 4: Implement
+Run `/rpi:implement {feature-slug}`.
+
+Smart execution mode:
+- < 8 tasks: single plan-executor agent, sequential
+- 8+ tasks: group into waves by dependency, execute in parallel
+- Override: `--sequential` or `--parallel` flags
+
+Pipeline per phase:
+1. Execute tasks → commit per task
+   - If TDD enabled: RED (write failing test) → VERIFY RED → GREEN (minimal code) → VERIFY GREEN → REFACTOR → commit
+   - If TDD disabled: execute task → commit (original behavior)
+2. Simplify (3 parallel sub-agents: reuse, quality, efficiency)
+3. Review (code-reviewer checks against plan + test coverage)
+4. Phase verdict: PASS or FAIL
+
+IMPLEMENT.md tracks: task completion with commits, start/end times, files changed, deviations, simplify findings, review verdict.
+
+After implementation, isolation cleanup runs based on config:
+- `none`: nothing
+- `branch`: asks to merge into main branch
+- `worktree`: asks to merge + remove the worktree
+
+## Configuration (.rpi.yaml)
+
+```yaml
+folder: rpi                    # Feature folder location
+tier: standard                 # Default research tier
+auto_simplify: true            # Run simplify before review
+commit_style: conventional     # Commit message format
+parallel_threshold: 8          # Task count for parallel mode
+skip_artifacts: []             # Artifacts to never generate
+review_after_implement: true   # Mandatory review gate
+isolation: none                # none | branch | worktree
+tdd: false                     # Enable Test-Driven Development
+test_runner: auto              # Test command (auto-detect or explicit)
+```
+
+## Feature Folder Structure
+
+```
+{folder}/{feature-slug}/
+├── REQUEST.md
+├── research/
+│   └── RESEARCH.md
+├── plan/
+│   ├── PLAN.md
+│   ├── pm.md          (adaptive)
+│   ├── ux.md          (adaptive)
+│   └── eng.md
+└── implement/
+    └── IMPLEMENT.md
+```
+
+## Cross-Session Continuity
+
+All state lives in markdown files. When resuming:
+- `/rpi:status` shows all features with current phase and progress
+- `/rpi:implement` reads IMPLEMENT.md and resumes from last completed task
+- Multiple features can be in progress simultaneously
+
+## Related
+
+For agent behavioral guidelines, see the **rpi-agents** skill or individual agent files in `agents/`.