@arvorco/relentless 0.1.19 → 0.1.21

package/.claude/commands/relentless.implement.md

@@ -1,15 +1,42 @@
 ---
-description: Execute implementation workflow phase by phase.
+description: Execute implementation workflow for a feature manually, story by story.
 ---
 
 Load the implement skill and begin systematic implementation.
 
+**Usage:** `/relentless.implement [story-id]`
+
 **Context:** $ARGUMENTS
 
-The implement skill will:
-1. Guide you through implementing tasks in dependency order
-2. Track progress per user story
-3. Ensure quality gates are met
-4. Update progress.txt with learnings
+The implement skill will guide you through:
+
+1. **TDD Workflow** - Tests first, then implementation
+2. **Quality Gates** - typecheck, lint, test must all pass
+3. **File Updates** - tasks.md, checklist.md, prd.json, progress.txt
+4. **Dependency Order** - Stories implemented in correct sequence
+
+## Quick Start
+
+1. Ensure you have all artifacts: spec.md, plan.md, tasks.md, checklist.md, prd.json
+2. Run `/relentless.analyze` first (must pass with no CRITICAL issues)
+3. Run `/relentless.implement` to start with the next available story
+4. Or run `/relentless.implement US-003` to implement a specific story
+
+## What Gets Updated
+
+After each story:
+- `tasks.md` - Acceptance criteria checked off
+- `checklist.md` - Verified items checked off
+- `prd.json` - Story marked as `passes: true`
+- `progress.txt` - Progress entry with learnings
+
+## Prerequisites
+
+- `/relentless.analyze` must pass
+- All feature artifacts must exist
+- Constitution and prompt.md reviewed
+
+## See Also
 
-Prerequisites: /relentless.analyze must pass (no CRITICAL issues)
+- `relentless run` - Automated orchestration (runs agents automatically)
+- `/relentless.analyze` - Check artifact consistency before implementing

package/.claude/skills/constitution/SKILL.md

@@ -12,9 +12,10 @@ Create a personalized project constitution that defines your team's coding princ
 ## The Job
 
 1. Ask the user about their project's coding philosophy and standards
-2. Generate a personalized constitution based on their answers
-3. Save to `relentless/constitution.md`
-4. Ensure consistency with project templates and documentation
+2. Analyze the project structure and documentation
+3. Generate personalized constitution based on their answers → `relentless/constitution.md`
+4. Generate personalized agent prompt based on the same analysis → `relentless/prompt.md`
+5. Ensure consistency with project templates and documentation
 
 **Important:** The constitution is the foundation for all feature work - create this before generating features.
 
@@ -67,31 +68,126 @@ Load the template from `templates/constitution-template.md` and:
 
 ---
 
-## Step 3: Validate & Save
+## Step 3: Analyze Project Structure
+
+Read and analyze project documentation:
+
+**Core Files:**
+- `README.md` - Project overview, setup instructions
+- `AGENTS.md` or `CLAUDE.md` - Developer guidelines
+- `package.json` - Scripts, dependencies, tech stack
+- `CONTRIBUTING.md` - Contribution workflow (if exists)
+
+**Extract:**
+- Tech stack (TypeScript, React, Node, etc.)
+- Testing framework (vitest, jest, playwright)
+- Quality commands (`typecheck`, `lint`, `test`)
+- Build system (bun, npm, turbo, vite)
+- Linting setup (eslint, biome)
+- File structure patterns
+
+---
+
+## Step 4: Generate Personalized Prompt
+
+Using the generic template from relentless, create a personalized `prompt.md` with:
+
+**Section 1: Quality Gates**
+```markdown
+## CRITICAL: Quality Gates (Non-Negotiable)
+
+Before marking ANY story as complete:
+
+\`\`\`bash
+# TypeScript (detected from package.json)
+[actual typecheck command from package.json scripts]
+
+# Linting (detected from package.json)
+[actual lint command from package.json scripts]
+
+# Tests (detected from package.json)
+[actual test command from package.json scripts]
+\`\`\`
+
+**If ANY check fails, DO NOT mark the story as complete.**
+```
+
+**Section 2: Project-Specific Patterns** (from README/AGENTS.md)
+- Monorepo structure (if applicable)
+- Component locations
+- Test file patterns
+- Database/backend info
+- Styling approach
+
+**Section 3: TDD Workflow** (if tests exist)
+- Test-first workflow
+- Test location patterns
+- Test commands
+
+**Section 4: Common Pitfalls** (from AGENTS.md/docs)
+- Project-specific gotchas
+- Known issues
+- Best practices
+
+**Footer:**
+```markdown
+---
+**Personalized for [Project Name]**
+**Generated:** [date]
+**Re-generate:** /relentless.constitution
+```
+
+Save to: `relentless/prompt.md`
+
+---
+
+## Step 5: Validate & Save
 
 Before saving:
