vibe-fabric 0.3.2 → 0.3.3

package/.claude/prompts/scope/task-analyze-prd.md

@@ -0,0 +1,125 @@
+# Task: Analyze PRD Requirements
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {OUTPUT_FILE} | Path to write the task output | Yes |
+| {MODULES} | JSON array of module names to analyze | Yes |
+
+---
+
+## Context
+
+You are analyzing PRD requirements to prepare for scope creation.
+
+Project: {PROJECT_PATH}
+Modules to analyze: {MODULES}
+
+---
+
+## Your Task
+
+Analyze requirements and categorize them by priority and scope-readiness.
+
+### Step 1: Read All Requirements
+
+Read all requirement files in:
+- `docs/prd/modules/*/` - All module requirements
+
+For each requirement, extract:
+- ID (e.g., REQ-AUTH-001)
+- Title
+- Module
+- Status (draft, in-progress, implemented)
+- Priority (P1, P2, P3)
+- Dependencies on other requirements
+
+### Step 2: Check Existing Scopes
+
+Read all scope files:
+- `docs/scopes/drafts/`
+- `docs/scopes/ready/`
+- `docs/scopes/sent/`
+- `docs/scopes/completed/`
+
+Identify which requirements are already covered by scopes.
+
+### Step 3: Categorize Requirements
+
+Group requirements into:
+1. **Ready to scope** - Not covered, no blocking dependencies
+2. **Blocked** - Has unscoped dependencies
+3. **Already scoped** - Covered by existing scope
+4. **Implemented** - Status is implemented
+
+### Step 4: Prioritize
+
+Order ready-to-scope requirements by:
+1. Priority (P1 first)
+2. Dependency order (dependencies before dependents)
+3. Module grouping (related requirements together)
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "analysis": {
+    "total_requirements": 23,
+    "ready_to_scope": 12,
+    "blocked": 3,
+    "already_scoped": 5,
+    "implemented": 3
+  },
+  "by_module": {
+    "auth": {
+      "total": 5,
+      "ready": 3,
+      "blocked": 0,
+      "scoped": 1,
+      "implemented": 1
+    }
+  },
+  "ready_to_scope": [
+    {
+      "id": "REQ-AUTH-001",
+      "title": "User Login",
+      "module": "auth",
+      "priority": "P1",
+      "dependencies": [],
+      "suggested_scope": "User authentication and session management"
+    }
+  ],
+  "blocked": [
+    {
+      "id": "REQ-PAY-003",
+      "title": "Refund Processing",
+      "blocked_by": ["REQ-PAY-001", "REQ-PAY-002"],
+      "reason": "Depends on payment processing which is not scoped"
+    }
+  ],
+  "scope_suggestions": [
+    {
+      "name": "User Authentication",
+      "requirements": ["REQ-AUTH-001", "REQ-AUTH-002", "REQ-AUTH-003"],
+      "rationale": "These requirements form a cohesive authentication feature"
+    }
+  ]
+}
+```
+
+---
+
+## Rules
+
+- Do NOT modify any files
+- Do NOT interact with the user
+- ONLY output to {OUTPUT_FILE}
+- Group related requirements that should be in the same scope
+- Consider dependencies when suggesting scopes
+- A good scope has 3-8 requirements

package/.claude/prompts/scope/task-check-deps.md

@@ -0,0 +1,188 @@
+# Task: Check Scope Dependencies
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {OUTPUT_FILE} | Path to write the task output | Yes |
+| {PREVIOUS_OUTPUTS} | JSON array of previous task output paths | Yes |
+
+---
+
+## Context
+
+You are checking dependency ordering for scopes.
+
+Project: {PROJECT_PATH}
+
+---
+
+## Your Task
+
+Analyze scope dependencies and determine correct ordering. This is NON-INTERACTIVE.
+
+### Step 1: Load All Scopes
+
+Read all scopes from:
+- `docs/scopes/drafts/`
+- `docs/scopes/ready/`
+- `docs/scopes/sent/`
+- `docs/scopes/completed/`
+
+Also check {PREVIOUS_OUTPUTS} for newly created scopes.
+
+### Step 2: Extract Dependencies
+
+For each scope, find:
+- Scope ID
+- Status
+- Dependencies (other scopes it depends on)
+- Whether dependencies are blocking
+
+### Step 3: Build Dependency Graph
+
+Create a dependency graph:
+- Nodes: All scopes
+- Edges: Dependency relationships
+- Direction: From dependent to dependency
+
+### Step 4: Detect Issues
+
+Check for:
+- **Circular dependencies**: A depends on B, B depends on A
+- **Missing dependencies**: References non-existent scope
+- **Blocked scopes**: Dependencies not completed
+- **Order violations**: Dependent scope sent before dependency
+
+### Step 5: Calculate Order
+
+Determine the recommended implementation order:
+1. Scopes with no dependencies first
+2. Then scopes whose dependencies are completed
+3. Flag blocked scopes
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "analysis": {
+    "total_scopes": 8,
+    "with_dependencies": 5,
+    "blocked": 2,
+    "circular_dependencies": 0
+  },
+  "dependency_graph": {
+    "SCOPE-001": {
+      "status": "completed",
+      "depends_on": [],
+      "depended_by": ["SCOPE-002", "SCOPE-003"]
+    },
+    "SCOPE-002": {
+      "status": "sent",
+      "depends_on": ["SCOPE-001"],
+      "depended_by": ["SCOPE-004"]
+    },
+    "SCOPE-003": {
+      "status": "draft",
+      "depends_on": ["SCOPE-001"],
+      "depended_by": []
+    },
+    "SCOPE-004": {
+      "status": "draft",
+      "depends_on": ["SCOPE-002"],
+      "depended_by": []
+    }
+  },
+  "recommended_order": [
+    {
+      "order": 1,
+      "scope_id": "SCOPE-003",
+      "title": "Password Reset",
+      "status": "draft",
+      "reason": "Dependency SCOPE-001 is completed"
+    },
+    {
+      "order": 2,
+      "scope_id": "SCOPE-004",
+      "title": "User Profile",
+      "status": "draft",
+      "reason": "Blocked until SCOPE-002 completes"
+    }
+  ],
+  "issues": [
+    {
+      "type": "blocked",
+      "scope_id": "SCOPE-004",
+      "blocked_by": "SCOPE-002",
+      "message": "SCOPE-004 depends on SCOPE-002 which is still in 'sent' status"
+    }
+  ],
+  "warnings": [],
+  "ready_to_send": ["SCOPE-003"]
+}
+```
+
+For circular dependency:
+
+```json
+{
+  "issues": [
+    {
+      "type": "circular",
+      "scopes": ["SCOPE-005", "SCOPE-006"],
+      "message": "Circular dependency: SCOPE-005 depends on SCOPE-006, which depends on SCOPE-005"
+    }
+  ]
+}
+```
+
+---
+
+## Rules
+
+- Do NOT modify any files
+- Do NOT interact with the user
+- ONLY output to {OUTPUT_FILE}
+- Consider only blocking dependencies for order
+- Non-blocking dependencies are informational
+- Completed scopes should not appear in recommended_order
+
+---
+
+## Dependency Status Logic
+
+```
+If dependency.status == "completed":
+    dependent can proceed
+
+If dependency.status == "sent" or "in-progress":
+    dependent is blocked (waiting)
+
+If dependency.status == "draft" or "ready":
+    dependent is blocked (dependency not started)
+
+If dependency does not exist:
+    error: missing dependency
+```
+
+---
+
+## Order Calculation
+
+Topological sort based on:
+1. Dependencies resolved
+2. Priority (P1 before P2 before P3)
+3. Complexity (S before M before L)
+
+Example:
+```
+SCOPE-001 (no deps, P1) -> Order 1
+SCOPE-002 (depends on 001, P1) -> Order 2
+SCOPE-003 (depends on 001, P2) -> Order 3
+SCOPE-004 (depends on 002, P1) -> Order 4
+```

