data_porter 0.1.0 → 0.4.0

data/.claude/commands/tm/analyze-complexity.md

@@ -1,124 +0,0 @@
-Analyze Complexity
-
-Arguments: $ARGUMENTS
-Analyze task complexity and generate expansion recommendations.
-
-Arguments: $ARGUMENTS
-
-Perform deep analysis of task complexity across the project.
-
-## Complexity Analysis
-
-Uses AI to analyze tasks and recommend which ones need breakdown.
-
-## Execution Options
-
-```bash
-task-master analyze-complexity [--research] [--threshold=5]
-```
-
-## Analysis Parameters
-
-- `--research` → Use research AI for deeper analysis
-- `--threshold=5` → Only flag tasks above complexity 5
-- Default: Analyze all pending tasks
-
-## Analysis Process
-
-### 1. **Task Evaluation**
-For each task, AI evaluates:
-- Technical complexity
-- Time requirements
-- Dependency complexity
-- Risk factors
-- Knowledge requirements
-
-### 2. **Complexity Scoring**
-Assigns score 1-10 based on:
-- Implementation difficulty
-- Integration challenges
-- Testing requirements
-- Unknown factors
-- Technical debt risk
-
-### 3. **Recommendations**
-For complex tasks:
-- Suggest expansion approach
-- Recommend subtask breakdown
-- Identify risk areas
-- Propose mitigation strategies
-
-## Smart Analysis Features
-
-1. **Pattern Recognition**
-   - Similar task comparisons
-   - Historical complexity accuracy
-   - Team velocity consideration
-   - Technology stack factors
-
-2. **Contextual Factors**
-   - Team expertise
-   - Available resources
-   - Timeline constraints
-   - Business criticality
-
-3. **Risk Assessment**
-   - Technical risks
-   - Timeline risks
-   - Dependency risks
-   - Knowledge gaps
-
-## Output Format
-
-```
-Task Complexity Analysis Report
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-High Complexity Tasks (>7):
-📍 #5 "Implement real-time sync" - Score: 9/10
-   Factors: WebSocket complexity, state management, conflict resolution
-   Recommendation: Expand into 5-7 subtasks
-   Risks: Performance, data consistency
-
-📍 #12 "Migrate database schema" - Score: 8/10
-   Factors: Data migration, zero downtime, rollback strategy
-   Recommendation: Expand into 4-5 subtasks
-   Risks: Data loss, downtime
-
-Medium Complexity Tasks (5-7):
-📍 #23 "Add export functionality" - Score: 6/10
-   Consider expansion if timeline tight
-
-Low Complexity Tasks (<5):
-✅ 15 tasks - No expansion needed
-
-Summary:
-- Expand immediately: 2 tasks
-- Consider expanding: 5 tasks
-- Keep as-is: 15 tasks
-```
-
-## Actionable Output
-
-For each high-complexity task:
-1. Complexity score with reasoning
-2. Specific expansion suggestions
-3. Risk mitigation approaches
-4. Recommended subtask structure
-
-## Integration
-
-Results are:
-- Saved to `.taskmaster/reports/complexity-analysis.md`
-- Used by expand command
-- Inform sprint planning
-- Guide resource allocation
-
-## Next Steps
-
-After analysis:
-```
-/taskmaster:expand 5    # Expand specific task
-/taskmaster:expand-all  # Expand all recommended
-/taskmaster:complexity-report  # View detailed report
-```

data/.claude/commands/tm/analyze-project.md

@@ -1,100 +0,0 @@
-Analyze Project
-
-Arguments: $ARGUMENTS
-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.

data/.claude/commands/tm/auto-implement-tasks.md

@@ -1,100 +0,0 @@
-Auto Implement Tasks
-
-Arguments: $ARGUMENTS
-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.

data/.claude/commands/tm/command-pipeline.md

