trinity-method-sdk 2.0.0

package/dist/templates/trinity/CLAUDE.md.template

@@ -0,0 +1,372 @@
+# CLAUDE.md - Trinity Method Enforcement
+## {{PROJECT_NAME}} - Trinity Protocols
+
+**Framework:** {{FRAMEWORK}}
+**Trinity Version:** {{TRINITY_VERSION}}
+**Source Directory:** {{SOURCE_DIR}}
+
+---
+
+## Trinity Method Core Principles
+
+### The Fundamental Law
+**"No updates without investigation. No changes without Trinity consensus. No shortcuts without consequences."**
+
+### Investigation-First Requirements
+- **Mandatory Investigation**: Every code change, feature addition, or bug fix must begin with thorough investigation
+- **Evidence-Based Decisions**: All implementation decisions backed by documented evidence
+- **Pattern Recognition**: Leverage existing patterns and solutions from knowledge base
+- **Quality Gates**: No code moves forward without passing all Trinity quality standards
+
+### ⚠️ CRITICAL: Investigation vs Implementation Protocol
+
+**INVESTIGATIONS ARE READ-ONLY:**
+- Investigations analyze, document, and report findings ONLY
+- **NO file modifications** during investigations
+- **NO code implementations** during investigations
+- **NO fixes applied** during investigations
+
+**IMPLEMENTATIONS ARE SEPARATE:**
+- Implementation happens ONLY after investigation is complete
+- Implementation requires explicit user approval
+- User must explicitly request implementation based on investigation findings
+- Never assume investigation = permission to implement
+
+---
+
+## Session Workflow Protocols
+
+### Session Initialization
+```markdown
+## Required Steps at Session Start:
+1. Load project context from ../CLAUDE.md
+2. Review outstanding tasks in knowledge-base/To-do.md
+3. Check system health and performance metrics
+4. Update dependencies if needed
+5. Verify integrity checks
+6. Initialize debugging frameworks
+7. Load Trinity knowledge base patterns
+```
+
+### Session Completion
+```markdown
+## Required Steps at Session End:
+1. Document all changes in knowledge-base/ARCHITECTURE.md
+2. Update knowledge-base/To-do.md with completed/new items
+3. Record new issues and patterns in knowledge-base/ISSUES.md
+4. Plan next session requirements
+5. Update performance metrics
+6. Archive session artifacts to sessions/
+7. Update Technical-Debt.md with any new debt identified
+```
+
+### Session Artifacts Management
+```yaml
+Session Artifacts:
+  Location: trinity/sessions/[YYYY-MM-DD]-[HHMMSS]/
+  Required Files:
+    - SESSION-SUMMARY.md         # Session overview and accomplishments
+    - investigation-summary.md   # What was investigated
+    - patterns-discovered.md     # New patterns found
+    - issues-resolved.md         # Problems solved
+    - performance-report.md      # Metrics and baselines
+    - next-session-plan.md       # Planning for continuation
+```
+
+---
+
+## Crisis Management Protocols
+
+### Console Error Crisis Protocol
+```markdown
+## Immediate Response for Console Errors:
+1. STOP all development activity
+2. Capture complete error stack trace
+3. Investigate root cause using Trinity Method
+4. Document error pattern in knowledge-base/ISSUES.md
+5. Implement comprehensive debugging
+6. Verify fix with extensive testing
+7. Update error prevention measures
+8. Resume development only after verification
+```
+
+### Performance Crisis Protocol
+```markdown
+## Response for Performance Degradation:
+1. Measure current performance metrics
+2. Compare against established baselines in ../CLAUDE.md
+3. Identify performance bottlenecks
+4. Investigate using Trinity methodology
+5. Implement targeted optimizations
+6. Validate improvements with metrics
+7. Update performance baselines
+8. Document optimization patterns
+```
+
+### Data Integrity Crisis Protocol
+```markdown
+## Response for Data Inconsistencies:
+1. Immediately assess data corruption scope
+2. Audit all data sources and relationships
+3. Identify inconsistencies
+4. Backup current state before changes
+5. Restore data integrity systematically
+6. Verify data accuracy across all systems
+7. Implement additional integrity checks
+8. Document data recovery procedures
+```
+
+### Framework-Specific Crisis Protocol
+```markdown
+## Response for Framework Failures:
+1. Check framework version compatibility
+2. Analyze API rate limits and quotas
+3. Review recent framework updates
+4. Investigate connection and authentication
+5. Verify external service dependencies
+6. Implement fallback mechanisms
+7. Test all functionality end-to-end
+8. Monitor for recurring issues
+```
+
+---
+
+## Quality Standards & Checklists
+
+### Pre-Commit Quality Checklist
+```markdown
+## Mandatory Checks Before Any Commit:
+- [ ] Trinity investigation completed and documented
+- [ ] All tests passing (unit, integration, end-to-end)
+- [ ] Debugging statements implemented and verified
+- [ ] Performance standards met or exceeded
+- [ ] Zero console errors in development/production
+- [ ] User experience audit passed (if applicable)
+- [ ] Data integrity verified
+- [ ] Framework-specific functionality tested
+- [ ] Security review completed
+- [ ] Documentation updated and synchronized
+```
+
+### Code Quality Requirements
+```javascript
+// Mandatory debugging format for all critical functions
+const debugLog = (functionName, context, data) => {
+    console.log(`[TRINITY] ${functionName}`, {
+        timestamp: Date.now(),
+        context: context,
+        data: data,
+        framework: '{{FRAMEWORK}}',
+        session: process.env.SESSION_ID || 'unknown'
+    });
+};
+
+// Example implementation
+function criticalOperation(params) {
+    debugLog('criticalOperation', 'ENTRY', {
+        params: params,
+        source: '{{SOURCE_DIR}}'
+    });
+
+    // Function implementation...
+
+    debugLog('criticalOperation', 'EXIT', {
+        result: 'success',
+        responseTime: Date.now() - startTime
+    });
+}
+```
+
+### Trinity Method Investigation Standards
+```markdown
+## Investigation Requirements:
+1. **Scope Definition**: Clearly define what needs investigation
+2. **Time Boxing**: Set maximum investigation time (default: 2 hours)
+3. **Evidence Collection**: Gather all relevant data and patterns
+4. **Pattern Analysis**: Check existing solutions in knowledge-base/
+5. **Root Cause Analysis**: Identify underlying causes, not symptoms
+6. **Solution Documentation**: Document all findings in investigations/
+7. **Implementation Planning**: Create detailed implementation plan
+8. **Risk Assessment**: Identify potential complications and mitigations
+```
+
+---
+
+## Success Metrics Tracking
+
+### Trinity Performance Indicators
+```javascript
+const trinityMetrics = {
+    // Investigation Metrics
+    investigationSuccessRate: 0,      // % of investigations leading to successful solutions
+    investigationTimeEfficiency: 0,   // Average investigation time vs planned time
+    investigationScopeControl: 0,     // % of investigations staying within scope
+
+    // Quality Metrics
+    issuesPreventedByPatterns: 0,     // Issues caught by existing patterns
+    knowledgeReuseRate: 0,            // % of solutions reused from knowledge base
+    qualityGatePassRate: 0,           // % of commits passing all quality gates
+
+    // Crisis Metrics
+    crisisProtocolActivations: 0,     // Number of crisis protocols triggered
+    crisisResolutionTime: 0,          // Average time to resolve crises
+    preventativeMeasuresEffective: 0, // % of issues prevented by measures
+
+    // Framework Specific
+    frameworkUptimePercentage: 0,     // Framework availability metrics
+    functionalitySuccessRate: 0,      // % of features working correctly
+    apiErrorRate: 0,                  // External API error frequency
+
+    // Development Efficiency
+    sessionProductivity: 0,           // Features/fixes per session
+    documentationSyncRate: 0,         // % of code changes with docs
+    crossSessionKnowledgeTransfer: 0  // Knowledge retention between sessions
+};
+```
+
+### Metric Collection Requirements
+- Metrics collected at start/end of each session
+- Weekly metric review and trend analysis
+- Automated alerts for metric degradation
+- Monthly metric reporting and process improvement
+
+---
+
+## Cross-Session Knowledge Structure
+
+### Knowledge Persistence Framework
+```yaml
+Knowledge Base Structure:
+  trinity/knowledge-base/
+    - ISSUES.md              # Common problems and solutions
+    - Trinity.md             # Trinity Method project guide
+    - ARCHITECTURE.md        # System architecture documentation
+    - Technical-Debt.md      # Technical debt tracking
+    - To-do.md               # Task tracking and planning
+
+  trinity/sessions/
+    - [YYYY-MM-DD]-[HHMMSS]/  # Session artifacts
+      - SESSION-SUMMARY.md
+      - investigation-summary.md
+      - patterns-discovered.md
+      - issues-resolved.md
+      - performance-report.md
+
+  trinity/investigations/
+    - [investigation-name]/    # Investigation work products
+
+  trinity/patterns/
+    - [pattern-name].md        # Reusable solution patterns
+
+  trinity/work-orders/
+    - WORKORDER-XXX.md         # Active work orders
+```
+
+### Knowledge Transfer Protocols
+- Session handoffs must include knowledge summary
+- All discoveries added to appropriate knowledge base files
+- Pattern extraction and generalization required
+- Cross-reference related knowledge base entries
+
+---
+
+## Trinity Method Commands
+
+### Investigation Commands
+```bash
+# Start Trinity Investigation
+Begin Trinity Method investigation for [feature/bug/task]
+
+# Complete Investigation
+Finalize investigation with implementation plan
+
+# Scope Control
+Set investigation time limit: [X hours]
+Check investigation scope boundaries
+```
+
+### Quality Enforcement Commands
+```bash
+# Quality Gates
+Execute pre-commit checklist
+Verify Trinity quality standards
+Run comprehensive test suite
+Validate performance baselines
+```
+
+### Crisis Management Commands
+```bash
+# Crisis Response
+Execute Console Error Crisis Protocol
+Execute Performance Crisis Protocol
+Execute Data Integrity Crisis Protocol
+Execute Framework Crisis Protocol
+```
+
+---
+
+## Technology-Specific Adaptations
+
+### {{FRAMEWORK}} Integration
+- Trinity Method protocols adapt to {{FRAMEWORK}} architecture
+- Framework-specific debugging and monitoring standards
+- Performance optimization for {{FRAMEWORK}} runtime
+- Security protocols for {{FRAMEWORK}} applications
+- Refer to {{SOURCE_DIR}}/CLAUDE.md for detailed framework guidance
+
+### Framework Compliance
+- All Trinity protocols adapt to project's tech stack
+- Data integrity crucial for application state management
+- Performance monitoring for framework-specific operations
+- Security protocols for framework-specific vulnerabilities
+
+---
+
+## Context Hierarchy
+
+### Hierarchical Context Loading
+```
+1. ../CLAUDE.md              → Global project context (load FIRST)
+2. trinity/CLAUDE.md (this file) → Trinity Method enforcement (load SECOND)
+3. ../{{SOURCE_DIR}}/CLAUDE.md   → Technology-specific rules (load THIRD)
+```
+
+### Context Priority Rules
+- **Global context** provides project overview, performance baselines, team standards
+- **Trinity context** enforces investigation workflow, quality gates, session protocols
+- **Source context** provides technology-specific debugging, patterns, and conventions
+- When conflicts arise, **Trinity context takes precedence** for workflow enforcement
+
+---
+
+## Reference to Parent Context
+
+This file extends and enforces the global requirements defined in `../CLAUDE.md`. All Trinity Method protocols must comply with:
+- Global performance baselines
+- Project-wide behavioral requirements
+- Technology stack specifications
+- Quality gate requirements
+
+For technology-specific implementation details, see: `../src/CLAUDE.md`
+
+---
+
+## Context Hierarchy
+
+This file enforces Trinity Method protocols for all development work.
+
+**Parent Context**: [../CLAUDE.md](../CLAUDE.md) - Project overview and global requirements
+**Child Context**: [../src/CLAUDE.md](../src/CLAUDE.md) - Framework-specific implementation rules
+**Related Resources**:
+- [Agent Directory](../.claude/EMPLOYEE-DIRECTORY.md) - 19-agent Trinity team guide
+- [Architecture Documentation](knowledge-base/ARCHITECTURE.md) - System architecture and patterns
+- [Known Issues](knowledge-base/ISSUES.md) - Issue patterns and resolutions
+- [Technical Debt](knowledge-base/Technical-Debt.md) - Debt tracking and reduction plans
+
+---
+
+**Trinity Method Enforcement Active**
+**Project:** {{PROJECT_NAME}}
+**Framework:** {{FRAMEWORK}}
+**Trinity Version**: {{TRINITY_VERSION}}
+**Last Updated**: {{CURRENT_DATE}}