-- No `[PLACEHOLDER]` tokens remain (unless explicitly marked as TODO)
+
+**Constitution:**
+- No `[PLACEHOLDER]` tokens remain
 - All dates in ISO format (YYYY-MM-DD)
 - Principles are declarative and testable
 - Version format is semantic (X.Y.Z)
 
-Save to: `relentless/constitution.md`
+**Prompt:**
+- All quality commands are actual commands from package.json
+- File patterns match project structure
+- No generic placeholders remain
+
+Save both files:
+- `relentless/constitution.md`
+- `relentless/prompt.md`
 
 ---
 
-## Step 4: Report
+## Step 6: Report
 
 Output summary:
-- Constitution version created
-- Number of principles defined
-- Key MUST/SHOULD rules
-- Next steps: "Now create your first feature with `/relentless.specify`"
+```
+✓ Created constitution.md
+  - Version: 1.0.0
+  - Principles: [count]
+  - Key rules: [summary]
+
+✓ Created prompt.md
+  - Quality gates: [count]
+  - Tech stack: [detected stack]
+  - Test framework: [detected]
+
+Next steps:
+1. Review both files
+2. Create your first feature: /relentless.specify "feature description"
+```
 
 ---
 
-## Updating Existing Constitution
+## Updating Existing Files
+
+If `relentless/constitution.md` or `relentless/prompt.md` exist:
 
-If `relentless/constitution.md` exists:
+**For Constitution Updates:**
 1. Load current version
 2. Ask what needs to change
 3. Increment version appropriately:
@@ -101,6 +197,15 @@ If `relentless/constitution.md` exists:
 4. Update `LAST_AMENDED_DATE` to today
 5. Add amendment notes at top
 
+**For Prompt Updates:**
+1. Re-analyze project structure (package.json, docs)
+2. Detect any new quality commands or patterns
+3. Regenerate personalized sections
+4. Preserve any manual customizations in comments
+5. Update "Generated" date
+
+**Both files can be regenerated at any time by running `/relentless.constitution` again.**
+
 ---
 
 ## Example Constitution Structure

package/.claude/skills/implement/SKILL.md

@@ -5,137 +5,238 @@ description: "Execute implementation workflow phase by phase. Use after analysis
 
 # Implementation Workflow Executor
 
-Guide systematic implementation of features using the task breakdown.
+Guide systematic implementation of features using TDD and quality-first approach.
 
 ---
 
 ## The Job
 
-Guide user through implementing tasks in correct order following dependencies.
+Implement user stories one at a time, following strict TDD and updating all tracking files.
 
 ---
 
-## Prerequisites
+## Before You Start
 
-Before starting:
-- `/relentless.analyze` must pass (no CRITICAL issues)
-- All artifacts exist (spec, plan, tasks, checklist)
-- Constitution reviewed
+1. **Read the Constitution** - Review `relentless/constitution.md` for project principles
+2. **Read prompt.md** - Review `relentless/prompt.md` for workflow guidelines
+3. **Read progress.txt** - Check learnings from previous iterations
+4. **Review artifacts** - Ensure spec.md, plan.md, tasks.md, checklist.md exist
+5. **Run `/relentless.analyze`** - Must pass with no CRITICAL issues
 
 ---
 
