telos-framework 0.1.4 → 0.3.0

package/.claude/commands/tm/utils/analyze-project.md

@@ -0,0 +1,97 @@
+Advanced project analysis with actionable insights and recommendations.
+
+Arguments: $ARGUMENTS
+
+## Comprehensive Project Analysis
+
+Multi-dimensional analysis based on requested focus area.
+
+### 1. **Analysis Modes**
+
+Based on $ARGUMENTS:
+- "velocity" → Sprint velocity and trends
+- "quality" → Code quality metrics
+- "risk" → Risk assessment and mitigation
+- "dependencies" → Dependency graph analysis
+- "team" → Workload and skill distribution
+- "architecture" → System design coherence
+- Default → Full spectrum analysis
+
+### 2. **Velocity Analytics**
+
+```
+📊 Velocity Analysis
+━━━━━━━━━━━━━━━━━━━
+Current Sprint: 24 points/week ↗️ +20%
+Rolling Average: 20 points/week
+Efficiency: 85% (17/20 tasks on time)
+
+Bottlenecks Detected:
+- Code review delays (avg 4h wait)
+- Test environment availability
+- Dependency on external team
+
+Recommendations:
+1. Implement parallel review process
+2. Add staging environment
+3. Mock external dependencies
+```
+
+### 3. **Risk Assessment**
+
+**Technical Risks**
+- High complexity tasks without backup assignee
+- Single points of failure in architecture
+- Insufficient test coverage in critical paths
+- Technical debt accumulation rate
+
+**Project Risks**
+- Critical path dependencies
+- Resource availability gaps
+- Deadline feasibility analysis
+- Scope creep indicators
+
+### 4. **Dependency Intelligence**
+
+Visual dependency analysis:
+```
+Critical Path: 
+#12 → #15 → #23 → #45 → #50 (20 days)
+         ↘ #24 → #46 ↗
+
+Optimization: Parallelize #15 and #24
+Time Saved: 3 days
+```
+
+### 5. **Quality Metrics**
+
+**Code Quality**
+- Test coverage trends
+- Complexity scores
+- Technical debt ratio
+- Review feedback patterns
+
+**Process Quality**
+- Rework frequency
+- Bug introduction rate
+- Time to resolution
+- Knowledge distribution
+
+### 6. **Predictive Insights**
+
+Based on patterns:
+- Completion probability by deadline
+- Resource needs projection
+- Risk materialization likelihood
+- Suggested interventions
+
+### 7. **Executive Dashboard**
+
+High-level summary with:
+- Health score (0-100)
+- Top 3 risks
+- Top 3 opportunities
+- Recommended actions
+- Success probability
+
+Result: Data-driven decisions with clear action paths.

package/.claude/commands/tm/validate-dependencies/validate-dependencies.md

@@ -0,0 +1,71 @@
+Validate all task dependencies for issues.
+
+## Dependency Validation
+
+Comprehensive check for dependency problems across the entire project.
+
+## Execution
+
+```bash
+task-master validate-dependencies
+```
+
+## Validation Checks
+
+1. **Circular Dependencies**
+   - A depends on B, B depends on A
+   - Complex circular chains
+   - Self-dependencies
+
+2. **Missing Dependencies**
+   - References to non-existent tasks
+   - Deleted task references
+   - Invalid task IDs
+
+3. **Logical Issues**
+   - Completed tasks depending on pending
+   - Cancelled tasks in dependency chains
+   - Impossible sequences
+
+4. **Complexity Warnings**
+   - Over-complex dependency chains
+   - Too many dependencies per task
+   - Bottleneck tasks
+
+## Smart Analysis
+
+The validation provides:
+- Visual dependency graph
+- Critical path analysis
+- Bottleneck identification
+- Suggested optimizations
+
+## Report Format
+
+```
+Dependency Validation Report
+━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ No circular dependencies found
+⚠️  2 warnings found:
+   - Task #23 has 7 dependencies (consider breaking down)
+   - Task #45 blocks 5 other tasks (potential bottleneck)
+❌ 1 error found:
+   - Task #67 depends on deleted task #66
+
+Critical Path: #1 → #5 → #23 → #45 → #50 (15 days)
+```
+
+## Actionable Output
+
+For each issue found:
+- Clear description
+- Impact assessment
+- Suggested fix
+- Command to resolve
+
+## Next Steps
+
+After validation:
+- Run `/project:tm/fix-dependencies` to auto-fix
+- Manually adjust problematic dependencies
+- Rerun to verify fixes

package/.claude/commands/tm/workflows/auto-implement-tasks.md

