trinity-method-sdk 2.0.0

package/dist/templates/shared/claude-commands/trinity-plan-investigation.md.template

@@ -0,0 +1,135 @@
+---
+description: Generate AI-powered investigation plans with visualizations
+---
+
+Generate a comprehensive AI-powered investigation plan using the Trinity Method.
+
+**Investigation Planner Process:**
+
+**Step 1: Gather Requirements**
+Ask user:
+- What needs investigation?
+- Known symptoms or issues
+- Affected systems/components
+- Previous investigation attempts
+- Time constraints
+
+**Step 2: Analyze Context**
+- Scan relevant codebase sections
+- Review related investigations
+- Check system dependencies
+- Identify complexity factors
+
+**Step 3: Generate Plan**
+Using InvestigationPlanner, create:
+
+1. **Investigation Strategy**
+   - Recommended approach (breadth-first, depth-first, hybrid)
+   - Key focus areas
+   - Risk assessment
+   - Complexity rating
+
+2. **Phase Breakdown**
+   - Phase 1: Discovery & Analysis
+   - Phase 2: Hypothesis Formation
+   - Phase 3: Testing & Validation
+   - Phase 4: Documentation & Recommendations
+
+3. **Resource Estimates**
+   - Estimated time: X hours
+   - Agent assignments (Aly, AJ, JUNO, etc.)
+   - Tools required
+   - External dependencies
+
+4. **Task Checklist**
+   - [ ] Analyze entry points
+   - [ ] Map data flow
+   - [ ] Identify edge cases
+   - [ ] Test hypotheses
+   - [ ] Document findings
+
+**Step 4: Generate Visualizations**
+Create Mermaid diagrams:
+
+```mermaid
+graph TD
+    A[Start Investigation] --> B[Analyze Codebase]
+    B --> C[Form Hypotheses]
+    C --> D[Test Scenarios]
+    D --> E{Issue Found?}
+    E -->|Yes| F[Document Solution]
+    E -->|No| C
+    F --> G[End Investigation]
+```
+
+**Step 5: Risk & Dependency Analysis**
+- Potential blockers
+- Required permissions/access
+- Integration points
+- Rollback considerations
+
+**Output:**
+Save investigation plan to:
+`trinity/investigations/plans/PLAN-{investigation-title}.md`
+
+**Plan Includes:**
+- Executive summary
+- Detailed phase breakdown
+- Mermaid diagrams (flowchart, sequence, timeline)
+- Resource allocation
+- Success criteria
+- Contingency plans
+
+**Interactive Options:**
+- Modify plan sections
+- Add custom phases
+- Assign specific agents
+- Create investigation from plan
+- Export plan to JSON
+
+---
+
+## When to Use: /trinity-plan-investigation vs /trinity-create-investigation
+
+### /trinity-create-investigation
+**Use when**: Starting a new investigation from scratch
+
+**What it does**:
+- Creates new INV-XXX file
+- Sets up investigation structure
+- Defines research questions
+- Establishes scope
+
+**Example**: "Investigate why API is slow" → Creates INV-015-api-performance-analysis.md
+
+### /trinity-plan-investigation
+**Use when**: Investigation already exists, need execution plan
+
+**What it does**:
+- Reads existing INV-XXX file
+- Creates research methodology
+- Generates data collection plan
+- Defines success criteria
+- Produces step-by-step investigation tasks
+
+**Example**: "Plan how to execute INV-015" → Creates detailed investigation plan with 8 research tasks
+
+### Workflow
+
+```
+1. /trinity-create-investigation
+   → Creates INV-XXX-problem.md
+   
+2. /trinity-plan-investigation
+   → Reads INV-XXX-problem.md
+   → Creates investigation-plan-XXX.md
+   
+3. Execute investigation
+   → Follow plan
+   → Document findings
+   
+4. Archive results
+   → Update INV-XXX with conclusions
+```
+
+---

package/dist/templates/shared/claude-commands/trinity-plan.md.template