package/dist/templates/work-orders/ANALYSIS-TEMPLATE.md.template

@@ -0,0 +1,276 @@
+# ORCHESTRATOR WORK ORDER #XXX
+## Type: ANALYSIS
+## [Analysis Title]
+
+---
+
+## AUTHORIZATION
+
+```
+TRINITY COUNCIL APPROVAL:
+☑ LUKA: APPROVED - [Strategic value of analysis]
+☑ TRINITY: APPROVED - [Technical approach validation]
+☑ CC: PENDING - Awaiting your acknowledgment
+
+STATUS: APPROVED FOR EXECUTION
+```
+
+---
+
+## MISSION OBJECTIVE
+
+[Clear statement of what needs deep analysis and the expected insights]
+
+**Analysis Goal:** [What understanding we need to gain]
+**Decision It Informs:** [How this analysis will be used]
+
+---
+
+## ANALYSIS SCOPE
+
+### Focus Area
+**Primary Target:** [Specific system/component/pattern to analyze]
+**Boundaries:** [What is IN scope vs OUT of scope]
+**Depth Level:** [Surface/Medium/Deep dive]
+
+### Key Questions
+1. **[Question #1]** - [Why this matters]
+2. **[Question #2]** - [Why this matters]
+3. **[Question #3]** - [Why this matters]
+
+### Mobile-First Analysis Requirements
+**MANDATORY for all UI-related analyses:**
+- [ ] **Mobile Viewport Analysis** - Analyze on mobile device emulation
+- [ ] **Touch Interaction Assessment** - Evaluate touch-based interactions
+- [ ] **Mobile Browser Compatibility** - Consider iOS Safari, Chrome Mobile, Android browsers
+- [ ] **Dynamic Viewport Impact** - Account for browser UI showing/hiding
+- [ ] **Mobile Performance Analysis** - Include mobile-specific performance considerations
+- [ ] **Mobile-Specific Patterns** - Identify mobile-unique usage patterns
+
+### Data Sources
+- **Source #1:** [What data/files/metrics]
+  - Collection method: [How to gather]
+  - Expected volume: [Amount of data]
+
+- **Source #2:** [What data/files/metrics]
+  - Collection method: [How to gather]
+  - Expected volume: [Amount of data]
+
+---
+
+## ANALYSIS METHODOLOGY
+
+### Phase 1: Data Collection
+- [ ] Gather [specific data type]
+- [ ] Extract [specific metrics]
+- [ ] Compile [specific lists]
+- [ ] Document [specific patterns]
+
+### Phase 2: Analysis Techniques
+#### Technique 1: [Pattern Analysis]
+- Approach: [How to analyze]
+- Tool/Method: [What to use]
+- Expected output: [What you'll produce]
+
+#### Technique 2: [Statistical Analysis]
+- Approach: [How to analyze]
+- Tool/Method: [What to use]
+- Expected output: [What you'll produce]
+
+#### Technique 3: [Root Cause Analysis]
+- Approach: [How to analyze]
+- Tool/Method: [What to use]
+- Expected output: [What you'll produce]
+
+### Phase 3: Synthesis
+- [ ] Correlate findings across data sources
+- [ ] Identify causation vs correlation
+- [ ] Build mental model of system behavior
+- [ ] Generate actionable insights
+
+---
+
+## DELIVERABLE REQUIREMENTS
+
+### Document Format
+**Filename:** `[COMPONENT]-ANALYSIS-[TIMESTAMP].md`
+**Location:** `${PROJECT_REPORTS}/` (Project-specific Reports folder)
+
+### Required Sections
+1. **Executive Summary** - Key insights and their implications
+2. **Methodology** - How analysis was conducted
+3. **Data Overview** - What was analyzed (volume, scope)
+4. **Findings** - Detailed analysis results
+5. **Patterns Identified** - Recurring themes or issues
+6. **Correlations** - Related factors discovered
+7. **Root Causes** - Fundamental issues identified
+8. **Mobile Compatibility Analysis** - Mobile-specific findings (if applicable)
+9. **Visualizations** - Charts/diagrams if applicable
+10. **Recommendations** - Action items based on analysis
+11. **Confidence Levels** - Certainty of conclusions
+
+### Analysis Artifacts
+- Raw data summary
+- Pattern library additions
+- Correlation matrices
+- Decision trees if applicable
+- Risk assessments
+- Mobile compatibility scores (if applicable)
+
+---
+
+## ✅ AFTER COMPLETION
+
+### ⚠️ CRITICAL: Complete ALL Steps Below - NO EXCEPTIONS
+
+**Step 1: Create Completion Report** ✅
+   - [ ] Analysis deliverable created in `${PROJECT_REPORTS}/`
+   - [ ] Follow format: `[COMPONENT]-ANALYSIS-[TIMESTAMP].md`
+   - [ ] JUNO audit report generated automatically (if applicable)
+   - [ ] All deliverables include required sections listed above
+
+**Step 2: 🚨 MOVE THIS WORK ORDER FILE 🚨** ✅
+   - [ ] **IMMEDIATELY** move this file from `trinity/work-orders/` to `trinity/sessions/`
+   - [ ] **THIS STEP IS MANDATORY** - Work orders left in trinity/work-orders/ are considered incomplete
+
+   **Execute this exact command:**
+   ```bash
+   mv trinity/work-orders/{{workOrderFilename}} trinity/sessions/
+   ```
+
+**Step 3: Verify File Locations** ✅
+   - [ ] This work order file NOW EXISTS in: `trinity/sessions/{{workOrderFilename}}`
+   - [ ] Completion report exists in: `${PROJECT_REPORTS}/[COMPONENT]-ANALYSIS-[TIMESTAMP].md`
+   - [ ] This work order NO LONGER EXISTS in: `trinity/work-orders/`
+
+   **If any verification fails, the work order is NOT complete. Fix immediately.**
+
+**Step 4: Session Cleanup (when entire session complete):**
+   - [ ] When session is complete, run `/trinity-end`
+   - [ ] trinity-end will archive ALL files from `trinity/sessions/` and `${PROJECT_REPORTS}/`
+   - [ ] Next session starts with empty sessions/ and reports/ folders
+
+**Archive Destination (via trinity-end):**
+- Work order → `trinity/archive/work-orders/YYYY-MM-DD/`
+- Completion report → `trinity/archive/reports/YYYY-MM-DD/`
+- JUNO audit report → `trinity/archive/reports/YYYY-MM-DD/` (if applicable)
+- Session summary → `trinity/archive/sessions/YYYY-MM-DD/`
+
+---
+
+## SUCCESS CRITERIA
+
+The analysis is complete when:
+- [ ] All key questions have been answered
+- [ ] Data has been thoroughly examined
+- [ ] Patterns have been identified and validated
+- [ ] Root causes have been determined
+- [ ] Mobile compatibility analyzed (if UI analysis)
+- [ ] Actionable insights have been generated
+- [ ] Confidence levels have been assessed
+- [ ] Analysis report submitted to project Reports folder
+
+---
+
+## ⚠️ CRITICAL RESTRICTIONS - GIT OPERATIONS FORBIDDEN
+
+**ANALYSES ARE READ-ONLY OPERATIONS:**
+ALL team members (CC, TRINITY, specialists) are PERMANENTLY FORBIDDEN from performing ANY git operations during analyses:
+
+- [ ] **git add** - FORBIDDEN - Only LUKA has permission
+- [ ] **git commit** - FORBIDDEN - Only LUKA has permission
+- [ ] **git push** - FORBIDDEN - Only LUKA has permission
+- [ ] **git pull** - FORBIDDEN - Only LUKA has permission
+- [ ] **git merge** - FORBIDDEN - Only LUKA has permission
+- [ ] **git checkout -b** - FORBIDDEN - Only LUKA has permission
+- [ ] **git branch** - FORBIDDEN - Only LUKA has permission
+- [ ] **git tag** - FORBIDDEN - Only LUKA has permission
+- [ ] **git rebase** - FORBIDDEN - Only LUKA has permission
+- [ ] **git reset** - FORBIDDEN - Only LUKA has permission
+- [ ] **git revert** - FORBIDDEN - Only LUKA has permission
+- [ ] **git stash** - FORBIDDEN - Only LUKA has permission
+- [ ] **Any git operation that modifies repository state**
+
+**ANALYSIS PROTOCOL:**
+1. Analyze files and data in current state
+2. Document all findings and insights
+3. Report analysis results to LUKA
+4. No file modifications during analysis phase
+5. If changes are needed, LUKA will issue separate implementation work order
+
+---
+
+## ANALYSIS CONSTRAINTS
+
+### Time Boundaries
+- Data from: [Start date/version]
+- Data to: [End date/version]
+- Analysis boundaries: [What to include/exclude]
+
+### Technical Constraints
+- Available tools: [What you can use]
+- Data access: [What you can access]
+- Processing limits: [Any limitations]
+
+### Assumptions
+1. [Assumption #1]
+2. [Assumption #2]
+3. [Document any assumptions made]
+
+---
+
+## INTERPRETATION GUIDELINES
+
+### Statistical Significance
+- Minimum sample size: [X]
+- Confidence threshold: [95%/99%]
+- Correlation strength: [Weak <0.3, Moderate 0.3-0.7, Strong >0.7]
+
+### Pattern Recognition
+- Minimum frequency: [X occurrences to be considered a pattern]
+- Context requirements: [What context must be similar]
+
+### Causation Criteria
+Evidence required to claim causation:
+1. Temporal precedence
+2. Covariation
+3. No spurious relationships
+
+---
+
+## CONTEXT FROM PREVIOUS WORK
+
+**Related Analyses:** [Work Order #XXX, #XXX]
+**Building On:** [Previous findings to extend]
+**Hypothesis:** [If testing specific hypothesis]
+
+---
+
+
+## PACE AND COMPLETENESS NOTICE
+
+**IMPORTANT:** There are NO time constraints on this work.
+The scope indicators are for planning purposes only, NOT deadlines.
+Take as much time as needed to achieve 100% completion with precision.
+Partial completion is unacceptable.
+Quality and completeness are the ONLY metrics that matter.
+
+## PRIORITY & IMPACT
+
+**Analysis Scope:** [COMPREHENSIVE/STANDARD/FOCUSED]
+**Completeness Required:** 100% - Full analysis must be completed
+**Strategic Impact:** [How this affects decisions]
+**Technical Impact:** [What implementations this guides]
+
+---
+
+## SPECIAL CONSIDERATIONS
+
+[Any domain expertise needed, special tools required, or unique aspects of this analysis]
+
+---
+
+**Remember:** Analysis should be objective, evidence-based, and actionable. Present findings clearly with appropriate confidence levels. When uncertain, state limitations explicitly. Analyses are read-only - no file modifications or git operations.
+
+*Trinity Method v2.0 - Analysis Work Order Template*
+*Project-Isolated Architecture with Dynamic Paths*