@@ -0,0 +1,97 @@
+Enhanced auto-implementation with intelligent code generation and testing.
+
+Arguments: $ARGUMENTS
+
+## Intelligent Auto-Implementation
+
+Advanced implementation with context awareness and quality checks.
+
+### 1. **Pre-Implementation Analysis**
+
+Before starting:
+- Analyze task complexity and requirements
+- Check codebase patterns and conventions
+- Identify similar completed tasks
+- Assess test coverage needs
+- Detect potential risks
+
+### 2. **Smart Implementation Strategy**
+
+Based on task type and context:
+
+**Feature Tasks**
+1. Research existing patterns
+2. Design component architecture
+3. Implement with tests
+4. Integrate with system
+5. Update documentation
+
+**Bug Fix Tasks**
+1. Reproduce issue
+2. Identify root cause
+3. Implement minimal fix
+4. Add regression tests
+5. Verify side effects
+
+**Refactoring Tasks**
+1. Analyze current structure
+2. Plan incremental changes
+3. Maintain test coverage
+4. Refactor step-by-step
+5. Verify behavior unchanged
+
+### 3. **Code Intelligence**
+
+**Pattern Recognition**
+- Learn from existing code
+- Follow team conventions
+- Use preferred libraries
+- Match style guidelines
+
+**Test-Driven Approach**
+- Write tests first when possible
+- Ensure comprehensive coverage
+- Include edge cases
+- Performance considerations
+
+### 4. **Progressive Implementation**
+
+Step-by-step with validation:
+```
+Step 1/5: Setting up component structure ✓
+Step 2/5: Implementing core logic ✓
+Step 3/5: Adding error handling ⚡ (in progress)
+Step 4/5: Writing tests ⏳
+Step 5/5: Integration testing ⏳
+
+Current: Adding try-catch blocks and validation...
+```
+
+### 5. **Quality Assurance**
+
+Automated checks:
+- Linting and formatting
+- Test execution
+- Type checking
+- Dependency validation
+- Performance analysis
+
+### 6. **Smart Recovery**
+
+If issues arise:
+- Diagnostic analysis
+- Suggestion generation
+- Fallback strategies
+- Manual intervention points
+- Learning from failures
+
+### 7. **Post-Implementation**
+
+After completion:
+- Generate PR description
+- Update documentation
+- Log lessons learned
+- Suggest follow-up tasks
+- Update task relationships
+
+Result: High-quality, production-ready implementations.

package/.claude/commands/tm/workflows/command-pipeline.md

@@ -0,0 +1,77 @@
+Execute a pipeline of commands based on a specification.
+
+Arguments: $ARGUMENTS
+
+## Command Pipeline Execution
+
+Parse pipeline specification from arguments. Supported formats:
+
+### Simple Pipeline
+`init → expand-all → sprint-plan`
+
+### Conditional Pipeline  
+`status → if:pending>10 → sprint-plan → else → next`
+
+### Iterative Pipeline
+`for:pending-tasks → expand → complexity-check`
+
+### Smart Pipeline Patterns
+
+**1. Project Setup Pipeline**
+```
+init [prd] → 
+expand-all → 
+complexity-report → 
+sprint-plan → 
+show first-sprint
+```
+
+**2. Daily Work Pipeline**
+```
+standup →
+if:in-progress → continue →
+else → next → start
+```
+
+**3. Task Completion Pipeline**
+```
+complete [id] →
+git-commit →
+if:blocked-tasks-freed → show-freed →
+next
+```
+
+**4. Quality Check Pipeline**
+```
+list in-progress →
+for:each → check-idle-time →
+if:idle>1day → prompt-update
+```
+
+### Pipeline Features
+
+**Variables**
+- Store results: `status → $count=pending-count`
+- Use in conditions: `if:$count>10`
+- Pass between commands: `expand $high-priority-tasks`
+
+**Error Handling**
+- On failure: `try:complete → catch:show-blockers`
+- Skip on error: `optional:test-run`
+- Retry logic: `retry:3:commit`
+
+**Parallel Execution**
+- Parallel branches: `[analyze | test | lint]`
+- Join results: `parallel → join:report`
+
+### Execution Flow
+
+1. Parse pipeline specification
+2. Validate command sequence
+3. Execute with state passing
+4. Handle conditions and loops
+5. Aggregate results
+6. Show summary
+
+This enables complex workflows like:
+`parse-prd → expand-all → filter:complex>70 → assign:senior → sprint-plan:weighted`

package/.claude/commands/tm/workflows/smart-workflow.md