@@ -0,0 +1,201 @@
+---
+description: Create implementation plan using TRA (Work Planner)
+---
+
+# Trinity Work Planning - TRA
+
+**Agent:** TRA (Work Planner)
+**Role:** Implementation sequencing, BAS quality gates, and timeline estimation
+
+## What TRA Does
+
+1. **Implementation Sequencing:**
+   - Determines optimal task order
+   - Identifies dependencies
+   - Plans for parallelization opportunities
+
+2. **BAS Quality Gate Integration:**
+   - **Phase 1:** Linting (auto-fix enabled)
+   - **Phase 2:** Structure validation
+   - **Phase 3:** Build validation
+   - **Phase 4:** Testing (all tests pass)
+   - **Phase 5:** Coverage check (≥80%)
+   - **Phase 6:** Final review (best practices)
+
+3. **Timeline Estimation:**
+   - Task complexity scoring
+   - Dependency chains
+   - Realistic time estimates
+
+4. **Stop Points (Scale-Based):**
+   - Small: 0 stop points
+   - Medium: 2 stop points (design, final)
+   - Large: 4 stop points (requirements, design, plan, final)
+
+## Output Format
+
+TRA produces structured JSON handoff:
+```json
+{
+  "tasks": [
+    {
+      "id": 1,
+      "description": "task description",
+      "dependencies": [],
+      "estimatedTime": "30min",
+      "basGates": ["lint", "build", "test", "coverage"]
+    }
+  ],
+  "sequence": [1, 2, 3],
+  "parallelizable": [[4, 5]],
+  "stopPoints": ["design", "final"],
+  "totalEstimate": "2 hours"
+}
+```
+
+## Integration with Trinity Workflow
+
+TRA's strategic planning bridges design and implementation:
+
+**TRA's Planning Role:**
+- Requirements breakdown into implementation phases
+- 3-phase implementation structure (Setup → Core → Finalize)
+- High-level task identification with dependencies
+- Risk assessment and mitigation strategies
+- Resource allocation and timeline estimation
+- BAS quality gate integration points
+
+**Workflow Context:**
+
+1. **After ROR:** Technical design complete with function signatures
+2. **TRA Planning (Claude adopts TRA persona):** Creates strategic implementation plan
+3. **Plan Output:** JSON handoff with tasks, sequence, stop points, time estimates
+4. **Handoff to EUS:** Strategic plan feeds into atomic task decomposition
+
+**See Also:** `/trinity-orchestrate` for complete workflow planning guidance
+
+## Usage
+
+**Provide design and Claude (as TRA) will create implementation plan:**
+
+What is the technical design? (Or provide ROR's output)
+
+**For complete workflow planning:**
+
+Use `/trinity-orchestrate` to plan your implementation approach with TRA as a key planning phase
+
+## Related Commands
+
+- `/trinity-orchestrate` - Complete workflow planning guidance
+- `/trinity-design` - ROR technical design (input to TRA)
+- `/trinity-decompose` - EUS atomic task decomposition (follows TRA)
+
+---
+
+## Complexity Scoring Guide
+
+Rate each task on complexity (1-10 scale):
+
+### Scoring Criteria
+
+**1-3 (Low)**:
+- Simple CRUD operations
+- Configuration changes
+- Documentation updates
+- Straightforward refactoring
+
+**4-6 (Medium)**:
+- Business logic implementation
+- API integrations
+- Database migrations
+- Multi-step workflows
+
+**7-10 (High)**:
+- Complex algorithms
+- Security-critical features
+- Performance optimization
+- Large-scale refactoring
+
+### Complexity Factors
+
+Add +1-2 points for each:
+- External dependencies (APIs, services)
+- Security requirements (auth, payments, PII)
+- Performance requirements (<100ms, high throughput)
+- Complex state management
+- Cross-cutting concerns
+
+**Example**:
+- "Add user field" = 2 (Low)
+- "JWT refresh tokens" = 6 (Medium: auth + API + security)
+- "Real-time notification system" = 9 (High: WebSockets + state + performance)
+
+---
+
+## Task Parallelization
+
+### Identifying Parallel Tasks
+
+Tasks can run in parallel if:
+- ✅ No shared file modifications
+- ✅ No data dependencies
+- ✅ Independent test suites
+
+Tasks must be sequential if:
+- ❌ One modifies file that other reads
+- ❌ One creates interface that other implements
+- ❌ One's output is other's input
+
+### Parallelization Examples
+
+**Example 1: Authentication Module**
+
+Sequential (WRONG):
+```
+1. Create auth service → 2 hours
+2. Create auth middleware → 1 hour  
+3. Add types → 30 min
+4. Write tests → 2 hours
+Total: 5.5 hours
+```
+
+Parallel (CORRECT):
+```
+Phase 1 (Parallel):
+- Create auth service (2 hours)
+- Create auth middleware (1 hour)
+- Add types (30 min)
+Bottleneck: 2 hours
+
+Phase 2 (Parallel):
+- Test auth service (1 hour)
+- Test auth middleware (1 hour)
+Bottleneck: 1 hour
+
+Total: 3 hours (42% faster)
+```
+
+**Example 2: API Endpoints**
+
+```
+Parallel Tasks (no dependencies):
+├─ POST /users endpoint (1 hour)
+├─ GET /users/:id endpoint (45 min)
+├─ PUT /users/:id endpoint (1 hour)
+└─ DELETE /users/:id endpoint (45 min)
+
+Bottleneck: 1 hour (vs 3.5 hours sequential)
+Speedup: 71%
+```
+
+**Dependencies Require Sequencing**:
+```
+1. Create User model (must finish first)
+   ↓
+2. Parallel tasks can start:
+   ├─ UserService (uses model)
+   ├─ UserController (uses model)
+   └─ User validation (uses model)
+```
+
+---