-## Implementation Flow
+## CRITICAL: Quality Gates (Non-Negotiable)
 
-### Phase 0: Setup
-1. Review `tasks.md` for setup tasks
-2. Install dependencies
-3. Create directory structure
-4. Initialize configuration
+Before marking ANY story as complete, ALL checks must pass:
 
-### Phase 1: Foundation
-1. Implement data models
-2. Create base utilities
-3. Set up infrastructure
-4. Tests for foundation
+```bash
+# TypeScript strict mode check
+bun run typecheck
 
-### Phase 2: User Stories
-For each story in dependency order:
-1. Read story acceptance criteria
-2. Implement functionality
-3. Write tests
-4. Run quality checks (typecheck, lint)
-5. Verify against checklist
-6. Commit changes
-7. Mark story complete in prd.json
+# ESLint with zero warnings policy
+bun run lint
 
-### Phase 3: Polish
-1. Performance optimization
-2. Error handling improvements
-3. Documentation
-4. Final quality checks
+# All tests must pass
+bun test
+```
+
+**If ANY check fails, DO NOT mark the story as complete. Fix the issues first.**
 
 ---
 
-## Per-Story Workflow
+## TDD Workflow (MANDATORY)
 
-```markdown
-**Current:** US-001: Create User Registration Endpoint
+For EVERY story, follow strict Test-Driven Development:
 
-**Acceptance Criteria:**
-- [ ] POST /api/auth/register endpoint exists
-- [ ] Email validation works
-- [ ] Password requirements enforced
-- [ ] Password hashed before storage
-- [ ] Confirmation email sent
-- [ ] Returns 201 with user ID
-- [ ] Returns 400 for invalid input
-- [ ] Typecheck passes
-- [ ] Tests pass
-
-**Checklist Items:**
-- CHK-001: User table created
-- CHK-006: Password hashing uses bcrypt
-- CHK-011: Returns correct status codes
-
-**Steps:**
-1. Create endpoint handler
-2. Implement validation
-3. Add password hashing
-4. Integrate email service
-5. Write unit tests
-6. Write integration tests
-7. Run typecheck
-8. Run tests
-9. Verify checklist items
-10. Commit with message: "feat: US-001 - Create User Registration Endpoint"
+### Step 1: Write Failing Tests First (RED)
+```bash
+# Create test file if needed
+# Write tests that define expected behavior
+bun test  # Tests MUST fail initially
 ```
 
----
+### Step 2: Implement Minimum Code (GREEN)
+```bash
+# Write only enough code to pass tests
+bun test  # Tests MUST pass
+```
 
-## Quality Gates
+### Step 3: Refactor
+```bash
+# Clean up while keeping tests green
+bun test  # Tests MUST still pass
+```
 
-Before marking story complete:
-- [ ] All acceptance criteria checked
-- [ ] Typecheck passes
-- [ ] Linter passes
-- [ ] Tests pass
-- [ ] Relevant checklist items verified
-- [ ] Code committed
+**Do NOT skip TDD. Tests are contracts that validate your implementation.**
 
 ---
 
-## Progress Tracking
+## Per-Story Implementation Flow
+
+For each story (in dependency order):
+
+### 1. Identify the Story
+- Read `prd.json` to find the next story where `passes: false`
+- Check dependencies are met (dependent stories have `passes: true`)
+- Read the story's acceptance criteria
+
+### 2. Find Relevant Checklist Items
+- Open `checklist.md`
+- Find items tagged with `[US-XXX]` for this story
+- Note constitution compliance items `[Constitution]`
 
-Update `progress.txt` after each story:
+### 3. Implement with TDD
+Follow the TDD workflow above for each acceptance criterion.
 
+### 4. Update tasks.md
+As you complete each criterion:
 ```markdown
-## 2026-01-11 - US-001
-- Implemented user registration endpoint
-- Added email validation and password hashing
-- Email service integration working
-- All tests passing
+# Change from:
+- [ ] Criterion text
 