@@ -0,0 +1,55 @@
+Execute an intelligent workflow based on current project state and recent commands.
+
+This command analyzes:
+1. Recent commands you've run
+2. Current project state
+3. Time of day / day of week
+4. Your working patterns
+
+Arguments: $ARGUMENTS
+
+## Intelligent Workflow Selection
+
+Based on context, I'll determine the best workflow:
+
+### Context Analysis
+- Previous command executed
+- Current task states
+- Unfinished work from last session
+- Your typical patterns
+
+### Smart Execution
+
+If last command was:
+- `status` → Likely starting work → Run daily standup
+- `complete` → Task finished → Find next task
+- `list pending` → Planning → Suggest sprint planning
+- `expand` → Breaking down work → Show complexity analysis
+- `init` → New project → Show onboarding workflow
+
+If no recent commands:
+- Morning? → Daily standup workflow
+- Many pending tasks? → Sprint planning
+- Tasks blocked? → Dependency resolution
+- Friday? → Weekly review
+
+### Workflow Composition
+
+I'll chain appropriate commands:
+1. Analyze current state
+2. Execute primary workflow
+3. Suggest follow-up actions
+4. Prepare environment for coding
+
+### Learning Mode
+
+This command learns from your patterns:
+- Track command sequences
+- Note time preferences
+- Remember common workflows
+- Adapt to your style
+
+Example flows detected:
+- Morning: standup → next → start
+- After lunch: status → continue task
+- End of day: complete → commit → status

package/.claude/commands/van.md