package/.claude/prompts/scope/task-create-scope.md

@@ -0,0 +1,207 @@
+# Task: Create Scope (Interactive)
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {OUTPUT_FILE} | Path to write the task output | Yes |
+| {FEATURE} | Feature name for the scope | Yes |
+| {REQUIREMENTS} | JSON array of requirement IDs | Yes |
+| {SUGGESTED_ID} | Suggested scope ID (e.g., SCOPE-003) | Yes |
+| {PREVIOUS_OUTPUTS} | JSON array of previous task output paths | Yes |
+
+---
+
+## Context
+
+You are creating a new scope through conversation with the user.
+
+Project: {PROJECT_PATH}
+Feature: {FEATURE}
+Requirements: {REQUIREMENTS}
+Suggested ID: {SUGGESTED_ID}
+
+---
+
+## Your Task
+
+Create a scope through Q&A with the user. This is an INTERACTIVE task.
+
+### Step 1: Load Previous Work
+
+Read the recommendation from {PREVIOUS_OUTPUTS} if available.
+
+### Step 2: Present Draft
+
+Show the user the recommended scope structure:
+
+```
+Creating scope for: {FEATURE}
+
+Based on PRD analysis, here's the recommended scope:
+
+  ID:         {SUGGESTED_ID}
+  Title:      [Recommended title]
+  Target:     [backend/frontend/both]
+  Complexity: [S/M/L]
+  Priority:   [P1/P2/P3]
+
+  Summary:
+    [2-3 sentence summary]
+
+  User Story:
+    As a [role],
+    I want to [action],
+    so that [benefit].
+
+  Requirements (from PRD):
+    - REQ-XXX-001: [Title]
+    - REQ-XXX-002: [Title]
+
+  Acceptance Criteria:
+    - AC-1: Given [...], when [...], then [...]
+    - AC-2: Given [...], when [...], then [...]
+
+Does this look right? What would you like to change?
+```
+
+### Step 3: Refine Through Conversation
+
+Ask clarifying questions:
+
+1. **Target**: "Should this be implemented in backend, frontend, or both?"
+2. **Scope boundaries**: "Should we include [related requirement] in this scope?"
+3. **Acceptance criteria**: "Are there any edge cases or error scenarios to add?"
+4. **Dependencies**: "Does this depend on any other scopes being completed first?"
+5. **Out of scope**: "What should we explicitly exclude?"
+
+### Step 4: Capture User Decisions
+
+Update the scope based on user feedback:
+- Add/remove requirements
+- Adjust acceptance criteria
+- Update target or complexity
+- Add constraints or notes
+
+### Step 5: Confirm Final Scope
+
+Present the final scope for confirmation:
+
+```
+Final scope to create:
+
+  SCOPE-003: User Authentication
+  ================================
+
+  [Full scope content in template format]
+
+Ready to save this scope? (Yes/No/Edit more)
+```
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "action": "create",
+  "scope": {
+    "id": "SCOPE-003",
+    "title": "User Authentication",
+    "status": "draft",
+    "target": "backend",
+    "complexity": "M",
+    "module": "auth",
+    "priority": "P1",
+    "summary": "Implement JWT-based authentication...",
+    "user_story": {
+      "role": "registered user",
+      "action": "log in with my email and password",
+      "benefit": "I can access my personal data securely"
+    },
+    "requirements": {
+      "functional": [
+        {"id": "REQ-1", "text": "POST /auth/login accepts email/password"},
+        {"id": "REQ-2", "text": "Returns JWT token on success"}
+      ],
+      "non_functional": [
+        {"id": "NFR-1", "text": "Response time under 200ms"}
+      ]
+    },
+    "acceptance_criteria": [
+      {
+        "id": "AC-1",
+        "given": "valid email and password",
+        "when": "user submits POST /auth/login",
+        "then": "return 200 with JWT token"
+      }
+    ],
+    "constraints": [
+      {"id": "C-1", "text": "Must use bcrypt for password hashing"}
+    ],
+    "dependencies": [
+      {"scope": "SCOPE-001", "reason": "Needs user schema", "blocking": true}
+    ],
+    "out_of_scope": [
+      "Password reset (SCOPE-004)",
+      "Social login (future)"
+    ],
+    "implementation_notes": {
+      "approach": "Use existing auth middleware pattern",
+      "key_files": ["src/auth/", "src/middleware/"]
+    },
+    "prd_requirements": ["REQ-AUTH-001", "REQ-AUTH-002", "REQ-AUTH-003"]
+  },
+  "file_path": "docs/scopes/drafts/SCOPE-003-user-authentication.md"
+}
+```
+
+---
+
+## Rules
+
+- This is INTERACTIVE - engage with the user
+- Start with recommendations from previous analysis
+- Let user override any suggestion
+- Ensure Given/When/Then format for acceptance criteria
+- Validate scope has at least 1 requirement and 1 AC
+- Generate appropriate file name from title (kebab-case)
+- Include PRD requirement IDs in prd_requirements field
+
+---
+
+## Conversation Style
+
+Be helpful and collaborative:
+
+```
+> Based on the PRD, I recommend including REQ-AUTH-001 (Login) and
+> REQ-AUTH-002 (JWT tokens) in this scope. They're tightly coupled
+> and should be delivered together.
+>
+> Should we also include REQ-AUTH-003 (Password validation)?
+> It's related but could be a separate scope if you prefer.
+```
+
+Ask follow-up questions:
+
+```
+> For the acceptance criteria, I've drafted 5 scenarios covering
+> successful login, invalid credentials, and token refresh.
+>
+> Are there any edge cases you'd like to add? For example:
+> - Account lockout after failed attempts?
+> - Rate limiting?
+```
+
+Confirm decisions:
+
+```
+> Got it! I'll mark password reset as out of scope and add a note
+> that it will be handled in a future scope.
+>
+> Anything else to adjust before we finalize?
+```

package/.claude/prompts/scope/task-recommend.md

@@ -0,0 +1,146 @@
+# Task: Recommend Scope Boundaries
+
+## Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| {PROJECT_PATH} | Path to the project directory | Yes |
+| {OUTPUT_FILE} | Path to write the task output | Yes |
+| {TARGET_FEATURE} | Feature name to create scope for | Yes |
+| {REQUIREMENTS} | JSON array of requirement IDs to include | Yes |
+| {PREVIOUS_OUTPUTS} | JSON array of previous task output paths | Yes |
+
+---
+
+## Context
+
+You are recommending scope boundaries based on PRD analysis.
+
+Project: {PROJECT_PATH}
+Target feature: {TARGET_FEATURE}
+Requirements: {REQUIREMENTS}
+
+---
+
+## Your Task
+
+Create a recommended scope structure with suggested content.
+
+### Step 1: Read Previous Analysis
+
+Load the analysis from previous tasks in {PREVIOUS_OUTPUTS}.
+
+### Step 2: Read Requirement Details
+
+For each requirement in {REQUIREMENTS}, read the full content from PRD files.
+
+### Step 3: Determine Scope Attributes
+
+Based on requirements, determine:
+
+**Target Repository:**
+- `backend` - Server-side work (APIs, database, business logic)
+- `frontend` - Client-side work (UI, components, state management)
+- `both` - Requires work in both repos
+
+**Complexity:**
+- `S` - Small, a few hours
+- `M` - Medium, 1-2 days
+- `L` - Large, 3-5 days
+- `XL` - Extra large, consider splitting
+
+**Priority:**
+- Inherit from highest priority requirement
+
+### Step 4: Draft Scope Content
+
+Create a draft of:
+- Summary (2-3 sentences)
+- User story
+- Acceptance criteria (from requirements)
+- Technical constraints
+- Dependencies on other scopes
+- Out of scope items
+
+---
+
+## Output Format
+
+Write to: {OUTPUT_FILE}
+
+```json
+{
+  "scope_id": "SCOPE-003",
+  "title": "User Authentication",
+  "target": "backend",
+  "complexity": "M",
+  "priority": "P1",
+  "module": "auth",
+  "summary": "Implement JWT-based authentication with login, logout, and token refresh endpoints. Users authenticate with email/password and receive secure tokens for API access.",
+  "user_story": {
+    "role": "registered user",
+    "action": "log in with my email and password",
+    "benefit": "I can access my personal data and features securely"
+  },
+  "requirements": [
+    {
+      "id": "REQ-AUTH-001",
+      "title": "User Login",
+      "original_text": "Users can log in with email and password"
+    },
+    {
+      "id": "REQ-AUTH-002",
+      "title": "JWT Tokens",
+      "original_text": "System issues JWT tokens on successful login"
+    }
+  ],
+  "acceptance_criteria": [
+    {
+      "id": "AC-1",
+      "given": "valid email and password",
+      "when": "user submits login form",
+      "then": "system returns JWT token and 200 status"
+    },
+    {
+      "id": "AC-2",
+      "given": "invalid credentials",
+      "when": "user submits login form",
+      "then": "system returns 401 with error message"
+    }
+  ],
+  "technical_constraints": [
+    "Must use bcrypt for password hashing",
+    "JWT expiration: 24 hours"
+  ],
+  "dependencies": [
+    {
+      "scope_id": "SCOPE-001",
+      "reason": "Requires user database schema",
+      "blocking": true
+    }
+  ],
+  "out_of_scope": [
+    "Password reset flow (SCOPE-004)",
+    "Social login (future)",
+    "Multi-factor authentication (future)"
+  ],
+  "implementation_notes": {
+    "suggested_approach": "Implement using existing auth middleware pattern",
+    "key_files": ["src/auth/", "src/middleware/"]
+  },
+  "estimated_acs": 8,
+  "rationale": "These requirements form a cohesive authentication feature. Login and JWT handling are tightly coupled and should be delivered together."
+}
+```
+
+---
+
+## Rules
+
+- Do NOT modify any files
+- Do NOT interact with the user
+- ONLY output to {OUTPUT_FILE}
+- Generate acceptance criteria in Given/When/Then format
+- Include error scenarios in acceptance criteria
+- Keep scope focused (3-8 requirements)
+- Identify blocking dependencies