-**Learnings:**
-- Bcrypt cost factor 12 provides good balance
-- Email validation regex from validator.js works well
-- Nodemailer setup straightforward
+# To:
+- [x] Criterion text
+```
+
+### 5. Update checklist.md
+For each verified checklist item:
+```markdown
+# Change from:
+- [ ] CHK-XXX [US-001] Description
+
+# To:
+- [x] CHK-XXX [US-001] Description
+```
+
+### 6. Run Quality Checks
+```bash
+bun run typecheck  # 0 errors required
+bun run lint       # 0 warnings required
+bun test           # All tests must pass
+```
+
+### 7. Commit Changes
+```bash
+git add -A
+git commit -m "feat: US-XXX - Story Title"
+```
+
+### 8. Update prd.json
+Set the story's `passes` field to `true`:
+```json
+{
+  "id": "US-001",
+  "title": "...",
+  "passes": true,  // <- Change from false to true
+  ...
+}
+```
+
+### 9. Update progress.txt
+Append progress entry:
+```markdown
+## [Date] - US-XXX: Story Title
+
+**Implemented:**
+- What was built
+- Key decisions made
 
 **Files Changed:**
-- src/api/auth/register.ts (new)
-- src/services/user.service.ts (new)
-- src/utils/password.ts (new)
-- tests/auth/register.test.ts (new)
+- path/to/file.ts (new/modified)
+
+**Tests Added:**
+- path/to/file.test.ts
+
+**Learnings:**
+- Patterns discovered
+- Gotchas encountered
+
+**Constitution Compliance:**
+- Principle N: How it was followed
+
+---
+```
 
 ---
+
+## Example Per-Story Workflow
+
+```markdown
+**Current:** US-001: Test Infrastructure Setup
+
+**Acceptance Criteria:**
+- [ ] `bun test` command runs successfully
+- [ ] Test files with pattern `*.test.ts` are auto-discovered
+- [ ] `bun test --coverage` shows coverage report
+- [ ] Typecheck passes
+- [ ] Lint passes
+
+**Relevant Checklist Items:**
+- [ ] CHK-001 [US-001] `bun test` command executes successfully
+- [ ] CHK-002 [US-001] Test files with `*.test.ts` pattern are auto-discovered
+- [ ] CHK-007 [Constitution] Tests written BEFORE implementation
+
+**Implementation Steps:**
+1. Write a simple failing test first
+2. Configure bun test runner
+3. Verify test discovery works
+4. Run `bun run typecheck` - must pass
+5. Run `bun run lint` - must pass with 0 warnings
+6. Update tasks.md - check off completed criteria
+7. Update checklist.md - mark verified items
+8. Commit: "feat: US-001 - Test Infrastructure Setup"
+9. Update prd.json: set passes: true
+10. Update progress.txt with learnings
 ```
 
 ---
 
+## File Update Summary
+
+After completing each story, these files MUST be updated:
+
+| File | Update |
+|------|--------|
+| `tasks.md` | Check off `- [x]` completed acceptance criteria |
+| `checklist.md` | Check off `- [x]` verified checklist items |
+| `prd.json` | Set `"passes": true` for the story |
+| `progress.txt` | Append progress entry with learnings |
+
+---
+
+## Implementation Phases
+
+### Phase 0: Setup
+- Infrastructure, tooling, configuration
+- Usually US-001 type stories
+
+### Phase 1: Foundation
+- Data models, types, schemas
+- Base utilities and helpers
+- Core infrastructure
+
+### Phase 2: User Stories
+- Feature implementation
+- Follow dependency order strictly
+
+### Phase 3: Polish
+- E2E tests
+- Documentation
+- Performance optimization
+
+---
+
 ## Notes
 
 - Work on ONE story at a time
-- Follow dependency order
-- Don't skip quality checks
-- Commit frequently
-- Update progress after each story
-- This is a guided workflow, not automated
+- Follow dependency order strictly
+- Never skip TDD - tests come FIRST
+- Never skip quality checks
+- Commit after each story
+- Update ALL tracking files
+- This is a guided workflow for manual implementation
+
+---
+
+*Reference: See `relentless/prompt.md` for additional guidelines*
+*Reference: See `relentless/constitution.md` for project principles*