@@ -0,0 +1,150 @@
+# /van - Collective Routing Engine
+
+---
+allowed-tools: Task(*), Read(*), Write(*), Edit(*), MultiEdit(*), Glob(*), Grep(*), Bash(*), LS(*), TodoWrite(*), WebSearch(*), WebFetch(*), mcp__task-master__*, mcp__context7__*
+description: 🚐 Fast routing engine for intelligent agent selection and request delegation
+---
+
+## 🎯 Purpose - Smart Routing
+
+**Fast Agent Selection** - analyze user requests and route to the optimal specialized agent using proven patterns and decision matrices.
+
+## 🚐 Routing Flow
+
+```
+Request → 🧠 Quick Analysis → 🎯 Agent Selection → ⚡ Task Delegation
+```
+
+## 🚀 DUAL-MODE ROUTING PROTOCOL
+
+### **🎯 USER IMPLEMENTATION MODE** (Direct Agent Routing - DEFAULT)
+**Triggers**: Feature implementation, code creation, bug fixes, testing, research  
+**Pattern**: Direct routing to specialized implementation agents  
+**No TaskMaster**: Bypass research coordination for practical development  
+
+### **🔬 RESEARCH COORDINATION MODE** (TaskMaster Integration - RARE)
+**Triggers**: System management, research project coordination, collective enhancement  
+**Pattern**: Complex coordination through TaskMaster workflows  
+**Full Orchestration**: Use enhanced TaskMaster agents (task-orchestrator → task-executor → task-checker)  
+
+## 🧠 IMMEDIATE AGENT ROUTING
+
+**Bypass analysis for obvious requests:**
+
+| User Says | Instant Agent | Why Skip Analysis |
+|-----------|---------------|-------------------|
+| **"build/create/implement X"** | **@component-implementation-agent** OR **@feature-implementation-agent** | Direct implementation needed |
+| **"build app from PRD"** | **@prd-parser-agent** | Parse PRD → research → generate tasks |
+| **"create app from PRD"** | **@prd-parser-agent** | Parse PRD → research → generate tasks |
+| **"create application using PRD"** | **@prd-parser-agent** | Parse PRD → research → generate tasks |
+| **"implement from PRD"** | **@prd-parser-agent** | Parse PRD → research → generate tasks |
+| **"execute tasks"** | **@task-orchestrator** | Coordinate existing TaskMaster tasks |
+| **"fix/debug/resolve X"** | **@feature-implementation-agent** | Direct problem-solving |
+| **"test/validate X"** | **@testing-implementation-agent** | Direct testing workflow |
+| **"optimize/polish X"** | **@polish-implementation-agent** | Direct improvement |
+| **"research/analyze/compare X"** | **@research-agent** | Direct research needed |
+| **"setup/configure build"** | **@infrastructure-implementation-agent** | Direct infrastructure work |
+| **"review/check quality"** | **@quality-agent** | Direct quality validation |
+| **"deploy/setup devops"** | **@devops-agent** | Direct deployment work |
+| **"enhance collective"** | **@task-orchestrator** | System-level coordination |
+| **"coordinate complex project"** | **@task-orchestrator** | Multi-agent orchestration |
+
+## 📊 COMPLEX REQUEST ANALYSIS
+
+**When routing isn't obvious:**
+
+| Request Category | Analysis Approach | Agent Selection Strategy |
+|------------------|-------------------|--------------------------| 
+| **🔧 Implementation & Features** | Assess UI vs logic complexity | UI-focused → `@component-implementation-agent`, Logic-focused → `@feature-implementation-agent`, Full-stack → both |
+| **🧪 Testing & Quality** | Scope and current state | New tests → `@testing-implementation-agent`, Quality check → `@quality-agent`, Performance → `@polish-implementation-agent` |
+| **🏗️ Infrastructure & Build** | Setup vs maintenance | New project → `@infrastructure-implementation-agent`, Deployment → `@devops-agent` |
+| **📚 Research & Analysis** | Information vs implementation | Pure research → `@research-agent`, Research + implementation → `@prd-research-agent` |
+| **🌟 Multi-Domain/Epic** | Decomposition and coordination needs | Always → `@task-orchestrator` with TaskMaster integration |
+
+## 🎯 SMART ROUTING DECISION TREE
+
+```
+Request Analysis
+├── PRD Document? → @prd-parser-agent → @research-agent → @task-generator-agent → @task-orchestrator
+├── UI/Component Focus? → @component-implementation-agent
+├── Business Logic Focus? → @feature-implementation-agent  
+├── Testing Focus? → @testing-implementation-agent
+├── Infrastructure Focus? → @infrastructure-implementation-agent
+├── Quality Focus? → @quality-agent OR @polish-implementation-agent
+├── Research Focus? → @research-agent
+├── Multi-Domain Complex? → @task-orchestrator
+└── System Enhancement? → @task-orchestrator + TaskMaster
+```
+
+## 🎮 ORCHESTRATION PATTERNS
+
+**Pattern 1: Direct Implementation Delegation**
+```bash
+# User: "build a React todo app with TypeScript"
+Task(subagent_type="component-implementation-agent", 
+     prompt="Build React todo app with TypeScript - use Context7 for latest React patterns, implement TDD workflow")
+```
+
+**Pattern 2: Research-Backed Development**
+```bash
+# User: "implement authentication with best practices"
+Task(subagent_type="feature-implementation-agent",
+     prompt="Implement authentication with security best practices - research latest patterns via Context7, apply TDD methodology")
+```
+
+**Pattern 3: PRD-Based Development**
+```bash
+# User: "create application using PRD at path/to/prd.txt"
+Task(subagent_type="prd-parser-agent",
+     prompt="Parse PRD document and extract structured requirements:
+     - Read PRD and identify all technologies mentioned
+     - Extract functional and technical requirements
+     - Create structured analysis for research handoff
+     - Hand off to research-agent for technology research")
+```
+
+## ⚡ ROUTING RULES
+
+### Execution Efficiency Rules
+1. **Single Agent Default**: Prefer focused agent execution over complex orchestration (90% of requests)
+2. **TaskMaster Only When Needed**: Use @task-orchestrator for truly complex coordination (10% of requests)
+3. **Research Integration**: Every agent incorporates Context7 research into their execution
+4. **TDD Compliance**: All implementation follows Test-Driven Development patterns
+5. **Quality Validation**: Mandatory gate checkpoints for production readiness
+
+### Strategic Decision Making
+1. **Agent-First Thinking**: Always consider which collective agent can handle the request most efficiently
+2. **Strategic Focus**: Maintain Van's orchestration role above all else
+3. **Research-Backed Routing**: Use Context7 patterns and TaskMaster data for informed routing
+4. **TDD Integration**: Ensure all implementation flows through TDD methodology
+5. **Quality Gates**: Implement mandatory validation at every handoff point
+
+## 🎯 Van-Optimized Output Format
+
+```markdown
+# 🚐✨ Van Collective: [User's Original Request]
+
+## 🧠 Analysis & Routing Decision
+- **Intent**: [Clear category]
+- **Mode**: [USER IMPLEMENTATION / RESEARCH COORDINATION]
+- **Agent Selected**: @[agent-name] 
+- **Routing Reason**: [Why this agent was chosen]
+- **Research Integration**: [Context7 libraries / TaskMaster coordination]
+
+## 🎯 Agent Execution Summary
+**Agent**: @[agent-name]
+**Task Delegated**: "[Exact task given to agent]"
+**TDD Requirement**: [Yes/No + methodology]
+**Research Context**: [Context7 libraries + research cache references]
+**Quality Gates**: [Validation checkpoints]
+
+## ✨ Collective Status
+- **Status**: [Delegated/In Progress/Completed]
+- **Next Action**: [What happens next]
+- **Quality Gates**: [Validation requirements]
+- **Research Cache**: [Updated patterns for future routing]
+```
+
+---
+
+*"🚐✨ Your development request is our collective command - through the power of research-backed agent orchestration!"*