@@ -1,80 +0,0 @@
-Command Pipeline
-
-Arguments: $ARGUMENTS
-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`

data/.claude/commands/tm/complexity-report.md

@@ -1,120 +0,0 @@
-Complexity Report
-
-Arguments: $ARGUMENTS
-Display the task complexity analysis report.
-
-Arguments: $ARGUMENTS
-
-View the detailed complexity analysis generated by analyze-complexity command.
-
-## Viewing Complexity Report
-
-Shows comprehensive task complexity analysis with actionable insights.
-
-## Execution
-
-```bash
-task-master complexity-report [--file=<path>]
-```
-
-## Report Location
-
-Default: `.taskmaster/reports/complexity-analysis.md`
-Custom: Specify with --file parameter
-
-## Report Contents
-
-### 1. **Executive Summary**
-```
-Complexity Analysis Summary
-━━━━━━━━━━━━━━━━━━━━━━━━
-Analysis Date: 2024-01-15
-Tasks Analyzed: 32
-High Complexity: 5 (16%)
-Medium Complexity: 12 (37%)
-Low Complexity: 15 (47%)
-
-Critical Findings:
-- 5 tasks need immediate expansion
-- 3 tasks have high technical risk
-- 2 tasks block critical path
-```
-
-### 2. **Detailed Task Analysis**
-For each complex task:
-- Complexity score breakdown
-- Contributing factors
-- Specific risks identified
-- Expansion recommendations
-- Similar completed tasks
-
-### 3. **Risk Matrix**
-Visual representation:
-```
-Risk vs Complexity Matrix
-━━━━━━━━━━━━━━━━━━━━━━━
-High Risk  | #5(9) #12(8) | #23(6)
-Med Risk   | #34(7)       | #45(5) #67(5)
-Low Risk   | #78(8)       | [15 tasks]
-           | High Complex  | Med Complex
-```
-
-### 4. **Recommendations**
-
-**Immediate Actions:**
-1. Expand task #5 - Critical path + high complexity
-2. Expand task #12 - High risk + dependencies
-3. Review task #34 - Consider splitting
-
-**Sprint Planning:**
-- Don't schedule multiple high-complexity tasks together
-- Ensure expertise available for complex tasks
-- Build in buffer time for unknowns
-
-## Interactive Features
-
-When viewing report:
-1. **Quick Actions**
-   - Press 'e' to expand a task
-   - Press 'd' for task details
-   - Press 'r' to refresh analysis
-
-2. **Filtering**
-   - View by complexity level
-   - Filter by risk factors
-   - Show only actionable items
-
-3. **Export Options**
-   - Markdown format
-   - CSV for spreadsheets
-   - JSON for tools
-
-## Report Intelligence
-
-- Compares with historical data
-- Shows complexity trends
-- Identifies patterns
-- Suggests process improvements
-
-## Integration
-
-Use report for:
-- Sprint planning sessions
-- Resource allocation
-- Risk assessment
-- Team discussions
-- Client updates
-
-## Example Usage
-
-```
-/taskmaster:complexity-report
-→ Opens latest analysis
-
-/taskmaster:complexity-report --file=archived/2024-01-01.md
-→ View historical analysis
-
-After viewing:
-/taskmaster:expand 5
-→ Expand high-complexity task
-```

data/.claude/commands/tm/convert-task-to-subtask.md

@@ -1,74 +0,0 @@
-Convert Task To Subtask
-
-Arguments: $ARGUMENTS
-Convert an existing task into a subtask.
-
-Arguments: $ARGUMENTS
-
-Parse parent ID and task ID to convert.
-
-## Task Conversion
-
-Converts an existing standalone task into a subtask of another task.
-
-## Argument Parsing
-
-- "move task 8 under 5"
-- "make 8 a subtask of 5"
-- "nest 8 in 5"
-- "5 8" → make task 8 a subtask of task 5
-
-## Execution
-
-```bash
-task-master add-subtask --parent=<parent-id> --task-id=<task-to-convert>
-```
-
-## Pre-Conversion Checks
-
-1. **Validation**
-   - Both tasks exist and are valid
-   - No circular parent relationships
-   - Task isn't already a subtask
-   - Logical hierarchy makes sense
-
-2. **Impact Analysis**
-   - Dependencies that will be affected
-   - Tasks that depend on converting task
-   - Priority alignment needed
-   - Status compatibility
-
-## Conversion Process
-
-1. Change task ID from "8" to "5.1" (next available)
-2. Update all dependency references
-3. Inherit parent's context where appropriate
-4. Adjust priorities if needed
-5. Update time estimates
-
-## Smart Features
-
-- Preserve task history
-- Maintain dependencies
-- Update all references
-- Create conversion log
-
-## Example
-
-```
-/taskmaster:add-subtask/from-task 5 8
-→ Converting: Task #8 becomes subtask #5.1
-→ Updated: 3 dependency references
-→ Parent task #5 now has 1 subtask
-→ Note: Subtask inherits parent's priority
-
-Before: #8 "Implement validation" (standalone)
-After:  #5.1 "Implement validation" (subtask of #5)
-```
-
-## Post-Conversion
-
-- Show new task hierarchy
-- List updated dependencies
-- Verify project integrity
-- Suggest related conversions

data/.claude/commands/tm/expand-all-tasks.md

@@ -1,52 +0,0 @@
-Expand All Tasks
-Expand all pending tasks that need subtasks.
-
-## Bulk Task Expansion
-
-Intelligently expands all tasks that would benefit from breakdown.
-
-## Execution
-
-```bash
-task-master expand --all
-```
-
-## Smart Selection
-
-Only expands tasks that:
-- Are marked as pending
-- Have high complexity (>5)
-- Lack existing subtasks
-- Would benefit from breakdown
-
-## Expansion Process
-
-1. **Analysis Phase**
-   - Identify expansion candidates
-   - Group related tasks
-   - Plan expansion strategy
-
-2. **Batch Processing**
-   - Expand tasks in logical order
-   - Maintain consistency
-   - Preserve relationships
-   - Optimize for parallelism
-
-3. **Quality Control**
-   - Ensure subtask quality
-   - Avoid over-decomposition
-   - Maintain task coherence
-   - Update dependencies
-
-## Options
-
-- Add `force` to expand all regardless of complexity
-- Add `research` for enhanced AI analysis
-
-## Results
-
-After bulk expansion:
-- Summary of tasks expanded
-- New subtask count
-- Updated complexity metrics
-- Suggested task order

data/.claude/commands/tm/expand-task.md

@@ -1,52 +0,0 @@
-Expand Task
-
-Arguments: $ARGUMENTS
-Break down a complex task into subtasks.
-
-Arguments: $ARGUMENTS (task ID)
-
-## Intelligent Task Expansion
-
-Analyzes a task and creates detailed subtasks for better manageability.
-
-## Execution
-
-```bash
-task-master expand --id=$ARGUMENTS
-```
-
-## Expansion Process
-
-1. **Task Analysis**
-   - Review task complexity
-   - Identify components
-   - Detect technical challenges
-   - Estimate time requirements
-
-2. **Subtask Generation**
-   - Create 3-7 subtasks typically
-   - Each subtask 1-4 hours
-   - Logical implementation order
-   - Clear acceptance criteria
-
-3. **Smart Breakdown**
-   - Setup/configuration tasks
-   - Core implementation
-   - Testing components
-   - Integration steps
-   - Documentation updates
-
-## Enhanced Features
-
-Based on task type:
-- **Feature**: Setup → Implement → Test → Integrate
-- **Bug Fix**: Reproduce → Diagnose → Fix → Verify
-- **Refactor**: Analyze → Plan → Refactor → Validate
-
-## Post-Expansion
-
-After expansion:
-1. Show subtask hierarchy
-2. Update time estimates
-3. Suggest implementation order
-4. Highlight critical path