@hhsw2015/task-master-ai 0.43.0

package/dist/profiles-DcD-JxPM.js

@@ -0,0 +1,3528 @@
+import{c as e}from"./ai-services-unified-BgdcS4fE.js";import{Bt as t,E as n,Ft as r,Gt as i,Ht as a,It as o,J as s,Pt as c,Ut as l,Vt as u,Wt as d,hn as f,qt as p,vt as m,yt as h}from"./config-manager-cjltSxIS.js";import{r as g}from"./git-utils-DllbRE35.js";import{Ct as _,St as v,Tt as y,x as ee}from"./dependency-manager-CyOxi5uo.js";import*as b from"node:path";import x from"chalk";import S from"fs";import C from"path";import{randomUUID as w}from"crypto";import T from"os";import*as E from"node:fs";import{execSync as D}from"child_process";import*as O from"node:os";import{fileURLToPath as te}from"url";import k from"boxen";import A from"readline";import ne from"figlet";import re from"gradient-string";import ie from"inquirer";import ae from"ora";import oe from"open";const j=[`amp`,`claude`,`cline`,`codex`,`cursor`,`gemini`,`kiro`,`opencode`,`kilo`,`roo`,`trae`,`vscode`,`windsurf`,`zed`],se=[`architect`,`ask`,`orchestrator`,`code`,`debug`,`test`],M=`# Task files`,ce=`tasks.json`,N=`tasks/`;function le(e){return e.trim().replace(/^#/,``).trim()}function P(e){let t=le(e);return t===ce||t===N}function ue(e,t){return e.map(e=>{if(P(e)){let n=le(e),r=e.match(/\s*$/)[0];return t?`# ${n}${r}`:`${n}${r}`}return e})}function de(e){let t=[],n=!1;for(let r of e){if(r.trim()===M){n=!0;continue}P(r)||n&&!r.trim()||(n&&r.trim()&&!P(r)&&(n=!1),n||t.push(r))}return t}function fe(e,t){return e.filter(e=>{let n=e.trim();return!n||P(e)||n===M?!1:!t.has(n)})}function pe(e){let t=[M];return e?t.push(`# ${ce}`,`# ${N} `):t.push(ce,`${N} `),t}function me(e){if(e.some(e=>e.trim())){let t=e[e.length-1];t&&t.trim()&&e.push(``)}}function he(e,t,n){if(!e||typeof e!=`string`)throw Error(`targetPath must be a non-empty string`);if(!e.endsWith(`.gitignore`))throw Error(`targetPath must end with .gitignore`);if(!t||typeof t!=`string`)throw Error(`content must be a non-empty string`);if(typeof n!=`boolean`)throw Error(`storeTasksInGit must be a boolean`)}function ge(e,t,n){try{S.writeFileSync(e,t.join(`
+`)+`
+`),typeof n==`function`&&n(`success`,`Created ${e} with full template`)}catch(t){throw typeof n==`function`&&n(`error`,`Failed to create ${e}: ${t.message}`),t}}function _e(e,t,n,r){try{let i=de(S.readFileSync(e,`utf8`).split(`
+`)),a=fe(t,new Set(i.map(e=>e.trim()).filter(e=>e))),o=[...i];a.length>0&&(me(o),o.push(...a)),me(o),o.push(...pe(n)),S.writeFileSync(e,o.join(`
+`)+`
+`),typeof r==`function`&&r(`debug`,`Updated ${e} according to user preference${a.length>0?` and merged new content`:``}`)}catch(t){throw typeof r==`function`&&r(`error`,`Failed to merge content with ${e}: ${t.message}`),t}}function ve(e,t,n=!0,r=null){he(e,t,n);let i=ue(t.split(`
+`),n);S.existsSync(e)?_e(e,i,n,r):ge(e,i,r)}const ye=te(import.meta.url),F=C.dirname(ye);function I(){let e=[C.join(F,`assets`),C.join(F,`..`,`assets`),C.join(F,`..`,`..`,`public`,`assets`),C.join(process.cwd(),`assets`),C.join(process.cwd(),`node_modules`,`task-master-ai`,`dist`,`assets`),C.join(process.cwd(),`node_modules`,`task-master-ai`,`assets`)];for(let t of e)if(S.existsSync(t)){let e=C.join(t,`rules`,`taskmaster.mdc`);if(S.existsSync(e))return t}throw Error(`Assets directory not found. This is likely a packaging issue.`)}function be(e){let t=I();return C.join(t,e)}function xe(e){try{let t=be(e);return S.existsSync(t)}catch{return!1}}function L(e,t=`utf8`){let n=be(e);return S.readFileSync(n,t)}function R(e){let t=JSON.stringify(e,null,`	`);return t=t.replace(/(\[\n\t+)([^[\]]+?)(\n\t+\])/g,(e,t,n,r)=>!n.includes(`{`)&&!n.includes(`[`)?`[${n.replace(/\n\t+/g,` `).replace(/\s+/g,` `).trim()}]`:e),t}function Se(e,t){if(!t){h(`debug`,`[MCP Config] No mcpConfigPath provided, skipping MCP configuration setup`);return}let n=C.join(e,t),r=C.dirname(n);h(`info`,`Setting up MCP configuration at ${n}...`);let i={"task-master-ai":{command:`npx`,args:[`-y`,`task-master-ai`],env:{TASK_MASTER_TOOLS:`core`,ANTHROPIC_API_KEY:`YOUR_ANTHROPIC_API_KEY_HERE`,PERPLEXITY_API_KEY:`YOUR_PERPLEXITY_API_KEY_HERE`,OPENAI_API_KEY:`YOUR_OPENAI_KEY_HERE`,GOOGLE_API_KEY:`YOUR_GOOGLE_KEY_HERE`,XAI_API_KEY:`YOUR_XAI_KEY_HERE`,OPENROUTER_API_KEY:`YOUR_OPENROUTER_KEY_HERE`,MISTRAL_API_KEY:`YOUR_MISTRAL_KEY_HERE`,AZURE_OPENAI_API_KEY:`YOUR_AZURE_KEY_HERE`,OLLAMA_API_KEY:`YOUR_OLLAMA_API_KEY_HERE`}}};if(S.existsSync(r)||S.mkdirSync(r,{recursive:!0}),S.existsSync(n)){h(`info`,`MCP configuration file already exists, checking for existing task-master-ai...`);try{let e=JSON.parse(S.readFileSync(n,`utf8`));if(e.mcpServers||={},Object.values(e.mcpServers).some(e=>e.args&&Array.isArray(e.args)&&e.args.some(e=>typeof e==`string`&&e.includes(`task-master-ai`)))){h(`info`,`Found existing task-master-ai MCP configuration in mcp.json, leaving untouched`);return}e.mcpServers[`task-master-ai`]?h(`info`,`task-master-ai server already configured in mcp.json`):(e.mcpServers[`task-master-ai`]=i[`task-master-ai`],h(`info`,`Added task-master-ai server to existing MCP configuration`)),S.writeFileSync(n,R(e)+`
+`),h(`success`,`Updated MCP configuration file`)}catch(e){h(`error`,`Failed to update MCP configuration: ${e.message}`);let t=`${n}.backup-${Date.now()}`;S.existsSync(n)&&(S.copyFileSync(n,t),h(`info`,`Created backup of existing mcp.json at ${t}`));let r={mcpServers:i};S.writeFileSync(n,R(r)+`
+`),h(`warn`,`Created new MCP configuration file (backup of original file was created if it existed)`)}}else{let e={mcpServers:i};S.writeFileSync(n,R(e)+`
+`),h(`success`,`Created MCP configuration file at ${n}`)}h(`info`,`MCP server will use the installed task-master-ai package`)}function Ce(e,t){if(!t)return{success:!0,removed:!1,deleted:!1,error:null,hasOtherServers:!1};let n=C.join(e,t),r={success:!1,removed:!1,deleted:!1,error:null,hasOtherServers:!1};if(!S.existsSync(n))return r.success=!0,r.removed=!1,h(`debug`,`[MCP Config] MCP config file does not exist: ${n}`),r;try{let e=JSON.parse(S.readFileSync(n,`utf8`));if(!e.mcpServers)return r.success=!0,r.removed=!1,h(`debug`,`[MCP Config] No mcpServers section found in: ${n}`),r;if(!(e.mcpServers[`task-master-ai`]||Object.values(e.mcpServers).some(e=>e.args&&Array.isArray(e.args)&&e.args.some(e=>typeof e==`string`&&e.includes(`task-master-ai`)))))return r.success=!0,r.removed=!1,h(`debug`,`[MCP Config] Task Master not found in MCP config: ${n}`),r;delete e.mcpServers[`task-master-ai`],Object.keys(e.mcpServers).forEach(t=>{let n=e.mcpServers[t];n.args&&Array.isArray(n.args)&&n.args.some(e=>typeof e==`string`&&e.includes(`task-master-ai`))&&(delete e.mcpServers[t],h(`debug`,`[MCP Config] Removed server '${t}' containing task-master-ai`))});let t=Object.keys(e.mcpServers);r.hasOtherServers=t.length>0,r.hasOtherServers?(S.writeFileSync(n,R(e)+`
+`),r.success=!0,r.removed=!0,r.deleted=!1,h(`info`,`[MCP Config] Removed Task Master from MCP config, preserving other servers: ${t.join(`, `)}`)):(S.rmSync(n,{force:!0}),r.success=!0,r.removed=!0,r.deleted=!0,h(`info`,`[MCP Config] Removed MCP config file (no other servers remaining): ${n}`))}catch(e){r.error=e.message,h(`error`,`[MCP Config] Failed to remove Task Master from MCP config: ${e.message}`)}return r}function z(e){let{name:t,description:n,content:r,argumentHint:i,mode:a}=e;return{type:`static`,metadata:{name:t,description:n,...i&&{argumentHint:i},...a&&{mode:a}},content:r}}function B(e,t,n,r,i){if(!r.includes(`$ARGUMENTS`))throw Error(`Dynamic slash command "${e}" must contain $ARGUMENTS placeholder`);return{type:`dynamic`,metadata:{name:e,description:t,argumentHint:n,...i&&{mode:i}},content:r}}const we=B(`parse-prd`,`Parse PRD`,`<prd-file>`,`Parse a PRD document to generate tasks.
+
+Arguments: $ARGUMENTS (PRD file path)
+
+## Intelligent PRD Parsing
+
+Analyzes your requirements document and generates a complete task breakdown.
+
+## Execution
+
+\`\`\`bash
+task-master parse-prd --input=$ARGUMENTS
+\`\`\`
+
+## Parsing Process
+
+1. **Document Analysis**
+   - Extract key requirements
+   - Identify technical components
+   - Detect dependencies
+   - Estimate complexity
+
+2. **Task Generation**
+   - Create 10-15 tasks by default
+   - Include implementation tasks
+   - Add testing tasks
+   - Include documentation tasks
+   - Set logical dependencies
+
+3. **Smart Enhancements**
+   - Group related functionality
+   - Set appropriate priorities
+   - Add acceptance criteria
+   - Include test strategies
+
+## Options
+
+Parse arguments for modifiers:
+- Number after filename → \`--num-tasks\`
+- \`research\` → Use research mode
+- \`comprehensive\` → Generate more tasks
+
+## Post-Generation
+
+After parsing:
+1. Display task summary
+2. Show dependency graph
+3. Suggest task expansion for complex items
+4. Recommend sprint planning`,`solo`),Te=B(`parse-prd-with-research`,`Parse PRD With Research`,`<prd-file>`,`Parse PRD with enhanced research mode for better task generation.
+
+Arguments: $ARGUMENTS (PRD file path)
+
+## Research-Enhanced Parsing
+
+Uses the research AI provider (typically Perplexity) for more comprehensive task generation with current best practices.
+
+## Execution
+
+\`\`\`bash
+task-master parse-prd --input=$ARGUMENTS --research
+\`\`\`
+
+## Research Benefits
+
+1. **Current Best Practices**
+   - Latest framework patterns
+   - Security considerations
+   - Performance optimizations
+   - Accessibility requirements
+
+2. **Technical Deep Dive**
+   - Implementation approaches
+   - Library recommendations
+   - Architecture patterns
+   - Testing strategies
+
+3. **Comprehensive Coverage**
+   - Edge cases consideration
+   - Error handling tasks
+   - Monitoring setup
+   - Deployment tasks
+
+## Enhanced Output
+
+Research mode typically:
+- Generates more detailed tasks
+- Includes industry standards
+- Adds compliance considerations
+- Suggests modern tooling
+
+## When to Use
+
+- New technology domains
+- Complex requirements
+- Regulatory compliance needed
+- Best practices crucial`,`solo`),Ee=B(`analyze-complexity`,`Analyze Complexity`,`[options]`,`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
+\`\`\``,`solo`),De=B(`complexity-report`,`Complexity Report`,`[--file=<path>]`,`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
+\`\`\``,`solo`),Oe=B(`expand-task`,`Expand Task`,`<task-id>`,`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`,`solo`),ke=z({name:`expand-all-tasks`,description:`Expand All Tasks`,content:`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`,mode:`solo`}),Ae=B(`add-task`,`Add Task`,`<description>`,`Add new tasks with intelligent parsing and context awareness.
+
+Arguments: $ARGUMENTS
+
+## Smart Task Addition
+
+Parse natural language to create well-structured tasks.
+
+### 1. **Input Understanding**
+
+I'll intelligently parse your request:
+- Natural language → Structured task
+- Detect priority from keywords (urgent, ASAP, important)
+- Infer dependencies from context
+- Suggest complexity based on description
+- Determine task type (feature, bug, refactor, test, docs)
+
+### 2. **Smart Parsing Examples**
+
+**"Add urgent task to fix login bug"**
+→ Title: Fix login bug
+→ Priority: high
+→ Type: bug
+→ Suggested complexity: medium
+
+**"Create task for API documentation after task 23 is done"**
+→ Title: API documentation
+→ Dependencies: [23]
+→ Type: documentation
+→ Priority: medium
+
+**"Need to refactor auth module - depends on 12 and 15, high complexity"**
+→ Title: Refactor auth module
+→ Dependencies: [12, 15]
+→ Complexity: high
+→ Type: refactor
+
+### 3. **Context Enhancement**
+
+Based on current project state:
+- Suggest related existing tasks
+- Warn about potential conflicts
+- Recommend dependencies
+- Propose subtasks if complex
+
+### 4. **Interactive Refinement**
+
+\`\`\`yaml
+Task Preview:
+─────────────
+Title: [Extracted title]
+Priority: [Inferred priority]
+Dependencies: [Detected dependencies]
+Complexity: [Estimated complexity]
+
+Suggestions:
+- Similar task #34 exists, consider as dependency?
+- This seems complex, break into subtasks?
+- Tasks #45-47 work on same module
+\`\`\`
+
+### 5. **Validation & Creation**
+
+Before creating:
+- Validate dependencies exist
+- Check for duplicates
+- Ensure logical ordering
+- Verify task completeness
+
+### 6. **Smart Defaults**
+
+Intelligent defaults based on:
+- Task type patterns
+- Team conventions
+- Historical data
+- Current sprint/phase
+
+Result: High-quality tasks from minimal input.`,`solo`),je=B(`add-subtask`,`Add Subtask`,`<parent-id> <title>`,`Add a subtask to a parent task.
+
+Arguments: $ARGUMENTS
+
+Parse arguments to create a new subtask or convert existing task.
+
+## Adding Subtasks
+
+Creates subtasks to break down complex parent tasks into manageable pieces.
+
+## Argument Parsing
+
+Flexible natural language:
+- "add subtask to 5: implement login form"
+- "break down 5 with: setup, implement, test"
+- "subtask for 5: handle edge cases"
+- "5: validate user input" → adds subtask to task 5
+
+## Execution Modes
+
+### 1. Create New Subtask
+\`\`\`bash
+task-master add-subtask --parent=<id> --title="<title>" --description="<desc>"
+\`\`\`
+
+### 2. Convert Existing Task
+\`\`\`bash
+task-master add-subtask --parent=<id> --task-id=<existing-id>
+\`\`\`
+
+## Smart Features
+
+1. **Automatic Subtask Generation**
+   - If title contains "and" or commas, create multiple
+   - Suggest common subtask patterns
+   - Inherit parent's context
+
+2. **Intelligent Defaults**
+   - Priority based on parent
+   - Appropriate time estimates
+   - Logical dependencies between subtasks
+
+3. **Validation**
+   - Check parent task complexity
+   - Warn if too many subtasks
+   - Ensure subtask makes sense
+
+## Creation Process
+
+1. Parse parent task context
+2. Generate subtask with ID like "5.1"
+3. Set appropriate defaults
+4. Link to parent task
+5. Update parent's time estimate
+
+## Example Flows
+
+\`\`\`
+/taskmaster:add-subtask to 5: implement user authentication
+→ Created subtask #5.1: "implement user authentication"
+→ Parent task #5 now has 1 subtask
+→ Suggested next subtasks: tests, documentation
+
+/taskmaster:add-subtask 5: setup, implement, test
+→ Created 3 subtasks:
+  #5.1: setup
+  #5.2: implement
+  #5.3: test
+\`\`\`
+
+## Post-Creation
+
+- Show updated task hierarchy
+- Suggest logical next subtasks
+- Update complexity estimates
+- Recommend subtask order`,`solo`),Me=B(`remove-task`,`Remove Task`,`<task-id>`,`Remove a task permanently from the project.
+
+Arguments: $ARGUMENTS (task ID)
+
+Delete a task and handle all its relationships properly.
+
+## Task Removal
+
+Permanently removes a task while maintaining project integrity.
+
+## Argument Parsing
+
+- "remove task 5"
+- "delete 5"
+- "5" → remove task 5
+- Can include "-y" for auto-confirm
+
+## Execution
+
+\`\`\`bash
+task-master remove-task --id=<id> [-y]
+\`\`\`
+
+## Pre-Removal Analysis
+
+1. **Task Details**
+   - Current status
+   - Work completed
+   - Time invested
+   - Associated data
+
+2. **Relationship Check**
+   - Tasks that depend on this
+   - Dependencies this task has
+   - Subtasks that will be removed
+   - Blocking implications
+
+3. **Impact Assessment**
+   \`\`\`
+   Task Removal Impact
+   ━━━━━━━━━━━━━━━━━━
+   Task: #5 "Implement authentication" (in-progress)
+   Status: 60% complete (~8 hours work)
+
+   Will affect:
+   - 3 tasks depend on this (will be blocked)
+   - Has 4 subtasks (will be deleted)
+   - Part of critical path
+
+   ⚠️  This action cannot be undone
+   \`\`\`
+
+## Smart Warnings
+
+- Warn if task is in-progress
+- Show dependent tasks that will be blocked
+- Highlight if part of critical path
+- Note any completed work being lost
+
+## Removal Process
+
+1. Show comprehensive impact
+2. Require confirmation (unless -y)
+3. Update dependent task references
+4. Remove task and subtasks
+5. Clean up orphaned dependencies
+6. Log removal with timestamp
+
+## Alternative Actions
+
+Suggest before deletion:
+- Mark as cancelled instead
+- Convert to documentation
+- Archive task data
+- Transfer work to another task
+
+## Post-Removal
+
+- List affected tasks
+- Show broken dependencies
+- Update project statistics
+- Suggest dependency fixes
+- Recalculate timeline
+
+## Example Flows
+
+\`\`\`
+/taskmaster:remove-task 5
+→ Task #5 is in-progress with 8 hours logged
+→ 3 other tasks depend on this
+→ Suggestion: Mark as cancelled instead?
+Remove anyway? (y/n)
+
+/taskmaster:remove-task 5 -y
+→ Removed: Task #5 and 4 subtasks
+→ Updated: 3 task dependencies
+→ Warning: Tasks #7, #8, #9 now have missing dependency
+→ Run /taskmaster:fix-dependencies to resolve
+\`\`\`
+
+## Safety Features
+
+- Confirmation required
+- Impact preview
+- Removal logging
+- Suggest alternatives
+- No cascade delete of dependents`,`solo`),Ne=B(`remove-subtask`,`Remove Subtask`,`<subtask-id>`,`Remove a subtask from its parent task.
+
+Arguments: $ARGUMENTS
+
+Parse subtask ID to remove, with option to convert to standalone task.
+
+## Removing Subtasks
+
+Remove a subtask and optionally convert it back to a standalone task.
+
+## Argument Parsing
+
+- "remove subtask 5.1"
+- "delete 5.1"
+- "convert 5.1 to task" → remove and convert
+- "5.1 standalone" → convert to standalone
+
+## Execution Options
+
+### 1. Delete Subtask
+\`\`\`bash
+task-master remove-subtask --id=<parentId.subtaskId>
+\`\`\`
+
+### 2. Convert to Standalone
+\`\`\`bash
+task-master remove-subtask --id=<parentId.subtaskId> --convert
+\`\`\`
+
+## Pre-Removal Checks
+
+1. **Validate Subtask**
+   - Verify subtask exists
+   - Check completion status
+   - Review dependencies
+
+2. **Impact Analysis**
+   - Other subtasks that depend on it
+   - Parent task implications
+   - Data that will be lost
+
+## Removal Process
+
+### For Deletion:
+1. Confirm if subtask has work done
+2. Update parent task estimates
+3. Remove subtask and its data
+4. Clean up dependencies
+
+### For Conversion:
+1. Assign new standalone task ID
+2. Preserve all task data
+3. Update dependency references
+4. Maintain task history
+
+## Smart Features
+
+- Warn if subtask is in-progress
+- Show impact on parent task
+- Preserve important data
+- Update related estimates
+
+## Example Flows
+
+\`\`\`
+/taskmaster:remove-subtask 5.1
+→ Warning: Subtask #5.1 is in-progress
+→ This will delete all subtask data
+→ Parent task #5 will be updated
+Confirm deletion? (y/n)
+
+/taskmaster:remove-subtask 5.1 convert
+→ Converting subtask #5.1 to standalone task #89
+→ Preserved: All task data and history
+→ Updated: 2 dependency references
+→ New task #89 is now independent
+\`\`\`
+
+## Post-Removal
+
+- Update parent task status
+- Recalculate estimates
+- Show updated hierarchy
+- Suggest next actions`,`solo`),Pe=B(`remove-subtasks`,`Remove Subtasks`,`<task-id>`,`Clear all subtasks from a specific task.
+
+Arguments: $ARGUMENTS (task ID)
+
+Remove all subtasks from a parent task at once.
+
+## Clearing Subtasks
+
+Bulk removal of all subtasks from a parent task.
+
+## Execution
+
+\`\`\`bash
+task-master remove-subtasks --id=$ARGUMENTS
+\`\`\`
+
+## Pre-Clear Analysis
+
+1. **Subtask Summary**
+   - Number of subtasks
+   - Completion status of each
+   - Work already done
+   - Dependencies affected
+
+2. **Impact Assessment**
+   - Data that will be lost
+   - Dependencies to be removed
+   - Effect on project timeline
+   - Parent task implications
+
+## Confirmation Required
+
+\`\`\`
+Remove Subtasks Confirmation
+━━━━━━━━━━━━━━━━━━━━━━━━━
+Parent Task: #5 "Implement user authentication"
+Subtasks to remove: 4
+- #5.1 "Setup auth framework" (done)
+- #5.2 "Create login form" (in-progress)
+- #5.3 "Add validation" (pending)
+- #5.4 "Write tests" (pending)
+
+⚠️  This will permanently delete all subtask data
+Continue? (y/n)
+\`\`\`
+
+## Smart Features
+
+- Option to convert to standalone tasks
+- Backup task data before clearing
+- Preserve completed work history
+- Update parent task appropriately
+
+## Process
+
+1. List all subtasks for confirmation
+2. Check for in-progress work
+3. Remove all subtasks
+4. Update parent task
+5. Clean up dependencies
+
+## Alternative Options
+
+Suggest alternatives:
+- Convert important subtasks to tasks
+- Keep completed subtasks
+- Archive instead of delete
+- Export subtask data first
+
+## Post-Clear
+
+- Show updated parent task
+- Recalculate time estimates
+- Update task complexity
+- Suggest next steps
+
+## Example
+
+\`\`\`
+/taskmaster:remove-subtasks 5
+→ Found 4 subtasks to remove
+→ Warning: Subtask #5.2 is in-progress
+→ Cleared all subtasks from task #5
+→ Updated parent task estimates
+→ Suggestion: Consider re-expanding with better breakdown
+\`\`\``,`solo`),Fe=z({name:`remove-all-subtasks`,description:`Remove All Subtasks`,content:`Clear all subtasks from all tasks globally.
+
+## Global Subtask Clearing
+
+Remove all subtasks across the entire project. Use with extreme caution.
+
+## Execution
+
+\`\`\`bash
+task-master clear-subtasks --all
+\`\`\`
+
+## Pre-Clear Analysis
+
+1. **Project-Wide Summary**
+   \`\`\`
+   Global Subtask Summary
+   ━━━━━━━━━━━━━━━━━━━━
+   Total parent tasks: 12
+   Total subtasks: 47
+   - Completed: 15
+   - In-progress: 8
+   - Pending: 24
+
+   Work at risk: ~120 hours
+   \`\`\`
+
+2. **Critical Warnings**
+   - In-progress subtasks that will lose work
+   - Completed subtasks with valuable history
+   - Complex dependency chains
+   - Integration test results
+
+## Double Confirmation
+
+\`\`\`
+⚠️  DESTRUCTIVE OPERATION WARNING ⚠️
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+This will remove ALL 47 subtasks from your project
+Including 8 in-progress and 15 completed subtasks
+
+This action CANNOT be undone
+
+Type 'CLEAR ALL SUBTASKS' to confirm:
+\`\`\`
+
+## Smart Safeguards
+
+- Require explicit confirmation phrase
+- Create automatic backup
+- Log all removed data
+- Option to export first
+
+## Use Cases
+
+Valid reasons for global clear:
+- Project restructuring
+- Major pivot in approach
+- Starting fresh breakdown
+- Switching to different task organization
+
+## Process
+
+1. Full project analysis
+2. Create backup file
+3. Show detailed impact
+4. Require confirmation
+5. Execute removal
+6. Generate summary report
+
+## Alternative Suggestions
+
+Before clearing all:
+- Export subtasks to file
+- Clear only pending subtasks
+- Clear by task category
+- Archive instead of delete
+
+## Post-Clear Report
+
+\`\`\`
+Global Subtask Clear Complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Removed: 47 subtasks from 12 tasks
+Backup saved: .taskmaster/backup/subtasks-20240115.json
+Parent tasks updated: 12
+Time estimates adjusted: Yes
+
+Next steps:
+- Review updated task list
+- Re-expand complex tasks as needed
+- Check project timeline
+\`\`\``,mode:`solo`}),Ie=B(`convert-task-to-subtask`,`Convert Task To Subtask`,`<parent-id> <task-id>`,`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`,`solo`),Le=B(`add-dependency`,`Add Dependency`,`<task-id> <depends-on-id>`,`Add a dependency between tasks.
+
+Arguments: $ARGUMENTS
+
+Parse the task IDs to establish dependency relationship.
+
+## Adding Dependencies
+
+Creates a dependency where one task must be completed before another can start.
+
+## Argument Parsing
+
+Parse natural language or IDs:
+- "make 5 depend on 3" → task 5 depends on task 3
+- "5 needs 3" → task 5 depends on task 3
+- "5 3" → task 5 depends on task 3
+- "5 after 3" → task 5 depends on task 3
+
+## Execution
+
+\`\`\`bash
+task-master add-dependency --id=<task-id> --depends-on=<dependency-id>
+\`\`\`
+
+## Validation
+
+Before adding:
+1. **Verify both tasks exist**
+2. **Check for circular dependencies**
+3. **Ensure dependency makes logical sense**
+4. **Warn if creating complex chains**
+
+## Smart Features
+
+- Detect if dependency already exists
+- Suggest related dependencies
+- Show impact on task flow
+- Update task priorities if needed
+
+## Post-Addition
+
+After adding dependency:
+1. Show updated dependency graph
+2. Identify any newly blocked tasks
+3. Suggest task order changes
+4. Update project timeline
+
+## Example Flows
+
+\`\`\`
+/taskmaster:add-dependency 5 needs 3
+→ Task #5 now depends on Task #3
+→ Task #5 is now blocked until #3 completes
+→ Suggested: Also consider if #5 needs #4
+\`\`\``,`solo`),Re=B(`remove-dependency`,`Remove Dependency`,`<task-id> <depends-on-id>`,`Remove a dependency between tasks.
+
+Arguments: $ARGUMENTS
+
+Parse the task IDs to remove dependency relationship.
+
+## Removing Dependencies
+
+Removes a dependency relationship, potentially unblocking tasks.
+
+## Argument Parsing
+
+Parse natural language or IDs:
+- "remove dependency between 5 and 3"
+- "5 no longer needs 3"
+- "unblock 5 from 3"
+- "5 3" → remove dependency of 5 on 3
+
+## Execution
+
+\`\`\`bash
+task-master remove-dependency --id=<task-id> --depends-on=<dependency-id>
+\`\`\`
+
+## Pre-Removal Checks
+
+1. **Verify dependency exists**
+2. **Check impact on task flow**
+3. **Warn if it breaks logical sequence**
+4. **Show what will be unblocked**
+
+## Smart Analysis
+
+Before removing:
+- Show why dependency might have existed
+- Check if removal makes tasks executable
+- Verify no critical path disruption
+- Suggest alternative dependencies
+
+## Post-Removal
+
+After removing:
+1. Show updated task status
+2. List newly unblocked tasks
+3. Update project timeline
+4. Suggest next actions
+
+## Safety Features
+
+- Confirm if removing critical dependency
+- Show tasks that become immediately actionable
+- Warn about potential issues
+- Keep removal history
+
+## Example
+
+\`\`\`
+/taskmaster:remove-dependency 5 from 3
+→ Removed: Task #5 no longer depends on #3
+→ Task #5 is now UNBLOCKED and ready to start
+→ Warning: Consider if #5 still needs #2 completed first
+\`\`\``,`solo`),ze=z({name:`fix-dependencies`,description:`Fix Dependencies`,content:`Automatically fix dependency issues found during validation.
+
+## Automatic Dependency Repair
+
+Intelligently fixes common dependency problems while preserving project logic.
+
+## Execution
+
+\`\`\`bash
+task-master fix-dependencies
+\`\`\`
+
+## What Gets Fixed
+
+### 1. **Auto-Fixable Issues**
+- Remove references to deleted tasks
+- Break simple circular dependencies
+- Remove self-dependencies
+- Clean up duplicate dependencies
+
+### 2. **Smart Resolutions**
+- Reorder dependencies to maintain logic
+- Suggest task merging for over-dependent tasks
+- Flatten unnecessary dependency chains
+- Remove redundant transitive dependencies
+
+### 3. **Manual Review Required**
+- Complex circular dependencies
+- Critical path modifications
+- Business logic dependencies
+- High-impact changes
+
+## Fix Process
+
+1. **Analysis Phase**
+   - Run validation check
+   - Categorize issues by type
+   - Determine fix strategy
+
+2. **Execution Phase**
+   - Apply automatic fixes
+   - Log all changes made
+   - Preserve task relationships
+
+3. **Verification Phase**
+   - Re-validate after fixes
+   - Show before/after comparison
+   - Highlight manual fixes needed
+
+## Smart Features
+
+- Preserves intended task flow
+- Minimal disruption approach
+- Creates fix history/log
+- Suggests manual interventions
+
+## Output Example
+
+\`\`\`
+Dependency Auto-Fix Report
+━━━━━━━━━━━━━━━━━━━━━━━━
+Fixed Automatically:
+✅ Removed 2 references to deleted tasks
+✅ Resolved 1 self-dependency
+✅ Cleaned 3 redundant dependencies
+
+Manual Review Needed:
+⚠️ Complex circular dependency: #12 → #15 → #18 → #12
+  Suggestion: Make #15 not depend on #12
+⚠️ Task #45 has 8 dependencies
+  Suggestion: Break into subtasks
+
+Run '/taskmaster:validate-dependencies' to verify fixes
+\`\`\`
+
+## Safety
+
+- Preview mode available
+- Rollback capability
+- Change logging
+- No data loss`,mode:`solo`}),Be=z({name:`validate-dependencies`,description:`Validate Dependencies`,content:`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 \`/taskmaster:fix-dependencies\` to auto-fix
+- Manually adjust problematic dependencies
+- Rerun to verify fixes`,mode:`solo`}),Ve=z({name:`setup-models`,description:`Setup Models`,content:`Run interactive setup to configure AI models.
+
+## Interactive Model Configuration
+
+Guides you through setting up AI providers for Task Master.
+
+## Execution
+
+\`\`\`bash
+task-master models --setup
+\`\`\`
+
+## Setup Process
+
+1. **Environment Check**
+   - Detect existing API keys
+   - Show current configuration
+   - Identify missing providers
+
+2. **Provider Selection**
+   - Choose main provider (required)
+   - Select research provider (recommended)
+   - Configure fallback (optional)
+
+3. **API Key Configuration**
+   - Prompt for missing keys
+   - Validate key format
+   - Test connectivity
+   - Save configuration
+
+## Smart Recommendations
+
+Based on your needs:
+- **For best results**: Claude + Perplexity
+- **Budget conscious**: GPT-3.5 + Perplexity
+- **Maximum capability**: GPT-4 + Perplexity + Claude fallback
+
+## Configuration Storage
+
+Keys can be stored in:
+1. Environment variables (recommended)
+2. \`.env\` file in project
+3. Global \`.taskmaster/config\`
+
+## Post-Setup
+
+After configuration:
+- Test each provider
+- Show usage examples
+- Suggest next steps
+- Verify parse-prd works`,mode:`solo`}),He=z({name:`view-models`,description:`View Models`,content:`View current AI model configuration.
+
+## Model Configuration Display
+
+Shows the currently configured AI providers and models for Task Master.
+
+## Execution
+
+\`\`\`bash
+task-master models
+\`\`\`
+
+## Information Displayed
+
+1. **Main Provider**
+   - Model ID and name
+   - API key status (configured/missing)
+   - Usage: Primary task generation
+
+2. **Research Provider**
+   - Model ID and name
+   - API key status
+   - Usage: Enhanced research mode
+
+3. **Fallback Provider**
+   - Model ID and name
+   - API key status
+   - Usage: Backup when main fails
+
+## Visual Status
+
+\`\`\`
+Task Master AI Model Configuration
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Main:     ✅ claude-3-5-sonnet (configured)
+Research: ✅ perplexity-sonar (configured)
+Fallback: ⚠️  Not configured (optional)
+
+Available Models:
+- claude-3-5-sonnet
+- gpt-4-turbo
+- gpt-3.5-turbo
+- perplexity-sonar
+\`\`\`
+
+## Next Actions
+
+Based on configuration:
+- If missing API keys → Suggest setup
+- If no research model → Explain benefits
+- If all configured → Show usage tips`,mode:`solo`}),Ue=z({name:`install-taskmaster`,description:`Install TaskMaster`,content:`Check if Task Master is installed and install it if needed.
+
+This command helps you get Task Master set up globally on your system.
+
+## Detection and Installation Process
+
+1. **Check Current Installation**
+   \`\`\`bash
+   # Check if task-master command exists
+   which task-master || echo "Task Master not found"
+
+   # Check npm global packages
+   npm list -g task-master-ai
+   \`\`\`
+
+2. **System Requirements Check**
+   \`\`\`bash
+   # Verify Node.js is installed
+   node --version
+
+   # Verify npm is installed
+   npm --version
+
+   # Check Node version (need 16+)
+   \`\`\`
+
+3. **Install Task Master Globally**
+   If not installed, run:
+   \`\`\`bash
+   npm install -g task-master-ai
+   \`\`\`
+
+4. **Verify Installation**
+   \`\`\`bash
+   # Check version
+   task-master --version
+
+   # Verify command is available
+   which task-master
+   \`\`\`
+
+5. **Initial Setup**
+   \`\`\`bash
+   # Initialize in current directory
+   task-master init
+   \`\`\`
+
+6. **Configure AI Provider**
+   Ensure you have at least one AI provider API key set:
+   \`\`\`bash
+   # Check current configuration
+   task-master models --status
+
+   # If no API keys found, guide setup
+   echo "You'll need at least one API key:"
+   echo "- ANTHROPIC_API_KEY for Claude"
+   echo "- OPENAI_API_KEY for GPT models"
+   echo "- PERPLEXITY_API_KEY for research"
+   echo ""
+   echo "Set them in your shell profile or .env file"
+   \`\`\`
+
+7. **Quick Test**
+   \`\`\`bash
+   # Create a test PRD
+   echo "Build a simple hello world API" > test-prd.txt
+
+   # Try parsing it
+   task-master parse-prd test-prd.txt -n 3
+   \`\`\`
+
+## Troubleshooting
+
+If installation fails:
+
+**Permission Errors:**
+\`\`\`bash
+# Try with sudo (macOS/Linux)
+sudo npm install -g task-master-ai
+
+# Or fix npm permissions
+npm config set prefix ~/.npm-global
+export PATH=~/.npm-global/bin:$PATH
+\`\`\`
+
+**Network Issues:**
+\`\`\`bash
+# Use different registry
+npm install -g task-master-ai --registry https://registry.npmjs.org/
+\`\`\`
+
+**Node Version Issues:**
+\`\`\`bash
+# Install Node 20+ via nvm
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
+nvm install 20
+nvm use 20
+\`\`\`
+
+## Success Confirmation
+
+Once installed, you should see:
+\`\`\`
+✅ Task Master installed
+✅ Command 'task-master' available globally
+✅ AI provider configured
+✅ Ready to use slash commands!
+
+Try: /taskmaster:init your-prd.md
+\`\`\`
+
+## Next Steps
+
+After installation:
+1. Run \`/taskmaster:status\` to verify setup
+2. Configure AI providers with \`/taskmaster:setup-models\`
+3. Start using Task Master commands!`,mode:`solo`}),We=z({name:`quick-install-taskmaster`,description:`Quick Install TaskMaster`,content:`Quick install Task Master globally if not already installed.
+
+Execute this streamlined installation:
+
+\`\`\`bash
+# Check and install in one command
+task-master --version 2>/dev/null || npm install -g task-master-ai
+
+# Verify installation
+task-master --version
+
+# Quick setup check
+task-master models --status || echo "Note: You'll need to set up an AI provider API key"
+\`\`\`
+
+If you see "command not found" after installation, you may need to:
+1. Restart your terminal
+2. Or add npm global bin to PATH: \`export PATH=$(npm bin -g):$PATH\`
+
+Once installed, you can use all the Task Master commands!
+
+Quick test: Run \`/taskmaster:help\` to see all available commands.`,mode:`solo`}),Ge=B(`to-review`,`To Review`,`<task-id>`,`Set a task's status to review.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Marking Task for Review
+
+This status indicates work is complete but needs verification before final approval.
+
+## When to Use Review Status
+
+- Code complete but needs peer review
+- Implementation done but needs testing
+- Documentation written but needs proofreading
+- Design complete but needs stakeholder approval
+
+## Execution
+
+\`\`\`bash
+task-master set-status --id=$ARGUMENTS --status=review
+\`\`\`
+
+## Review Preparation
+
+When setting to review:
+1. **Generate Review Checklist**
+   - Link to PR/MR if applicable
+   - Highlight key changes
+   - Note areas needing attention
+   - Include test results
+
+2. **Documentation**
+   - Update task with review notes
+   - Link relevant artifacts
+   - Specify reviewers if known
+
+3. **Smart Actions**
+   - Create review reminders
+   - Track review duration
+   - Suggest reviewers based on expertise
+   - Prepare rollback plan if needed`,`solo`),Ke=B(`to-deferred`,`To Deferred`,`<task-id>`,`Defer a task for later consideration.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Deferring a Task
+
+This status indicates a task is valid but not currently actionable or prioritized.
+
+## Valid Reasons for Deferral
+
+- Waiting for external dependencies
+- Reprioritized for future sprint
+- Blocked by technical limitations
+- Resource constraints
+- Strategic timing considerations
+
+## Execution
+
+\`\`\`bash
+task-master set-status --id=$ARGUMENTS --status=deferred
+\`\`\`
+
+## Deferral Management
+
+When deferring:
+1. **Document Reason**
+   - Capture why it's being deferred
+   - Set reactivation criteria
+   - Note any partial work completed
+
+2. **Impact Analysis**
+   - Check dependent tasks
+   - Update project timeline
+   - Notify affected stakeholders
+
+3. **Future Planning**
+   - Set review reminders
+   - Tag for specific milestone
+   - Preserve context for reactivation
+   - Link to blocking issues
+
+## Smart Tracking
+
+- Monitor deferral duration
+- Alert when criteria met
+- Prevent scope creep
+- Regular review cycles`,`solo`),qe=B(`to-cancelled`,`To Cancelled`,`<task-id>`,`Cancel a task permanently.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Cancelling a Task
+
+This status indicates a task is no longer needed and won't be completed.
+
+## Valid Reasons for Cancellation
+
+- Requirements changed
+- Feature deprecated
+- Duplicate of another task
+- Strategic pivot
+- Technical approach invalidated
+
+## Pre-Cancellation Checks
+
+1. Confirm no critical dependencies
+2. Check for partial implementation
+3. Verify cancellation rationale
+4. Document lessons learned
+
+## Execution
+
+\`\`\`bash
+task-master set-status --id=$ARGUMENTS --status=cancelled
+\`\`\`
+
+## Cancellation Impact
+
+When cancelling:
+1. **Dependency Updates**
+   - Notify dependent tasks
+   - Update project scope
+   - Recalculate timelines
+
+2. **Clean-up Actions**
+   - Remove related branches
+   - Archive any work done
+   - Update documentation
+   - Close related issues
+
+3. **Learning Capture**
+   - Document why cancelled
+   - Note what was learned
+   - Update estimation models
+   - Prevent future duplicates
+
+## Historical Preservation
+
+- Keep for reference
+- Tag with cancellation reason
+- Link to replacement if any
+- Maintain audit trail`,`solo`),Je=B(`init-project`,`Init Project`,`[prd-file]`,`Initialize a new Task Master project.
+
+Arguments: $ARGUMENTS
+
+Parse arguments to determine initialization preferences.
+
+## Initialization Process
+
+1. **Parse Arguments**
+   - PRD file path (if provided)
+   - Project name
+   - Auto-confirm flag (-y)
+
+2. **Project Setup**
+   \`\`\`bash
+   task-master init
+   \`\`\`
+
+3. **Smart Initialization**
+   - Detect existing project files
+   - Suggest project name from directory
+   - Check for git repository
+   - Verify AI provider configuration
+
+## Configuration Options
+
+Based on arguments:
+- \`quick\` / \`-y\` → Skip confirmations
+- \`<file.md>\` → Use as PRD after init
+- \`--name=<name>\` → Set project name
+- \`--description=<desc>\` → Set description
+
+## Post-Initialization
+
+After successful init:
+1. Show project structure created
+2. Verify AI models configured
+3. Suggest next steps:
+   - Parse PRD if available
+   - Configure AI providers
+   - Set up git hooks
+   - Create first tasks
+
+## Integration
+
+If PRD file provided:
+\`\`\`
+/taskmaster:init my-prd.md
+→ Automatically runs parse-prd after init
+\`\`\``,`solo`),Ye=B(`init-project-quick`,`Init Project Quick`,`[prd-file]`,`Quick initialization with auto-confirmation.
+
+Arguments: $ARGUMENTS
+
+Initialize a Task Master project without prompts, accepting all defaults.
+
+## Quick Setup
+
+\`\`\`bash
+task-master init -y
+\`\`\`
+
+## What It Does
+
+1. Creates \`.taskmaster/\` directory structure
+2. Initializes empty \`tasks.json\`
+3. Sets up default configuration
+4. Uses directory name as project name
+5. Skips all confirmation prompts
+
+## Smart Defaults
+
+- Project name: Current directory name
+- Description: "Task Master Project"
+- Model config: Existing environment vars
+- Task structure: Standard format
+
+## Next Steps
+
+After quick init:
+1. Configure AI models if needed:
+   \`\`\`
+   /taskmaster:models/setup
+   \`\`\`
+
+2. Parse PRD if available:
+   \`\`\`
+   /taskmaster:parse-prd <file>
+   \`\`\`
+
+3. Or create first task:
+   \`\`\`
+   /taskmaster:add-task create initial setup
+   \`\`\`
+
+Perfect for rapid project setup!`,`solo`);z({name:`generate-tasks`,description:`Generate Task Files`,content:`Generate individual task files from tasks.json.
+
+## Task File Generation
+
+Creates separate markdown files for each task, perfect for AI agents or documentation.
+
+## Execution
+
+\`\`\`bash
+task-master generate
+\`\`\`
+
+## What It Creates
+
+For each task, generates a file like \`task_001.md\`:
+
+\`\`\`
+Task ID: 1
+Title: Implement user authentication
+Status: pending
+Priority: high
+Dependencies: []
+Created: 2024-01-15
+Complexity: 7
+
+## Description
+Create a secure user authentication system with login, logout, and session management.
+
+## Details
+- Use JWT tokens for session management
+- Implement secure password hashing
+- Add remember me functionality
+- Include password reset flow
+
+## Test Strategy
+- Unit tests for auth functions
+- Integration tests for login flow
+- Security testing for vulnerabilities
+- Performance tests for concurrent logins
+
+## Subtasks
+1.1 Setup authentication framework (pending)
+1.2 Create login endpoints (pending)
+1.3 Implement session management (pending)
+1.4 Add password reset (pending)
+\`\`\`
+
+## File Organization
+
+Creates structure:
+\`\`\`
+.taskmaster/
+└── tasks/
+    ├── task_001.md
+    ├── task_002.md
+    ├── task_003.md
+    └── ...
+\`\`\`
+
+## Smart Features
+
+1. **Consistent Formatting**
+   - Standardized structure
+   - Clear sections
+   - AI-readable format
+   - Markdown compatible
+
+2. **Contextual Information**
+   - Full task details
+   - Related task references
+   - Progress indicators
+   - Implementation notes
+
+3. **Incremental Updates**
+   - Only regenerate changed tasks
+   - Preserve custom additions
+   - Track generation timestamp
+   - Version control friendly
+
+## Use Cases
+
+- **AI Context**: Provide task context to AI assistants
+- **Documentation**: Standalone task documentation
+- **Archival**: Task history preservation
+- **Sharing**: Send specific tasks to team members
+- **Review**: Easier task review process
+
+## Post-Generation
+
+\`\`\`
+Task File Generation Complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━
+Generated: 45 task files
+Location: .taskmaster/tasks/
+Total size: 156 KB
+
+New files: 5
+Updated files: 12
+Unchanged: 28
+
+Ready for:
+- AI agent consumption
+- Version control
+- Team distribution
+\`\`\`
+
+## Integration Benefits
+
+- Git-trackable task history
+- Easy task sharing
+- AI tool compatibility
+- Offline task access
+- Backup redundancy`,mode:`solo`});const V=[we,Te,Ee,De,Oe,ke,Ae,je,Me,Ne,Pe,Fe,Ie,Le,Re,ze,Be,Ve,He,Ue,We,Ge,Ke,qe,Je,Ye,z({name:`goham`,description:`Start Working with Hamster Brief`,argumentHint:`[brief-url]`,mode:`team`,content:`# Start Working with Hamster Brief
+
+End-to-end workflow for working on tasks from a connected Hamster brief. All tasks from the brief are worked on in a single branch, with one PR created at the end.
+
+## Step 1: Verify Connection & Authentication
+
+\`\`\`bash
+# Check current context and authentication status
+tm context
+\`\`\`
+
+If not connected or authentication fails:
+- Get brief URL from user if not available
+- Connect: \`tm context <brief url>\`
+- Refresh token if needed: \`tm auth refresh\`
+
+## Step 2: List Available Tasks
+
+\`\`\`bash
+# View all tasks from the brief
+tm list
+\`\`\`
+
+Review the task list to understand what needs to be done. Note the total number of tasks.
+
+## Step 3: Initialize Git Branch for Brief
+
+\`\`\`bash
+# Ensure you're on dev branch and pull latest
+git checkout dev
+git pull origin dev
+
+# Create a single branch for the entire brief (e.g., hamster-brief-YYYY-MM-DD or brief-specific name)
+git checkout -b hamster-brief
+
+# Verify branch creation
+git branch
+\`\`\`
+
+**Note**: This branch will be used for ALL tasks in the brief. Do not create separate branches per task.
+
+## Step 4: Task Loop (Repeat for Each Task)
+
+Work through all tasks sequentially in the same branch:
+
+### 4.1: Read Task Details
+
+\`\`\`bash
+# Get detailed information about the task
+tm show 1
+
+# If task has subtasks, examine them all
+tm show 1,1.1,1.2,1.3  # Adjust IDs as needed
+\`\`\`
+
+### 4.2: Log Initial Context
+
+\`\`\`bash
+# Document task understanding and initial findings
+tm update-task -i 1 --append --prompt="Starting task implementation.
+
+Initial context:
+- Task requirements: [summarize key requirements]
+- Dependencies identified: [list any dependencies]
+- Files that may need modification: [list relevant files]
+- Approach planned: [brief implementation approach]"
+\`\`\`
+
+### 4.3: Mark Task as In-Progress
+
+\`\`\`bash
+# Mark task and first subtask (if exists) as in-progress
+tm set-status -i 1,1.1 -s in-progress
+\`\`\`
+
+### 4.4: Subtask Implementation Loop
+
+For each subtask (1.1, 1.2, 1.3, etc.):
+
+#### 4.4.1: Read Subtask Details
+\`\`\`bash
+tm show 1.1  # Replace with current subtask ID
+\`\`\`
+
+#### 4.4.2: Log Research & Context Gathering
+\`\`\`bash
+# Document findings during implementation
+tm update-task -i 1 --append --prompt="Subtask 1.1 - Context gathered:
+
+- Code exploration findings: [what you discovered]
+- Implementation approach: [how you plan to implement]
+- Key decisions made: [important choices]
+- Challenges encountered: [any blockers or issues]"
+\`\`\`
+
+#### 4.4.3: Implement Subtask
+- Write code following the subtask requirements
+- Make necessary changes to files
+
+#### 4.4.4: Quality Verification
+\`\`\`bash
+# Run linting
+pnpm lint
+
+# Run type checking
+pnpm typecheck
+
+# If either fails, fix issues and re-run until both pass
+\`\`\`
+
+#### 4.4.5: CodeRabbit Review
+\`\`\`bash
+# Generate code review (wait for plain text results)
+coderabbit --prompt-only
+
+# Review the output and address any critical issues if needed
+\`\`\`
+
+#### 4.4.6: Log Implementation Completion
+\`\`\`bash
+# Document what was completed
+tm update-task -i 1 --append --prompt="Subtask 1.1 - Implementation complete:
+
+- Files modified: [list files changed]
+- Key changes: [summary of implementation]
+- CodeRabbit feedback addressed: [if any issues were fixed]
+- Ready for commit"
+\`\`\`
+
+#### 4.4.7: Commit Subtask Work
+\`\`\`bash
+# Stage changes
+git add .
+
+# Commit with detailed message following git_workflow.mdc format
+git commit -m "feat(task-1): Complete subtask 1.1 - [Subtask Title]
+
+- Implementation details
+- Key changes made
+- Files modified: [list files]
+- CodeRabbit review completed
+
+Subtask 1.1: [Brief description of what was accomplished]
+Relates to Task 1: [Main task title]"
+\`\`\`
+
+#### 4.4.8: Mark Subtask as Done
+\`\`\`bash
+tm set-status -i 1.1 -s done
+\`\`\`
+
+#### 4.4.9: Move to Next Subtask
+Repeat steps 4.4.1 through 4.4.8 for the next subtask (1.2, 1.3, etc.)
+
+### 4.5: Complete Parent Task
+
+After all subtasks are complete:
+
+#### 4.5.1: Final Quality Checks
+\`\`\`bash
+# Final linting
+pnpm lint
+
+# Final type checking
+pnpm typecheck
+
+# Final CodeRabbit review
+coderabbit --prompt-only
+
+# Address any remaining issues if critical
+\`\`\`
+
+#### 4.5.2: Log Task Completion
+\`\`\`bash
+# Document final task completion
+tm update-task -i 1 --append --prompt="Task 1 - Complete:
+
+- All subtasks completed: [list all subtasks]
+- Final verification passed: lint, typecheck, CodeRabbit review
+- Files changed: [comprehensive list]
+- Committed to brief branch"
+\`\`\`
+
+#### 4.5.3: Mark Parent Task as Done
+\`\`\`bash
+tm set-status -i 1 -s done
+\`\`\`
+
+**Note**: Do NOT push or create PR yet. Continue to next task in the same branch.
+
+### 4.6: Move to Next Task
+
+\`\`\`bash
+# Verify remaining tasks
+tm list
+
+# Continue with next task (e.g., Task 2)
+# Repeat steps 4.1 through 4.5 for Task 2, then Task 3, etc.
+\`\`\`
+
+## Step 5: Complete All Tasks
+
+Continue working through all tasks (Steps 4.1-4.6) until all tasks in the brief are complete. All work is committed to the same \`hamster-brief\` branch.
+
+## Step 6: Final Verification & PR Creation
+
+After ALL tasks are complete:
+
+### 6.1: Verify All Tasks Complete
+\`\`\`bash
+# Verify all tasks are done
+tm list
+
+# Should show all tasks with status 'done'
+\`\`\`
+
+### 6.2: Final Quality Checks
+\`\`\`bash
+# Final comprehensive checks
+pnpm lint
+pnpm typecheck
+coderabbit --prompt-only
+
+# Address any remaining issues if critical
+\`\`\`
+
+### 6.3: Push Branch
+\`\`\`bash
+# Push the brief branch to remote
+git push origin hamster-brief
+\`\`\`
+
+### 6.4: Create Pull Request to Dev
+\`\`\`bash
+# Get all task titles (adjust task IDs as needed)
+# Create comprehensive PR description
+
+gh pr create \\
+  --base dev \\
+  --title "Hamster Brief: Complete Implementation" \\
+  --body "## Brief Overview
+Completed all tasks from Hamster brief.
+
+## Tasks Completed
+- [x] Task 1: [Task 1 title]
+  - Subtasks: 1.1, 1.2, 1.3
+- [x] Task 2: [Task 2 title]
+  - Subtasks: 2.1, 2.2
+- [x] Task 3: [Task 3 title]
+  - [Continue listing all tasks]
+
+## Implementation Summary
+- Total tasks: [number]
+- Total subtasks: [number]
+- Files modified: [comprehensive list]
+- All quality checks passed
+
+## Quality Checks
+- Linting passed (pnpm lint)
+- Type checking passed (pnpm typecheck)
+- CodeRabbit review completed for all changes
+
+## Testing
+- [ ] Manual testing completed
+- [ ] All checks passing
+
+Complete implementation of Hamster brief tasks"
+\`\`\`
+
+## Step 7: Cleanup
+
+\`\`\`bash
+# After PR is merged, switch back to dev
+git checkout dev
+git pull origin dev
+
+# Delete local branch (optional)
+git branch -d hamster-brief
+\`\`\`
+
+## Important Notes
+
+- **Use ONLY**: \`tm list\`, \`tm show <id>\`, \`tm set-status\`, \`tm update-task\`, \`tm auth refresh\`, \`tm context <brief url>\`
+- **DON'T use MCP tools** - not compatible with Hamster integration
+- **Single branch per brief**: All tasks work in the same branch (\`hamster-brief\`)
+- **Single PR per brief**: One PR created after all tasks are complete
+- **Always target dev branch** - never main branch
+- **Regular logging**: Use \`tm update-task -i <id> --append\` frequently to document:
+  - Context gathered during exploration
+  - Implementation decisions made
+  - Challenges encountered
+  - Completion status
+- **Quality gates**: Never skip lint, typecheck, or CodeRabbit review
+- **Commit format**: Follow git_workflow.mdc commit message standards
+- **PR format**: Always use \`--base dev\` when creating PRs
+
+## Workflow Summary
+
+\`\`\`
+1. Verify connection -> tm context
+2. List tasks -> tm list
+3. Create single branch -> git checkout -b hamster-brief
+4. For each task (in same branch):
+   a. Read task -> tm show X
+   b. Log context -> tm update-task -i X --append
+   c. Mark in-progress -> tm set-status -i X,X.Y -s in-progress
+   d. For each subtask:
+      - Read -> tm show X.Y
+      - Log context -> tm update-task -i X --append
+      - Implement code
+      - Verify -> pnpm lint && pnpm typecheck
+      - Review -> coderabbit --prompt-only
+      - Log completion -> tm update-task -i X --append
+      - Commit -> git commit (following git_workflow.mdc format)
+      - Mark done -> tm set-status -i X.Y -s done
+   e. Final checks -> pnpm lint && pnpm typecheck && coderabbit --prompt-only
+   f. Log completion -> tm update-task -i X --append
+   g. Mark task done -> tm set-status -i X -s done
+   h. Continue to next task (same branch)
+5. After ALL tasks complete:
+   a. Final verification -> pnpm lint && pnpm typecheck && coderabbit --prompt-only
+   b. Push branch -> git push origin hamster-brief
+   c. Create PR -> gh pr create --base dev
+\`\`\`
+`}),B(`show-task`,`Show Task`,`<task-id>`,`Show detailed task information with rich context and insights.
+
+Arguments: $ARGUMENTS
+
+## Enhanced Task Display
+
+Parse arguments to determine what to show and how.
+
+### 1. **Smart Task Selection**
+
+Based on $ARGUMENTS:
+- Number → Show specific task with full context
+- "current" → Show active in-progress task(s)
+- "next" → Show recommended next task
+- "blocked" → Show all blocked tasks with reasons
+- "critical" → Show critical path tasks
+- Multiple IDs → Comparative view
+
+### 2. **Contextual Information**
+
+For each task, intelligently include:
+
+**Core Details**
+- Full task information (id, title, description, details)
+- Current status with history
+- Test strategy and acceptance criteria
+- Priority and complexity analysis
+
+**Relationships**
+- Dependencies (what it needs)
+- Dependents (what needs it)
+- Parent/subtask hierarchy
+- Related tasks (similar work)
+
+**Time Intelligence**
+- Created/updated timestamps
+- Time in current status
+- Estimated vs actual time
+- Historical completion patterns
+
+### 3. **Visual Enhancements**
+
+\`\`\`
+📋 Task #45: Implement User Authentication
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Status: 🟡 in-progress (2 hours)
+Priority: 🔴 High | Complexity: 73/100
+
+Dependencies: ✅ #41, ✅ #42, ⏳ #43 (blocked)
+Blocks: #46, #47, #52
+
+Progress: ████████░░ 80% complete
+
+Recent Activity:
+- 2h ago: Status changed to in-progress
+- 4h ago: Dependency #42 completed
+- Yesterday: Task expanded with 3 subtasks
+\`\`\`
+
+### 4. **Intelligent Insights**
+
+Based on task analysis:
+- **Risk Assessment**: Complexity vs time remaining
+- **Bottleneck Analysis**: Is this blocking critical work?
+- **Recommendation**: Suggested approach or concerns
+- **Similar Tasks**: How others completed similar work
+
+### 5. **Action Suggestions**
+
+Context-aware next steps:
+- If blocked → Show how to unblock
+- If complex → Suggest expansion
+- If in-progress → Show completion checklist
+- If done → Show dependent tasks ready to start
+
+### 6. **Multi-Task View**
+
+When showing multiple tasks:
+- Common dependencies
+- Optimal completion order
+- Parallel work opportunities
+- Combined complexity analysis`),B(`list-tasks`,`List Tasks`,`[filters]`,`List tasks with intelligent argument parsing.
+
+Parse arguments to determine filters and display options:
+- Status: pending, in-progress, done, review, deferred, cancelled
+- Priority: high, medium, low (or priority:high)
+- Special: subtasks, tree, dependencies, blocked
+- IDs: Direct numbers (e.g., "1,3,5" or "1-5")
+- Complex: "pending high" = pending AND high priority
+
+Arguments: $ARGUMENTS
+
+Let me parse your request intelligently:
+
+1. **Detect Filter Intent**
+   - If arguments contain status keywords → filter by status
+   - If arguments contain priority → filter by priority
+   - If arguments contain "subtasks" → include subtasks
+   - If arguments contain "tree" → hierarchical view
+   - If arguments contain numbers → show specific tasks
+   - If arguments contain "blocked" → show blocked tasks only
+
+2. **Smart Combinations**
+   Examples of what I understand:
+   - "pending high" → pending tasks with high priority
+   - "done today" → tasks completed today
+   - "blocked" → tasks with unmet dependencies
+   - "1-5" → tasks 1 through 5
+   - "subtasks tree" → hierarchical view with subtasks
+
+3. **Execute Appropriate Query**
+   Based on parsed intent, run the most specific task-master command
+
+4. **Enhanced Display**
+   - Group by relevant criteria
+   - Show most important information first
+   - Use visual indicators for quick scanning
+   - Include relevant metrics
+
+5. **Intelligent Suggestions**
+   Based on what you're viewing, suggest next actions:
+   - Many pending? → Suggest priority order
+   - Many blocked? → Show dependency resolution
+   - Looking at specific tasks? → Show related tasks`),z({name:`list-tasks-with-subtasks`,description:`List Tasks With Subtasks`,content:`List all tasks including their subtasks in a hierarchical view.
+
+This command shows all tasks with their nested subtasks, providing a complete project overview.
+
+## Execution
+
+Run the Task Master list command with subtasks flag:
+\`\`\`bash
+task-master list --with-subtasks
+\`\`\`
+
+## Enhanced Display
+
+I'll organize the output to show:
+- Parent tasks with clear indicators
+- Nested subtasks with proper indentation
+- Status badges for quick scanning
+- Dependencies and blockers highlighted
+- Progress indicators for tasks with subtasks
+
+## Smart Filtering
+
+Based on the task hierarchy:
+- Show completion percentage for parent tasks
+- Highlight blocked subtask chains
+- Group by functional areas
+- Indicate critical path items
+
+This gives you a complete tree view of your project structure.`}),B(`list-tasks-by-status`,`List Tasks By Status`,`<status>`,`List tasks filtered by a specific status.
+
+Arguments: $ARGUMENTS
+
+Parse the status from arguments and list only tasks matching that status.
+
+## Status Options
+- \`pending\` - Not yet started
+- \`in-progress\` - Currently being worked on
+- \`done\` - Completed
+- \`review\` - Awaiting review
+- \`deferred\` - Postponed
+- \`cancelled\` - Cancelled
+
+## Execution
+
+Based on $ARGUMENTS, run:
+\`\`\`bash
+task-master list --status=$ARGUMENTS
+\`\`\`
+
+## Enhanced Display
+
+For the filtered results:
+- Group by priority within the status
+- Show time in current status
+- Highlight tasks approaching deadlines
+- Display blockers and dependencies
+- Suggest next actions for each status group
+
+## Intelligent Insights
+
+Based on the status filter:
+- **Pending**: Show recommended start order
+- **In-Progress**: Display idle time warnings
+- **Done**: Show newly unblocked tasks
+- **Review**: Indicate review duration
+- **Deferred**: Show reactivation criteria
+- **Cancelled**: Display impact analysis`),B(`project-status`,`Project Status`,`[focus-area]`,`Enhanced status command with comprehensive project insights.
+
+Arguments: $ARGUMENTS
+
+## Intelligent Status Overview
+
+### 1. **Executive Summary**
+Quick dashboard view:
+- 🏃 Active work (in-progress tasks)
+- 📊 Progress metrics (% complete, velocity)
+- 🚧 Blockers and risks
+- ⏱️ Time analysis (estimated vs actual)
+- 🎯 Sprint/milestone progress
+
+### 2. **Contextual Analysis**
+
+Based on $ARGUMENTS, focus on:
+- "sprint" → Current sprint progress and burndown
+- "blocked" → Dependency chains and resolution paths
+- "team" → Task distribution and workload
+- "timeline" → Schedule adherence and projections
+- "risk" → High complexity or overdue items
+
+### 3. **Smart Insights**
+
+**Workflow Health:**
+- Idle tasks (in-progress > 24h without updates)
+- Bottlenecks (multiple tasks waiting on same dependency)
+- Quick wins (low complexity, high impact)
+
+**Predictive Analytics:**
+- Completion projections based on velocity
+- Risk of missing deadlines
+- Recommended task order for optimal flow
+
+### 4. **Visual Intelligence**
+
+Dynamic visualization based on data:
+\`\`\`
+Sprint Progress: ████████░░ 80% (16/20 tasks)
+Velocity Trend: ↗️ +15% this week
+Blocked Tasks:  🔴 3 critical path items
+
+Priority Distribution:
+High:   ████████ 8 tasks (2 blocked)
+Medium: ████░░░░ 4 tasks
+Low:    ██░░░░░░ 2 tasks
+\`\`\`
+
+### 5. **Actionable Recommendations**
+
+Based on analysis:
+1. **Immediate actions** (unblock critical path)
+2. **Today's focus** (optimal task sequence)
+3. **Process improvements** (recurring patterns)
+4. **Resource needs** (skills, time, dependencies)
+
+### 6. **Historical Context**
+
+Compare to previous periods:
+- Velocity changes
+- Pattern recognition
+- Improvement areas
+- Success patterns to repeat`),B(`next-task`,`Next Task`,`[preference]`,`Intelligently determine and prepare the next action based on comprehensive context.
+
+This enhanced version of 'next' considers:
+- Current task states
+- Recent activity
+- Time constraints
+- Dependencies
+- Your working patterns
+
+Arguments: $ARGUMENTS
+
+## Intelligent Next Action
+
+### 1. **Context Gathering**
+Let me analyze the current situation:
+- Active tasks (in-progress)
+- Recently completed tasks
+- Blocked tasks
+- Time since last activity
+- Arguments provided: $ARGUMENTS
+
+### 2. **Smart Decision Tree**
+
+**If you have an in-progress task:**
+- Has it been idle > 2 hours? → Suggest resuming or switching
+- Near completion? → Show remaining steps
+- Blocked? → Find alternative task
+
+**If no in-progress tasks:**
+- Unblocked high-priority tasks? → Start highest
+- Complex tasks need breakdown? → Suggest expansion
+- All tasks blocked? → Show dependency resolution
+
+**Special arguments handling:**
+- "quick" → Find task < 2 hours
+- "easy" → Find low complexity task
+- "important" → Find high priority regardless of complexity
+- "continue" → Resume last worked task
+
+### 3. **Preparation Workflow**
+
+Based on selected task:
+1. Show full context and history
+2. Set up development environment
+3. Run relevant tests
+4. Open related files
+5. Show similar completed tasks
+6. Estimate completion time
+
+### 4. **Alternative Suggestions**
+
+Always provide options:
+- Primary recommendation
+- Quick alternative (< 1 hour)
+- Strategic option (unblocks most tasks)
+- Learning option (new technology/skill)
+
+### 5. **Workflow Integration**
+
+Seamlessly connect to:
+- \`/project:task-master:start [selected]\`
+- \`/project:workflows:auto-implement\`
+- \`/project:task-master:expand\` (if complex)
+- \`/project:utils:complexity-report\` (if unsure)
+
+The goal: Zero friction from decision to implementation.`),B(`help`,`Help`,`[command-name]`,"Show help for Task Master AI commands.\n\nArguments: $ARGUMENTS\n\nDisplay help for Task Master commands and available options.\n\n## Task Master AI Command Help\n\n### Quick Navigation\n\nType `/taskmaster:` and use tab completion to explore all commands.\n\n### Command Categories\n\n#### 🚀 Setup & Installation\n- `/taskmaster:install-taskmaster` - Comprehensive installation guide\n- `/taskmaster:quick-install-taskmaster` - One-line global install\n\n#### 📋 Project Setup\n- `/taskmaster:init-project` - Initialize new project\n- `/taskmaster:init-project-quick` - Quick setup with auto-confirm\n- `/taskmaster:view-models` - View AI configuration\n- `/taskmaster:setup-models` - Configure AI providers\n\n#### 🎯 Task Generation\n- `/taskmaster:parse-prd` - Generate tasks from PRD\n- `/taskmaster:parse-prd-with-research` - Enhanced parsing\n- `/taskmaster:generate-tasks` - Create task files\n\n#### 📝 Task Management\n- `/taskmaster:list-tasks` - List all tasks\n- `/taskmaster:list-tasks-by-status` - List tasks filtered by status\n- `/taskmaster:list-tasks-with-subtasks` - List tasks with subtasks\n- `/taskmaster:show-task` - Display task details\n- `/taskmaster:add-task` - Create new task\n- `/taskmaster:update-task` - Update single task\n- `/taskmaster:update-tasks-from-id` - Update multiple tasks\n- `/taskmaster:next-task` - Get next task recommendation\n\n#### 🔄 Status Management\n- `/taskmaster:to-pending` - Set task to pending\n- `/taskmaster:to-in-progress` - Set task to in-progress\n- `/taskmaster:to-done` - Set task to done\n- `/taskmaster:to-review` - Set task to review\n- `/taskmaster:to-deferred` - Set task to deferred\n- `/taskmaster:to-cancelled` - Set task to cancelled\n\n#### 🔍 Analysis & Breakdown\n- `/taskmaster:analyze-complexity` - Analyze task complexity\n- `/taskmaster:complexity-report` - View complexity report\n- `/taskmaster:expand-task` - Break down complex task\n- `/taskmaster:expand-all-tasks` - Expand all eligible tasks\n\n#### 🔗 Dependencies\n- `/taskmaster:add-dependency` - Add task dependency\n- `/taskmaster:remove-dependency` - Remove dependency\n- `/taskmaster:validate-dependencies` - Check for issues\n- `/taskmaster:fix-dependencies` - Auto-fix dependency issues\n\n#### 📦 Subtasks\n- `/taskmaster:add-subtask` - Add subtask to task\n- `/taskmaster:convert-task-to-subtask` - Convert task to subtask\n- `/taskmaster:remove-subtask` - Remove subtask\n- `/taskmaster:remove-subtasks` - Clear specific task subtasks\n- `/taskmaster:remove-all-subtasks` - Clear all subtasks\n\n#### 🗑️ Task Removal\n- `/taskmaster:remove-task` - Remove task permanently\n\n#### 🤖 Workflows\n- `/taskmaster:smart-workflow` - Intelligent workflows\n- `/taskmaster:command-pipeline` - Command chaining\n- `/taskmaster:auto-implement-tasks` - Auto-implementation\n\n#### 📊 Utilities\n- `/taskmaster:analyze-project` - Project analysis\n- `/taskmaster:project-status` - Project dashboard\n- `/taskmaster:sync-readme` - Sync README with tasks\n- `/taskmaster:learn` - Interactive learning\n- `/taskmaster:tm-main` - Main Task Master interface\n\n### Quick Start Examples\n\n```\n/taskmaster:list-tasks\n/taskmaster:show-task 1.2\n/taskmaster:add-task\n/taskmaster:next-task\n```\n\n### Getting Started\n\n1. Install: `/taskmaster:quick-install-taskmaster`\n2. Initialize: `/taskmaster:init-project-quick`\n3. Learn: `/taskmaster:learn`\n4. Work: `/taskmaster:smart-workflow`\n\nFor detailed command info, run the specific command with `--help` or check command documentation."),B(`to-done`,`To Done`,`<task-id>`,`Mark a task as completed.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Completing a Task
+
+This command validates task completion and updates project state intelligently.
+
+## Pre-Completion Checks
+
+1. Verify test strategy was followed
+2. Check if all subtasks are complete
+3. Validate acceptance criteria met
+4. Ensure code is committed
+
+## Execution
+
+\`\`\`bash
+task-master set-status --id=$ARGUMENTS --status=done
+\`\`\`
+
+## Post-Completion Actions
+
+1. **Update Dependencies**
+   - Identify newly unblocked tasks
+   - Update sprint progress
+   - Recalculate project timeline
+
+2. **Documentation**
+   - Generate completion summary
+   - Update CLAUDE.md with learnings
+   - Log implementation approach
+
+3. **Next Steps**
+   - Show newly available tasks
+   - Suggest logical next task
+   - Update velocity metrics
+
+## Celebration & Learning
+
+- Show impact of completion
+- Display unblocked work
+- Recognize achievement
+- Capture lessons learned`),B(`to-pending`,`To Pending`,`<task-id>`,`Set a task's status to pending.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Setting Task to Pending
+
+This moves a task back to the pending state, useful for:
+- Resetting erroneously started tasks
+- Deferring work that was prematurely begun
+- Reorganizing sprint priorities
+
+## Execution
+
+\`\`\`bash
+task-master set-status --id=$ARGUMENTS --status=pending
+\`\`\`
+
+## Validation
+
+Before setting to pending:
+- Warn if task is currently in-progress
+- Check if this will block other tasks
+- Suggest documenting why it's being reset
+- Preserve any work already done
+
+## Smart Actions
+
+After setting to pending:
+- Update sprint planning if needed
+- Notify about freed resources
+- Suggest priority reassessment
+- Log the status change with context`),B(`to-in-progress`,`To In Progress`,`<task-id>`,`Start working on a task by setting its status to in-progress.
+
+Arguments: $ARGUMENTS (task ID)
+
+## Starting Work on Task
+
+This command does more than just change status - it prepares your environment for productive work.
+
+## Pre-Start Checks
+
+1. Verify dependencies are met
+2. Check if another task is already in-progress
+3. Ensure task details are complete
+4. Validate test strategy exists
+
+## Execution
+
+\`\`\`bash
+task-master set-status --id=$ARGUMENTS --status=in-progress
+\`\`\`
+
+## Environment Setup
+
+After setting to in-progress:
+1. Create/checkout appropriate git branch
+2. Open relevant documentation
+3. Set up test watchers if applicable
+4. Display task details and acceptance criteria
+5. Show similar completed tasks for reference
+
+## Smart Suggestions
+
+- Estimated completion time based on complexity
+- Related files from similar tasks
+- Potential blockers to watch for
+- Recommended first steps`),B(`update-task`,`Update Task`,`<update-spec>`,`Update tasks with intelligent field detection and bulk operations.
+
+Arguments: $ARGUMENTS
+
+## Intelligent Task Updates
+
+Parse arguments to determine update intent and execute smartly.
+
+### 1. **Natural Language Processing**
+
+Understand update requests like:
+- "mark 23 as done" → Update status to done
+- "increase priority of 45" → Set priority to high
+- "add dependency on 12 to task 34" → Add dependency
+- "tasks 20-25 need review" → Bulk status update
+- "all API tasks high priority" → Pattern-based update
+
+### 2. **Smart Field Detection**
+
+Automatically detect what to update:
+- Status keywords: done, complete, start, pause, review
+- Priority changes: urgent, high, low, deprioritize
+- Dependency updates: depends on, blocks, after
+- Assignment: assign to, owner, responsible
+- Time: estimate, spent, deadline
+
+### 3. **Bulk Operations**
+
+Support for multiple task updates:
+\`\`\`
+Examples:
+- "complete tasks 12, 15, 18"
+- "all pending auth tasks to in-progress"
+- "increase priority for tasks blocking 45"
+- "defer all documentation tasks"
+\`\`\`
+
+### 4. **Contextual Validation**
+
+Before updating, check:
+- Status transitions are valid
+- Dependencies don't create cycles
+- Priority changes make sense
+- Bulk updates won't break project flow
+
+Show preview:
+\`\`\`
+Update Preview:
+─────────────────
+Tasks to update: #23, #24, #25
+Change: status → in-progress
+Impact: Will unblock tasks #30, #31
+Warning: Task #24 has unmet dependencies
+\`\`\`
+
+### 5. **Smart Suggestions**
+
+Based on update:
+- Completing task? → Show newly unblocked tasks
+- Changing priority? → Show impact on sprint
+- Adding dependency? → Check for conflicts
+- Bulk update? → Show summary of changes
+
+### 6. **Workflow Integration**
+
+After updates:
+- Auto-update dependent task states
+- Trigger status recalculation
+- Update sprint/milestone progress
+- Log changes with context
+
+Result: Flexible, intelligent task updates with safety checks.`),B(`update-single-task`,`Update Single Task`,`<task-id> <changes>`,`Update a single specific task with new information.
+
+Arguments: $ARGUMENTS
+
+Parse task ID and update details.
+
+## Single Task Update
+
+Precisely update one task with AI assistance to maintain consistency.
+
+## Argument Parsing
+
+Natural language updates:
+- "5: add caching requirement"
+- "update 5 to include error handling"
+- "task 5 needs rate limiting"
+- "5 change priority to high"
+
+## Execution
+
+\`\`\`bash
+task-master update-task --id=<id> --prompt="<context>"
+\`\`\`
+
+## Update Types
+
+### 1. **Content Updates**
+- Enhance description
+- Add requirements
+- Clarify details
+- Update acceptance criteria
+
+### 2. **Metadata Updates**
+- Change priority
+- Adjust time estimates
+- Update complexity
+- Modify dependencies
+
+### 3. **Strategic Updates**
+- Revise approach
+- Change test strategy
+- Update implementation notes
+- Adjust subtask needs
+
+## AI-Powered Updates
+
+The AI:
+1. **Understands Context**
+   - Reads current task state
+   - Identifies update intent
+   - Maintains consistency
+   - Preserves important info
+
+2. **Applies Changes**
+   - Updates relevant fields
+   - Keeps style consistent
+   - Adds without removing
+   - Enhances clarity
+
+3. **Validates Results**
+   - Checks coherence
+   - Verifies completeness
+   - Maintains relationships
+   - Suggests related updates
+
+## Example Updates
+
+\`\`\`
+/taskmaster:update/single 5: add rate limiting
+→ Updating Task #5: "Implement API endpoints"
+
+Current: Basic CRUD endpoints
+Adding: Rate limiting requirements
+
+Updated sections:
+✓ Description: Added rate limiting mention
+✓ Details: Added specific limits (100/min)
+✓ Test Strategy: Added rate limit tests
+✓ Complexity: Increased from 5 to 6
+✓ Time Estimate: Increased by 2 hours
+
+Suggestion: Also update task #6 (API Gateway) for consistency?
+\`\`\`
+
+## Smart Features
+
+1. **Incremental Updates**
+   - Adds without overwriting
+   - Preserves work history
+   - Tracks what changed
+   - Shows diff view
+
+2. **Consistency Checks**
+   - Related task alignment
+   - Subtask compatibility
+   - Dependency validity
+   - Timeline impact
+
+3. **Update History**
+   - Timestamp changes
+   - Track who/what updated
+   - Reason for update
+   - Previous versions
+
+## Field-Specific Updates
+
+Quick syntax for specific fields:
+- "5 priority:high" → Update priority only
+- "5 add-time:4h" → Add to time estimate
+- "5 status:review" → Change status
+- "5 depends:3,4" → Add dependencies
+
+## Post-Update
+
+- Show updated task
+- Highlight changes
+- Check related tasks
+- Update suggestions
+- Timeline adjustments`),B(`update-tasks-from-id`,`Update Tasks From ID`,`<from-id> <changes>`,`Update multiple tasks starting from a specific ID.
+
+Arguments: $ARGUMENTS
+
+Parse starting task ID and update context.
+
+## Bulk Task Updates
+
+Update multiple related tasks based on new requirements or context changes.
+
+## Argument Parsing
+
+- "from 5: add security requirements"
+- "5 onwards: update API endpoints"
+- "starting at 5: change to use new framework"
+
+## Execution
+
+\`\`\`bash
+task-master update --from=<id> --prompt="<context>"
+\`\`\`
+
+## Update Process
+
+### 1. **Task Selection**
+Starting from specified ID:
+- Include the task itself
+- Include all dependent tasks
+- Include related subtasks
+- Smart boundary detection
+
+### 2. **Context Application**
+AI analyzes the update context and:
+- Identifies what needs changing
+- Maintains consistency
+- Preserves completed work
+- Updates related information
+
+### 3. **Intelligent Updates**
+- Modify descriptions appropriately
+- Update test strategies
+- Adjust time estimates
+- Revise dependencies if needed
+
+## Smart Features
+
+1. **Scope Detection**
+   - Find natural task groupings
+   - Identify related features
+   - Stop at logical boundaries
+   - Avoid over-updating
+
+2. **Consistency Maintenance**
+   - Keep naming conventions
+   - Preserve relationships
+   - Update cross-references
+   - Maintain task flow
+
+3. **Change Preview**
+   \`\`\`
+   Bulk Update Preview
+   ━━━━━━━━━━━━━━━━━━
+   Starting from: Task #5
+   Tasks to update: 8 tasks + 12 subtasks
+
+   Context: "add security requirements"
+
+   Changes will include:
+   - Add security sections to descriptions
+   - Update test strategies for security
+   - Add security-related subtasks where needed
+   - Adjust time estimates (+20% average)
+
+   Continue? (y/n)
+   \`\`\`
+
+## Example Updates
+
+\`\`\`
+/taskmaster:update-tasks-from-id 5: change database to PostgreSQL
+→ Analyzing impact starting from task #5
+→ Found 6 related tasks to update
+→ Updates will maintain consistency
+→ Preview changes? (y/n)
+
+Applied updates:
+✓ Task #5: Updated connection logic references
+✓ Task #6: Changed migration approach
+✓ Task #7: Updated query syntax notes
+✓ Task #8: Revised testing strategy
+✓ Task #9: Updated deployment steps
+✓ Task #12: Changed backup procedures
+\`\`\`
+
+## Safety Features
+
+- Preview all changes
+- Selective confirmation
+- Rollback capability
+- Change logging
+- Validation checks
+
+## Post-Update
+
+- Summary of changes
+- Consistency verification
+- Suggest review tasks
+- Update timeline if needed`),z({name:`tm-main`,description:`Task Master Main`,content:"# Task Master Command Reference\n\nComprehensive command structure for Task Master integration with Claude Code.\n\n## Command Organization\n\nCommands are organized hierarchically to match Task Master's CLI structure while providing enhanced Claude Code integration.\n\n## Project Setup & Configuration\n\n### `/taskmaster:init`\n- `init-project` - Initialize new project (handles PRD files intelligently)\n- `init-project-quick` - Quick setup with auto-confirmation (-y flag)\n\n### `/taskmaster:models`\n- `view-models` - View current AI model configuration\n- `setup-models` - Interactive model configuration\n- `set-main` - Set primary generation model\n- `set-research` - Set research model\n- `set-fallback` - Set fallback model\n\n## Task Generation\n\n### `/taskmaster:parse-prd`\n- `parse-prd` - Generate tasks from PRD document\n- `parse-prd-with-research` - Enhanced parsing with research mode\n\n### `/taskmaster:generate`\n- `generate-tasks` - Create individual task files from tasks.json\n\n## Task Management\n\n### `/taskmaster:list`\n- `list-tasks` - Smart listing with natural language filters\n- `list-tasks-with-subtasks` - Include subtasks in hierarchical view\n- `list-tasks-by-status` - Filter by specific status\n\n### `/taskmaster:set-status`\n- `to-pending` - Reset task to pending\n- `to-in-progress` - Start working on task\n- `to-done` - Mark task complete\n- `to-review` - Submit for review\n- `to-deferred` - Defer task\n- `to-cancelled` - Cancel task\n\n### `/taskmaster:sync-readme`\n- `sync-readme` - Export tasks to README.md with formatting\n\n### `/taskmaster:update`\n- `update-task` - Update tasks with natural language\n- `update-tasks-from-id` - Update multiple tasks from a starting point\n- `update-single-task` - Update specific task\n\n### `/taskmaster:add-task`\n- `add-task` - Add new task with AI assistance\n\n### `/taskmaster:remove-task`\n- `remove-task` - Remove task with confirmation\n\n## Subtask Management\n\n### `/taskmaster:add-subtask`\n- `add-subtask` - Add new subtask to parent\n- `convert-task-to-subtask` - Convert existing task to subtask\n\n### `/taskmaster:remove-subtask`\n- `remove-subtask` - Remove subtask (with optional conversion)\n\n### `/taskmaster:clear-subtasks`\n- `clear-subtasks` - Clear subtasks from specific task\n- `clear-all-subtasks` - Clear all subtasks globally\n\n## Task Analysis & Breakdown\n\n### `/taskmaster:analyze-complexity`\n- `analyze-complexity` - Analyze and generate expansion recommendations\n\n### `/taskmaster:complexity-report`\n- `complexity-report` - Display complexity analysis report\n\n### `/taskmaster:expand`\n- `expand-task` - Break down specific task\n- `expand-all-tasks` - Expand all eligible tasks\n- `with-research` - Enhanced expansion\n\n## Task Navigation\n\n### `/taskmaster:next`\n- `next-task` - Intelligent next task recommendation\n\n### `/taskmaster:show`\n- `show-task` - Display detailed task information\n\n### `/taskmaster:status`\n- `project-status` - Comprehensive project dashboard\n\n## Dependency Management\n\n### `/taskmaster:add-dependency`\n- `add-dependency` - Add task dependency\n\n### `/taskmaster:remove-dependency`\n- `remove-dependency` - Remove task dependency\n\n### `/taskmaster:validate-dependencies`\n- `validate-dependencies` - Check for dependency issues\n\n### `/taskmaster:fix-dependencies`\n- `fix-dependencies` - Automatically fix dependency problems\n\n## Workflows & Automation\n\n### `/taskmaster:workflows`\n- `smart-workflow` - Context-aware intelligent workflow execution\n- `command-pipeline` - Chain multiple commands together\n- `auto-implement-tasks` - Advanced auto-implementation with code generation\n\n## Utilities\n\n### `/taskmaster:utils`\n- `analyze-project` - Deep project analysis and insights\n\n### `/taskmaster:setup`\n- `install-taskmaster` - Comprehensive installation guide\n- `quick-install-taskmaster` - One-line global installation\n\n## Usage Patterns\n\n### Natural Language\nMost commands accept natural language arguments:\n```\n/taskmaster:add-task create user authentication system\n/taskmaster:update mark all API tasks as high priority\n/taskmaster:list show blocked tasks\n```\n\n### ID-Based Commands\nCommands requiring IDs intelligently parse from $ARGUMENTS:\n```\n/taskmaster:show 45\n/taskmaster:expand 23\n/taskmaster:set-status/to-done 67\n```\n\n### Smart Defaults\nCommands provide intelligent defaults and suggestions based on context."}),B(`smart-workflow`,`Smart Workflow`,`[context]`,`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`),B(`learn`,`Learn`,`[topic]`,`Learn about Task Master capabilities through interactive exploration.
+
+Arguments: $ARGUMENTS
+
+## Interactive Task Master Learning
+
+Based on your input, I'll help you discover capabilities:
+
+### 1. **What are you trying to do?**
+
+If $ARGUMENTS contains:
+- "start" / "begin" → Show project initialization workflows
+- "manage" / "organize" → Show task management commands
+- "automate" / "auto" → Show automation workflows
+- "analyze" / "report" → Show analysis tools
+- "fix" / "problem" → Show troubleshooting commands
+- "fast" / "quick" → Show efficiency shortcuts
+
+### 2. **Intelligent Suggestions**
+
+Based on your project state:
+
+**No tasks yet?**
+\`\`\`
+You'll want to start with:
+1. /project:task-master:init <prd-file>
+   → Creates tasks from requirements
+
+2. /project:task-master:parse-prd <file>
+   → Alternative task generation
+
+Try: /project:task-master:init demo-prd.md
+\`\`\`
+
+**Have tasks?**
+Let me analyze what you might need...
+- Many pending tasks? → Learn sprint planning
+- Complex tasks? → Learn task expansion
+- Daily work? → Learn workflow automation
+
+### 3. **Command Discovery**
+
+**By Category:**
+- 📋 Task Management: list, show, add, update, complete
+- 🔄 Workflows: auto-implement, sprint-plan, daily-standup
+- 🛠️ Utilities: check-health, complexity-report, sync-memory
+- 🔍 Analysis: validate-deps, show dependencies
+
+**By Scenario:**
+- "I want to see what to work on" → \`/project:task-master:next\`
+- "I need to break this down" → \`/project:task-master:expand <id>\`
+- "Show me everything" → \`/project:task-master:status\`
+- "Just do it for me" → \`/project:workflows:auto-implement\`
+
+### 4. **Power User Patterns**
+
+**Command Chaining:**
+\`\`\`
+/project:task-master:next
+/project:task-master:start <id>
+/project:workflows:auto-implement
+\`\`\`
+
+**Smart Filters:**
+\`\`\`
+/project:task-master:list pending high
+/project:task-master:list blocked
+/project:task-master:list 1-5 tree
+\`\`\`
+
+**Automation:**
+\`\`\`
+/project:workflows:pipeline init → expand-all → sprint-plan
+\`\`\`
+
+### 5. **Learning Path**
+
+Based on your experience level:
+
+**Beginner Path:**
+1. init → Create project
+2. status → Understand state
+3. next → Find work
+4. complete → Finish task
+
+**Intermediate Path:**
+1. expand → Break down complex tasks
+2. sprint-plan → Organize work
+3. complexity-report → Understand difficulty
+4. validate-deps → Ensure consistency
+
+**Advanced Path:**
+1. pipeline → Chain operations
+2. smart-flow → Context-aware automation
+3. Custom commands → Extend the system
+
+### 6. **Try This Now**
+
+Based on what you asked about, try:
+[Specific command suggestion based on $ARGUMENTS]
+
+Want to learn more about a specific command?
+Type: /project:help <command-name>`),B(`command-pipeline`,`Command Pipeline`,`<pipeline-spec>`,`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\``),B(`auto-implement-tasks`,`Auto Implement Tasks`,`[task-id]`,`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.`),B(`analyze-project`,`Analyze Project`,`[focus-area]`,`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.`),B(`sync-readme`,`Sync README`,`[options]`,`Export tasks to README.md with professional formatting.
+
+Arguments: $ARGUMENTS
+
+Generate a well-formatted README with current task information.
+
+## README Synchronization
+
+Creates or updates README.md with beautifully formatted task information.
+
+## Argument Parsing
+
+Optional filters:
+- "pending" → Only pending tasks
+- "with-subtasks" → Include subtask details
+- "by-priority" → Group by priority
+- "sprint" → Current sprint only
+
+## Execution
+
+\`\`\`bash
+task-master sync-readme [--with-subtasks] [--status=<status>]
+\`\`\`
+
+## README Generation
+
+### 1. **Project Header**
+\`\`\`markdown
+# Project Name
+
+## 📋 Task Progress
+
+Last Updated: 2024-01-15 10:30 AM
+
+### Summary
+- Total Tasks: 45
+- Completed: 15 (33%)
+- In Progress: 5 (11%)
+- Pending: 25 (56%)
+\`\`\`
+
+### 2. **Task Sections**
+Organized by status or priority:
+- Progress indicators
+- Task descriptions
+- Dependencies noted
+- Time estimates
+
+### 3. **Visual Elements**
+- Progress bars
+- Status badges
+- Priority indicators
+- Completion checkmarks
+
+## Smart Features
+
+1. **Intelligent Grouping**
+   - By feature area
+   - By sprint/milestone
+   - By assigned developer
+   - By priority
+
+2. **Progress Tracking**
+   - Overall completion
+   - Sprint velocity
+   - Burndown indication
+   - Time tracking
+
+3. **Formatting Options**
+   - GitHub-flavored markdown
+   - Task checkboxes
+   - Collapsible sections
+   - Table format available
+
+## Example Output
+
+\`\`\`markdown
+## 🚀 Current Sprint
+
+### In Progress
+- [ ] 🔄 #5 **Implement user authentication** (60% complete)
+  - Dependencies: API design (#3 ✅)
+  - Subtasks: 4 (2 completed)
+  - Est: 8h / Spent: 5h
+
+### Pending (High Priority)
+- [ ] ⚡ #8 **Create dashboard UI**
+  - Blocked by: #5
+  - Complexity: High
+  - Est: 12h
+\`\`\`
+
+## Customization
+
+Based on arguments:
+- Include/exclude sections
+- Detail level control
+- Custom grouping
+- Filter by criteria
+
+## Post-Sync
+
+After generation:
+1. Show diff preview
+2. Backup existing README
+3. Write new content
+4. Commit reminder
+5. Update timestamp
+
+## Integration
+
+Works well with:
+- Git workflows
+- CI/CD pipelines
+- Project documentation
+- Team updates
+- Client reports`)];function H(e,t){return t===`team`?e.filter(e=>e.metadata.mode===`team`||e.metadata.mode===`common`||!e.metadata.mode):e.filter(e=>e.metadata.mode===`solo`||e.metadata.mode===`common`||!e.metadata.mode)}H(V,`solo`),H(V,`team`),V.filter(e=>e.metadata.mode===`common`||!e.metadata.mode);var U=class{supportsNestedCommands=!0;get supportsCommands(){return this.commandsDir!==``}formatAll(e){return e.map(e=>this.format(e))}getFilename(e){return this.supportsNestedCommands?`${e}${this.extension}`:`tm-${e}${this.extension}`}transformArgumentPlaceholder(e){return e}postProcess(e){return e}getCommandsPath(e){return this.supportsNestedCommands?b.join(e,this.commandsDir,`tm`):b.join(e,this.commandsDir)}addSlashCommands(e,t,n){let r=this.getCommandsPath(e),i=[];if(!this.supportsCommands)return{success:!1,count:0,directory:r,files:[],error:`Profile "${this.name}" does not support slash commands`};try{n?.mode&&this.removeSlashCommands(e,t,!1);let a=n?.mode?H(t,n.mode):t;E.existsSync(r)||E.mkdirSync(r,{recursive:!0});let o=this.formatAll(a);for(let e of o){let t=b.join(r,e.filename);E.writeFileSync(t,e.content),i.push(e.filename)}return{success:!0,count:i.length,directory:r,files:i}}catch(e){return{success:!1,count:0,directory:r,files:[],error:e instanceof Error?e.message:String(e)}}}removeSlashCommands(e,t,n=!0){let r=this.getCommandsPath(e),i=[];if(!this.supportsCommands)return{success:!1,count:0,directory:r,files:[],error:`Profile "${this.name}" does not support slash commands`};if(!E.existsSync(r))return{success:!0,count:0,directory:r,files:[]};try{let e=new Set(t.map(e=>{let t=e.metadata.name.toLowerCase();return this.supportsNestedCommands?t:`tm-${t}`})),a=E.readdirSync(r);for(let t of a){let n=b.basename(t,b.extname(t)).toLowerCase();if(e.has(n)){let e=b.join(r,t);E.rmSync(e,{force:!0}),i.push(t)}}return n&&E.readdirSync(r).length===0&&E.rmSync(r,{recursive:!0,force:!0}),{success:!0,count:i.length,directory:r,files:i}}catch(e){return{success:!1,count:i.length,directory:r,files:i,error:e instanceof Error?e.message:String(e)}}}replaceSlashCommands(e,t,n){let r=this.removeSlashCommands(e,t);return r.success?this.addSlashCommands(e,t,{mode:n}):r}},Xe=class extends U{name=`claude`;displayName=`Claude Code`;commandsDir=`.claude/commands`;extension=`.md`;format(e){let t=this.buildHeader(e),n=this.transformArgumentPlaceholder(e.content);return{filename:this.getFilename(e.metadata.name),content:`${t}${n}`}}buildHeader(e){let t=[e.metadata.description,``];return e.metadata.argumentHint&&(t.push(`Arguments: $ARGUMENTS`),t.push(``)),t.join(`
+`)}},Ze=class extends U{name=`codex`;displayName=`Codex`;commandsDir=`.codex/prompts`;extension=`.md`;supportsNestedCommands=!1;isHomeRelative=!0;homeDir;constructor(e){super(),this.homeDir=e?.homeDir??O.homedir()}getCommandsPath(e){return b.join(this.homeDir,this.commandsDir)}format(e){let t=this.buildFrontmatter(e);return{filename:this.getFilename(e.metadata.name),content:`${t}${e.content}`}}buildFrontmatter(e){let t=e=>e.replace(/"/g,`\\"`),n=[`---`,`description: "${t(e.metadata.description)}"`];return e.metadata.argumentHint&&n.push(`argument-hint: "${t(e.metadata.argumentHint)}"`),n.push(`---`,``),n.join(`
+`)}},Qe=class extends U{name=`cursor`;displayName=`Cursor`;commandsDir=`.cursor/commands`;extension=`.md`;format(e){return{filename:this.getFilename(e.metadata.name),content:e.content}}},$e=class extends U{name=`gemini`;displayName=`Gemini`;commandsDir=`.gemini/commands`;extension=`.toml`;format(e){let t=this.escapeForPython(e.metadata.description),n=this.escapeForTripleQuotedString(e.content.trim());return{filename:this.getFilename(e.metadata.name),content:`description="${t}"
+prompt = """
+${n}
+"""
+`}}escapeForPython(e){return e.replace(/"/g,`\\"`)}escapeForTripleQuotedString(e){return e.replace(/"""/g,`""\\"`)}},et=class extends U{name=`opencode`;displayName=`OpenCode`;commandsDir=`.opencode/command`;extension=`.md`;supportsNestedCommands=!1;format(e){let t=this.buildFrontmatter(e),n=this.transformArgumentPlaceholder(e.content);return{filename:this.getFilename(e.metadata.name),content:`${t}${n}`}}buildFrontmatter(e){return[`---`,`description: ${e.metadata.description}`,`---`,``].join(`
+`)}},tt=class extends U{name=`roo`;displayName=`Roo Code`;commandsDir=`.roo/commands`;extension=`.md`;supportsNestedCommands=!1;format(e){let t=this.buildFrontmatter(e),n=this.transformArgumentPlaceholder(e.content);return{filename:this.getFilename(e.metadata.name),content:`${t}${n}`}}buildFrontmatter(e){let t=[`---`,`description: ${e.metadata.description}`];return e.metadata.argumentHint&&t.push(`argument-hint: ${e.metadata.argumentHint}`),t.push(`---`,``,``),t.join(`
+`)}};const nt={claude:new Xe,codex:new Ze,cursor:new Qe,gemini:new $e,opencode:new et,roo:new tt};function rt(e){return nt[e.toLowerCase()]}function it(){let e=T.homedir(),t=process.env.SHELL||``;if(t.includes(`zsh`))return C.join(e,`.zshrc`);if(t.includes(`bash`)){let t=C.join(e,`.bash_profile`);return process.platform===`darwin`?t:C.join(e,`.bashrc`)}if(t.includes(`fish`))return C.join(e,`.config`,`fish`,`config.fish`);if(process.platform===`win32`){if(process.env.PSModulePath){let t=process.env.PROFILE||C.join(e,`Documents`,`WindowsPowerShell`,`Microsoft.PowerShell_profile.ps1`),n=C.join(e,`Documents`,`PowerShell`,`Microsoft.PowerShell_profile.ps1`);return S.existsSync(n)?n:S.existsSync(t)?t:n}let t=C.join(e,`.bashrc`);if(S.existsSync(t))return t}let n=C.join(e,`.zshrc`);if(S.existsSync(n))return n;let r=C.join(e,`.bashrc`);return S.existsSync(r)?r:null}function W(e){return e.endsWith(`.ps1`)}function at(e){return e.includes(`config.fish`)}function ot(e,t,n){if(!/^[A-Z_][A-Z0-9_]*$/i.test(e))return{success:!1,message:`Invalid environment variable name: ${e}. Must start with a letter or underscore and contain only alphanumeric characters and underscores.`};if(typeof t!=`string`||t.includes(`
+`)||t.includes(`\r`))return{success:!1,message:`Invalid value: must be a single-line string without newlines`};let r=it();if(!r)return{success:!1,message:`Could not determine shell type (zsh, bash, fish, or PowerShell)`};try{let i=C.dirname(r);if(S.existsSync(i)||S.mkdirSync(i,{recursive:!0}),!S.existsSync(r)){let e=process.platform===`darwin`&&r.endsWith(`.bash_profile`);if(W(r)||e)S.writeFileSync(r,``);else return{success:!1,shellConfigFile:r,message:`Shell config file ${r} not found`}}let a=S.readFileSync(r,`utf8`),o;if(o=W(r)?RegExp(`^\\s*\\$env:${e}\\s*=`,`m`).test(a):at(r)?RegExp(`^\\s*set\\s+-[gux]*x[gux]*\\s+${e}\\s+`,`m`).test(a):RegExp(`^\\s*export\\s+${e}\\s*=`,`m`).test(a),o)return{success:!0,shellConfigFile:r,message:`${e} already configured`,alreadyExists:!0};let s,c;W(r)?(s=`$env:${e} = "${t.replace(/["`$]/g,"`$&")}"`,c=`#`):at(r)?(s=`set -gx ${e} '${t.replace(/'/g,`'\\''`)}'`,c=`#`):(s=`export ${e}='${t.replace(/'/g,`'\\''`)}'`,c=`#`);let l=`\n${n?`${c} ${n}\n`:``}${s}\n`;return S.appendFileSync(r,l),{success:!0,shellConfigFile:r,message:`Added ${e} to ${r}`}}catch(e){return{success:!1,shellConfigFile:r,message:`Failed to modify shell config: ${e.message}`}}}function st(){return ot(`ENABLE_EXPERIMENTAL_MCP_CLI`,`true`,`Claude Code deferred MCP loading (added by Taskmaster)`)}const ct=[{profileName:`cursor`,markers:[{path:`.cursor`,type:`directory`}],displayName:`Cursor`},{profileName:`claude`,markers:[{path:`.claude`,type:`directory`}],displayName:`Claude Code`},{profileName:`windsurf`,markers:[{path:`.windsurf`,type:`directory`}],displayName:`Windsurf`},{profileName:`vscode`,markers:[{path:`.vscode`,type:`directory`}],displayName:`VS Code`},{profileName:`roo`,markers:[{path:`.roo`,type:`directory`}],displayName:`Roo Code`},{profileName:`cline`,markers:[{path:`.cline`,type:`directory`}],displayName:`Cline`},{profileName:`kiro`,markers:[{path:`.kiro`,type:`directory`}],displayName:`Kiro`},{profileName:`zed`,markers:[{path:`.zed`,type:`directory`}],displayName:`Zed`},{profileName:`kilo`,markers:[{path:`.kilo`,type:`directory`}],displayName:`Kilo Code`},{profileName:`trae`,markers:[{path:`.trae`,type:`directory`}],displayName:`Trae`},{profileName:`gemini`,markers:[{path:`.gemini`,type:`directory`},{path:`GEMINI.md`,type:`file`}],displayName:`Gemini`},{profileName:`opencode`,markers:[{path:`.opencode`,type:`directory`}],displayName:`OpenCode`},{profileName:`codex`,markers:[{path:`.codex`,type:`directory`}],displayName:`Codex`}];function lt(e){let{projectRoot:t}=e,n=[];for(let e of ct)for(let r of e.markers){let i=C.join(t,r.path);try{let t=S.statSync(i);if(r.type===`directory`?t.isDirectory():t.isFile()){n.push({profileName:e.profileName,markerPath:r.path,displayName:e.displayName,exists:!0});break}}catch{}}return n}function ut(e){return lt(e).map(e=>e.profileName)}const dt={solo:[`rules/taskmaster.mdc`,`rules/dev_workflow.mdc`,`rules/self_improve.mdc`,`rules/cursor_rules.mdc`,`rules/taskmaster_hooks_workflow.mdc`],team:[`rules/hamster.mdc`]};function ft(e,t){return t===`team`?Object.fromEntries(Object.entries(e).filter(([e])=>dt.team.includes(e))):Object.fromEntries(Object.entries(e).filter(([e])=>dt.solo.includes(e)))}function G(e){let{name:t,displayName:n=t,url:r,docsUrl:i,profileDir:a=`.${t.toLowerCase()}`,rulesDir:o=`${a}/rules`,mcpConfig:s=!0,mcpConfigName:c=s?`mcp.json`:null,fileExtension:l=`.mdc`,targetExtension:u=`.md`,toolMappings:d={},customReplacements:f=[],fileMap:p={},supportsRulesSubdirectories:m=!1,includeDefaultRules:g=!0,onAdd:_,onRemove:v,onPostConvert:y}=e,ee=c?C.join(a,c):null,b=m?`taskmaster/`:``,x={"rules/cursor_rules.mdc":`${t.toLowerCase()}_rules${u}`,"rules/dev_workflow.mdc":`${b}dev_workflow${u}`,"rules/self_improve.mdc":`self_improve${u}`,"rules/taskmaster.mdc":`${b}taskmaster${u}`,"rules/hamster.mdc":`${b}hamster${u}`},S=g?{...x,...p}:p,w=[{from:/cursor\.so/gi,to:r},{from:/cursor\s*\.\s*so/gi,to:r},{from:/https?:\/\/cursor\.so/gi,to:`https://${r}`},{from:/https?:\/\/www\.cursor\.so/gi,to:`https://www.${r}`},{from:/\bedit_file\b/gi,to:d.edit_file||`edit_file`},{from:/\bsearch tool\b/gi,to:`${d.search||`search`} tool`},{from:/\bSearch Tool\b/g,to:`${d.search||`Search`} Tool`},{from:/\bcursor\b/gi,to:e=>e.charAt(0)===`C`?n:t.toLowerCase()},{from:/Cursor/g,to:n},{from:/CURSOR/g,to:n.toUpperCase()},...u===l?[]:[{from:RegExp(`\\${l}(?!\\])\\b`,`g`),to:u}],{from:/docs\.cursor\.com/gi,to:i},...f],T={search:`search`,read_file:`read_file`,edit_file:`edit_file`,create_file:`create_file`,run_command:`run_command`,terminal_command:`terminal_command`,use_mcp:`use_mcp`,switch_mode:`switch_mode`,...d},E={profileTerms:[{from:/cursor\.so/g,to:r},{from:/\[cursor\.so\]/g,to:`[${r}]`},{from:/href="https:\/\/cursor\.so/g,to:`href="https://${r}`},{from:/\(https:\/\/cursor\.so/g,to:`(https://${r}`},{from:/\bcursor\b/gi,to:e=>e===`Cursor`?n:t.toLowerCase()},{from:/Cursor/g,to:n}],fileExtensions:u===l?[]:[{from:RegExp(`\\${l}\\b`,`g`),to:u}],docUrls:[{from:RegExp(`https:\\/\\/docs\\.cursor\\.com\\/[^\\s)'"]+`,`g`),to:e=>e.replace(`docs.cursor.com`,i)},{from:RegExp(`https:\\/\\/${i}\\/`,`g`),to:`https://${i}/`}],toolNames:T,toolContexts:Object.entries(T).flatMap(([e,t])=>[{from:RegExp(`\\b${e} tool\\b`,`g`),to:`${t} tool`},{from:RegExp(`\\bthe ${e}\\b`,`g`),to:`the ${t}`},{from:RegExp(`\\bThe ${e}\\b`,`g`),to:`The ${t}`},{from:RegExp(`\\bCursor ${e}\\b`,`g`),to:`${n} ${t}`}]),toolGroups:[{from:/\bSearch tools\b/g,to:`Read Group tools`},{from:/\bEdit tools\b/g,to:`Edit Group tools`},{from:/\bRun tools\b/g,to:`Command Group tools`},{from:/\bMCP servers\b/g,to:`MCP Group tools`},{from:/\bSearch Group\b/g,to:`Read Group`},{from:/\bEdit Group\b/g,to:`Edit Group`},{from:/\bRun Group\b/g,to:`Command Group`}],fileReferences:{pathPattern:/\[(.+?)\]\(mdc:\.cursor\/rules\/(.+?)\.mdc\)/g,replacement:(e,n,r)=>{let i=C.basename(r,`.mdc`),a=S[`rules/${i}.mdc`]||`${i}${u}`,s=C.basename(a);return t.toLowerCase()===`cursor`?`[${s}](mdc:${o}/${a})`:`[${s}](${o}/${a})`}}};function D(e){return S[e]?S[e]:u===l?e:e.replace(RegExp(`\\${l}$`),u)}let O=null;try{let e=rt(t);e?.supportsCommands&&(O={profile:e,commands:V})}catch(e){h(`debug`,`[${n}] Slash command profile lookup failed: ${e.message}`)}return{profileName:t,displayName:n,profileDir:a,rulesDir:o,mcpConfig:s,mcpConfigName:c,mcpConfigPath:ee,supportsRulesSubdirectories:m,includeDefaultRules:g,fileMap:S,globalReplacements:w,conversionConfig:E,getTargetRuleFilename:D,targetExtension:u,slashCommands:O,..._&&{onAddRulesProfile:_},...v&&{onRemoveRulesProfile:v},...y&&{onPostConvertRulesProfile:y}}}const pt={STANDARD:{},ROO_STYLE:{edit_file:`apply_diff`,search:`search_files`,create_file:`write_to_file`,run_command:`execute_command`,terminal_command:`execute_command`,use_mcp:`use_mcp_tool`}};function mt(e){let t={};e.mcpServers&&(t[`amp.mcpServers`]=e.mcpServers);for(let[n,r]of Object.entries(e))n!==`mcpServers`&&(t[n]=r);return t}function ht(e,t){let n=C.join(t,`AGENTS.md`),r=C.join(e,`AGENT.md`),i=C.join(e,`.taskmaster`,`AGENT.md`),a=`@./.taskmaster/AGENT.md`,o=`\n## Task Master AI Instructions\n**Import Task Master's development workflow commands and guidelines, treat as if import is in the main AGENT.md file.**\n${a}`;if(S.existsSync(n))try{let t=C.join(e,`.taskmaster`);if(S.existsSync(t)||S.mkdirSync(t,{recursive:!0}),S.copyFileSync(n,i),h(`debug`,`[Amp] Created Task Master instructions at ${i}`),S.existsSync(r)){let e=S.readFileSync(r,`utf8`);if(e.includes(a))h(`info`,`[Amp] Task Master import already present in ${r}`);else{let t=e.trim()+`
+`+o+`
+`;S.writeFileSync(r,t),h(`info`,`[Amp] Added Task Master import to existing ${r}`)}}else{let e=`# Amp Instructions\n${o}\n`;S.writeFileSync(r,e),h(`info`,`[Amp] Created ${r} with Task Master import`)}}catch(e){h(`error`,`[Amp] Failed to set up Amp instructions: ${e.message}`)}}function gt(e){let t=C.join(e,`AGENT.md`),n=C.join(e,`.taskmaster`,`AGENT.md`);try{if(S.existsSync(n)&&(S.rmSync(n,{force:!0}),h(`debug`,`[Amp] Removed ${n}`)),S.existsSync(t)){let e=S.readFileSync(t,`utf8`).split(`
+`),n=[],r=0;for(let t=0;t<e.length;t++){if(r>0){r--;continue}if(e[t].includes(`## Task Master AI Instructions`)){r=2;continue}e[t].trim()!==`@./.taskmaster/AGENT.md`&&n.push(e[t])}let i=n.join(`
+`).replace(/\n{3,}/g,`
+
+`).trim();i===`# Amp Instructions`||i===``?(S.rmSync(t,{force:!0}),h(`debug`,`[Amp] Removed empty ${t}`)):(S.writeFileSync(t,i+`
+`),h(`debug`,`[Amp] Removed Task Master import from ${t}`))}}catch(e){h(`error`,`[Amp] Failed to remove Amp instructions: ${e.message}`)}let r=C.join(e,`.vscode`,`settings.json`);if(!S.existsSync(r)){h(`debug`,`[Amp] No .vscode/settings.json found to clean up`);return}try{let t=S.readFileSync(r,`utf8`),n=JSON.parse(t);if(n[`amp.mcpServers`]&&n[`amp.mcpServers`][`task-master-ai`])if(delete n[`amp.mcpServers`][`task-master-ai`],Object.keys(n[`amp.mcpServers`]).length===0&&(delete n[`amp.mcpServers`],h(`debug`,`[Amp] Removed empty amp.mcpServers section`)),Object.keys(n).length===0){S.rmSync(r,{force:!0}),h(`info`,`[Amp] Removed empty settings.json file`);let t=C.join(e,`.vscode`);S.existsSync(t)&&S.readdirSync(t).length===0&&(S.rmSync(t,{recursive:!0,force:!0}),h(`debug`,`[Amp] Removed empty .vscode directory`))}else S.writeFileSync(r,JSON.stringify(n,null,`	`)+`
+`),h(`info`,`[Amp] Removed TaskMaster from settings.json, preserved other configurations`);else h(`debug`,`[Amp] TaskMaster not found in amp.mcpServers`)}catch(e){h(`error`,`[Amp] Failed to clean up settings.json: ${e.message}`)}}function _t(e,t){ht(e,t);let n=C.join(e,`.vscode`,`settings.json`);if(!S.existsSync(n)){h(`debug`,`[Amp] No .vscode/settings.json found to transform`);return}try{let e=S.readFileSync(n,`utf8`),t=JSON.parse(e);if(t[`amp.mcpServers`]){h(`info`,`[Amp] settings.json already in Amp format, skipping transformation`);return}let r=mt(t);S.writeFileSync(n,JSON.stringify(r,null,`	`)+`
+`),h(`info`,`[Amp] Transformed settings.json to Amp format`),h(`debug`,`[Amp] Renamed mcpServers to amp.mcpServers`)}catch(e){h(`error`,`[Amp] Failed to transform settings.json: ${e.message}`)}}const vt=G({name:`amp`,displayName:`Amp`,url:`ampcode.com`,docsUrl:`ampcode.com/manual`,profileDir:`.vscode`,rulesDir:`.`,mcpConfig:!0,mcpConfigName:`settings.json`,includeDefaultRules:!1,fileMap:{"AGENTS.md":`.taskmaster/AGENT.md`},onAdd:ht,onRemove:gt,onPostConvert:_t});function yt(e,t){h(`info`,`[Claude] Commands and agents are now available via the Task Master plugin`),h(`info`,`[Claude] Install with: /plugin marketplace add taskmaster`),h(`info`,`[Claude] Then: /plugin install taskmaster@taskmaster`);let n=C.join(t,`AGENTS.md`),r=C.join(e,`CLAUDE.md`),i=C.join(e,`.taskmaster`,`CLAUDE.md`),a=`@./.taskmaster/CLAUDE.md`,o=`\n## Task Master AI Instructions\n**Import Task Master's development workflow commands and guidelines, treat as if import is in the main CLAUDE.md file.**\n${a}`;if(S.existsSync(n))try{let t=C.join(e,`.taskmaster`);if(S.existsSync(t)||S.mkdirSync(t,{recursive:!0}),S.copyFileSync(n,i),h(`debug`,`[Claude] Created Task Master instructions at ${i}`),S.existsSync(r)){let e=S.readFileSync(r,`utf8`);if(e.includes(a))h(`info`,`[Claude] Task Master import already present in ${r}`);else{let t=e.trim()+`
+`+o+`
+`;S.writeFileSync(r,t),h(`info`,`[Claude] Added Task Master import to existing ${r}`)}}else{let e=`# Claude Code Instructions\n${o}\n`;S.writeFileSync(r,e),h(`info`,`[Claude] Created ${r} with Task Master import`)}}catch(e){h(`error`,`[Claude] Failed to set up Claude instructions: ${e.message}`)}let s=st();s.success?s.alreadyExists?h(`debug`,`[Claude] Deferred MCP loading already configured`):(h(`info`,`[Claude] Enabled deferred MCP loading in ${s.shellConfigFile}`),h(`info`,`[Claude] Restart your terminal for changes to take effect`)):h(`debug`,`[Claude] Could not configure deferred loading: ${s.message}`)}function bt(e){h(`info`,`[Claude] To remove Task Master commands/agents, uninstall the plugin with: /plugin uninstall taskmaster`);let t=C.join(e,`CLAUDE.md`),n=C.join(e,`.taskmaster`,`CLAUDE.md`);try{if(S.existsSync(n)&&(S.rmSync(n,{force:!0}),h(`debug`,`[Claude] Removed ${n}`)),S.existsSync(t)){let e=S.readFileSync(t,`utf8`).split(`
+`),n=[],r=0;for(let t=0;t<e.length;t++){if(r>0){r--;continue}if(e[t].includes(`## Task Master AI Instructions`)){r=2;continue}e[t].trim()!==`@./.taskmaster/CLAUDE.md`&&n.push(e[t])}let i=n.join(`
+`).replace(/\n{3,}/g,`
+
+`).trim();i===`# Claude Code Instructions`||i===``?(S.rmSync(t,{force:!0}),h(`debug`,`[Claude] Removed empty ${t}`)):(S.writeFileSync(t,i+`
+`),h(`debug`,`[Claude] Removed Task Master import from ${t}`))}}catch(e){h(`error`,`[Claude] Failed to remove Claude instructions: ${e.message}`)}}function xt(e){let t={};if(e.mcpServers){t.mcpServers={};for(let[n,r]of Object.entries(e.mcpServers)){let e={};e.type=`stdio`,r.command&&(e.command=r.command),r.args&&(e.args=r.args),r.env&&(e.env=r.env),Object.keys(r).forEach(t=>{[`command`,`args`,`env`,`type`].includes(t)||(e[t]=r[t])}),t.mcpServers[n]=e}}return t}function St(e,t){yt(e,t);let n=C.join(e,`.mcp.json`);if(S.existsSync(n))try{let e=xt(JSON.parse(S.readFileSync(n,`utf8`)));S.writeFileSync(n,JSON.stringify(e,null,`	`)+`
+`),h(`debug`,`[Claude] Transformed MCP configuration to Claude format at ${n}`)}catch(e){h(`error`,`[Claude] Failed to transform MCP configuration: ${e.message}`)}}const Ct=G({name:`claude`,displayName:`Claude Code`,url:`claude.ai`,docsUrl:`docs.anthropic.com/en/docs/claude-code`,profileDir:`.`,rulesDir:`.`,mcpConfigName:`.mcp.json`,includeDefaultRules:!1,fileMap:{"AGENTS.md":`.taskmaster/CLAUDE.md`},onAdd:yt,onRemove:bt,onPostConvert:St}),wt=G({name:`cline`,displayName:`Cline`,url:`cline.bot`,docsUrl:`docs.cline.bot`,profileDir:`.clinerules`,rulesDir:`.clinerules`,mcpConfig:!1}),Tt=G({name:`codex`,displayName:`Codex`,url:`codex.ai`,docsUrl:`platform.openai.com/docs/codex`,profileDir:`.`,rulesDir:`.`,mcpConfig:!1,mcpConfigName:null,includeDefaultRules:!1,fileMap:{"AGENTS.md":`AGENTS.md`}}),Et=G({name:`cursor`,displayName:`Cursor`,url:`cursor.so`,docsUrl:`docs.cursor.com`,targetExtension:`.mdc`,supportsRulesSubdirectories:!0}),Dt=G({name:`gemini`,displayName:`Gemini`,url:`codeassist.google`,docsUrl:`github.com/google-gemini/gemini-cli`,profileDir:`.gemini`,rulesDir:`.`,mcpConfigName:`settings.json`,includeDefaultRules:!1,fileMap:{"AGENT.md":`AGENTS.md`,"GEMINI.md":`GEMINI.md`}});function Ot(e){let t=[{from:/\broo\b/gi,to:e=>e.charAt(0)===`R`?`Kilo`:`kilo`},{from:/Roo/g,to:`Kilo`},{from:/ROO/g,to:`KILO`},{from:/roocode\.com/gi,to:`kilocode.com`},{from:/docs\.roocode\.com/gi,to:`docs.kilocode.com`},{from:/https?:\/\/roocode\.com/gi,to:`https://kilocode.com`},{from:/https?:\/\/docs\.roocode\.com/gi,to:`https://docs.kilocode.com`},{from:/\.roo\//g,to:`.kilo/`},{from:/\.roomodes/g,to:`.kilocodemodes`},{from:/roo-rules/g,to:`kilo-rules`},{from:/rules-roo/g,to:`rules-kilo`}],n=e;for(let e of t)n=n.replace(e.from,e.to);return n}function kt(e,t){let n=S.existsSync(e),r=n&&S.statSync(e);n&&r.isDirectory()?(S.existsSync(t)||S.mkdirSync(t,{recursive:!0}),S.readdirSync(e).forEach(n=>{kt(C.join(e,n),C.join(t,n))})):S.copyFileSync(e,t)}function At(e,t){let n=C.join(t,`roocode`);if(!S.existsSync(n)){h(`error`,`[Kilo] Source directory does not exist: ${n}`);return}kt(n,e),h(`debug`,`[Kilo] Copied roocode directory to ${e}`);let r=C.join(n,`.roomodes`),i=C.join(e,`.kilocodemodes`);if(S.existsSync(r))try{let t=Ot(S.readFileSync(r,`utf8`));S.writeFileSync(i,t),h(`debug`,`[Kilo] Created .kilocodemodes at ${i}`),S.unlinkSync(C.join(e,`.roomodes`))}catch(e){h(`error`,`[Kilo] Failed to transform .roomodes: ${e.message}`)}let a=C.join(n,`.roo`),o=C.join(e,`.kilo`);S.existsSync(C.join(e,`.roo`))&&S.rmSync(C.join(e,`.roo`),{recursive:!0,force:!0});for(let e of se){let t=C.join(a,`rules-${e}`,`${e}-rules`),n=C.join(o,`rules-${e}`,`${e}-rules`);if(S.existsSync(t))try{let r=C.dirname(n);S.existsSync(r)||S.mkdirSync(r,{recursive:!0});let i=Ot(S.readFileSync(t,`utf8`));S.writeFileSync(n,i),h(`debug`,`[Kilo] Transformed and copied ${e}-rules to ${n}`)}catch(e){h(`error`,`[Kilo] Failed to transform ${t} to ${n}: ${e.message}`)}}}function jt(e){let t=C.join(e,`.kilocodemodes`);if(S.existsSync(t))try{S.rmSync(t,{force:!0}),h(`debug`,`[Kilo] Removed .kilocodemodes from ${t}`)}catch(e){h(`error`,`[Kilo] Failed to remove .kilocodemodes: ${e.message}`)}let n=C.join(e,`.kilo`);if(S.existsSync(n)&&(S.readdirSync(n).forEach(e=>{if(e.startsWith(`rules-`)){let t=C.join(n,e);try{S.rmSync(t,{recursive:!0,force:!0}),h(`debug`,`[Kilo] Removed ${e} directory from ${t}`)}catch(e){h(`error`,`[Kilo] Failed to remove ${t}: ${e.message}`)}}}),S.readdirSync(n).length===0))try{S.rmSync(n,{recursive:!0,force:!0}),h(`debug`,`[Kilo] Removed empty .kilo directory from ${n}`)}catch(e){h(`error`,`[Kilo] Failed to remove .kilo directory: ${e.message}`)}}function Mt(e,t){At(e,t)}const Nt=G({name:`kilo`,displayName:`Kilo Code`,url:`kilocode.com`,docsUrl:`docs.kilocode.com`,profileDir:`.kilo`,rulesDir:`.kilo/rules`,toolMappings:pt.ROO_STYLE,fileMap:{"rules/cursor_rules.mdc":`kilo_rules.md`,"rules/dev_workflow.mdc":`dev_workflow.md`,"rules/self_improve.mdc":`self_improve.md`,"rules/taskmaster.mdc":`taskmaster.md`},onAdd:At,onRemove:jt,onPostConvert:Mt}),Pt=G({name:`kiro`,displayName:`Kiro`,url:`kiro.dev`,docsUrl:`kiro.dev/docs`,profileDir:`.kiro`,rulesDir:`.kiro/steering`,mcpConfig:!0,mcpConfigName:`settings/mcp.json`,includeDefaultRules:!0,targetExtension:`.md`,fileMap:{"rules/taskmaster_hooks_workflow.mdc":`taskmaster_hooks_workflow.md`},customReplacements:[{from:/\.cursor\/rules/g,to:`.kiro/steering`},{from:/\.cursor\/mcp\.json/g,to:`.kiro/settings/mcp.json`},{from:/\.kiro\/rules/g,to:`.kiro/steering`},{from:/\[(.+?)\]\(mdc:\.cursor\/rules\/(.+?)\.mdc\)/g,to:`[$1](.kiro/steering/$2.md)`},{from:/rules directory/g,to:`steering directory`},{from:/cursor rules/gi,to:`Kiro steering files`},{from:/^---\n(?:description:\s*[^\n]*\n)?(?:globs:\s*[^\n]*\n)?(?:alwaysApply:\s*true\n)?---/m,to:`---
+inclusion: always
+---`}],onPostConvert:(e,t)=>{let n=C.join(t,`kiro-hooks`),r=C.join(e,`.kiro`,`hooks`);if(S.existsSync(r)||S.mkdirSync(r,{recursive:!0}),S.existsSync(n)){let e=S.readdirSync(n).filter(e=>e.endsWith(`.kiro.hook`));e.forEach(e=>{let t=C.join(n,e),i=C.join(r,e);S.copyFileSync(t,i)}),e.length>0&&h(`info`,`[Kiro] Installed ${e.length} Taskmaster hooks in .kiro/hooks/`)}}});function Ft(e){let t={$schema:`https://opencode.ai/config.json`};if(e.mcpServers){t.mcp={};for(let[n,r]of Object.entries(e.mcpServers)){let e={type:`local`};r.command&&r.args?e.command=[r.command,...r.args]:r.command&&(e.command=[r.command]),e.enabled=!0,r.env&&(e.environment=r.env),t.mcp[n]=e}}return t}function It(e,t){let n=C.join(e,`opencode.json`);if(!S.existsSync(n)){h(`debug`,`[OpenCode] No opencode.json found to transform`);return}try{let e=S.readFileSync(n,`utf8`),t=JSON.parse(e);if(t.$schema){h(`info`,`[OpenCode] opencode.json already in OpenCode format, skipping transformation`);return}let r=Ft(t);S.writeFileSync(n,JSON.stringify(r,null,2)+`
+`),h(`info`,`[OpenCode] Transformed opencode.json to OpenCode format`),h(`debug`,`[OpenCode] Added schema, renamed mcpServers->mcp, combined command+args, added type/enabled, renamed env->environment`)}catch(e){h(`error`,`[OpenCode] Failed to transform opencode.json: ${e.message}`)}}function Lt(e){let t=C.join(e,`opencode.json`);if(!S.existsSync(t)){h(`debug`,`[OpenCode] No opencode.json found to clean up`);return}try{let e=S.readFileSync(t,`utf8`),n=JSON.parse(e);n.mcp&&n.mcp[`taskmaster-ai`]?(delete n.mcp[`taskmaster-ai`],Object.keys(n.mcp).length===0&&delete n.mcp,Object.keys(n).filter(e=>e!==`$schema`).length===0?(S.rmSync(t,{force:!0}),h(`info`,`[OpenCode] Removed empty opencode.json file`)):(S.writeFileSync(t,JSON.stringify(n,null,2)+`
+`),h(`info`,`[OpenCode] Removed TaskMaster from opencode.json, preserved other configurations`))):h(`debug`,`[OpenCode] TaskMaster not found in opencode.json`)}catch(e){h(`error`,`[OpenCode] Failed to clean up opencode.json: ${e.message}`)}}const Rt=G({name:`opencode`,displayName:`OpenCode`,url:`opencode.ai`,docsUrl:`opencode.ai/docs/`,profileDir:`.`,rulesDir:`.`,mcpConfigName:`opencode.json`,includeDefaultRules:!1,fileMap:{"AGENTS.md":`AGENTS.md`},onPostConvert:It,onRemove:Lt});function zt(e){if(!S.existsSync(e)){h(`warn`,`[Roo] MCP configuration file not found at ${e}`);return}try{let t=JSON.parse(S.readFileSync(e,`utf8`));if(t.mcpServers&&t.mcpServers[`task-master-ai`]){let n=t.mcpServers[`task-master-ai`];n.timeout=300,S.writeFileSync(e,R(t)+`
+`),h(`debug`,`[Roo] Enhanced MCP configuration with timeout at ${e}`)}else h(`warn`,`[Roo] task-master-ai server not found in MCP configuration`)}catch(e){h(`error`,`[Roo] Failed to enhance MCP configuration: ${e.message}`)}}function Bt(e,t){let n=C.join(t,`roocode`);if(!S.existsSync(n)){h(`error`,`[Roo] Source directory does not exist: ${n}`);return}Vt(n,e),h(`debug`,`[Roo] Copied roocode directory to ${e}`);let r=C.join(n,`.roo`),i=C.join(n,`.roomodes`),a=C.join(e,`.roomodes`);if(S.existsSync(i))try{S.copyFileSync(i,a),h(`debug`,`[Roo] Copied .roomodes to ${a}`)}catch(e){h(`error`,`[Roo] Failed to copy .roomodes: ${e.message}`)}for(let t of se){let n=C.join(r,`rules-${t}`,`${t}-rules`),i=C.join(e,`.roo`,`rules-${t}`,`${t}-rules`);if(S.existsSync(n))try{let e=C.dirname(i);S.existsSync(e)||S.mkdirSync(e,{recursive:!0}),S.copyFileSync(n,i),h(`debug`,`[Roo] Copied ${t}-rules to ${i}`)}catch(e){h(`error`,`[Roo] Failed to copy ${n} to ${i}: ${e.message}`)}}}function Vt(e,t){let n=S.existsSync(e),r=n&&S.statSync(e);n&&r.isDirectory()?(S.existsSync(t)||S.mkdirSync(t,{recursive:!0}),S.readdirSync(e).forEach(n=>{Vt(C.join(e,n),C.join(t,n))})):S.copyFileSync(e,t)}function Ht(e){let t=C.join(e,`.roomodes`);if(S.existsSync(t))try{S.rmSync(t,{force:!0}),h(`debug`,`[Roo] Removed .roomodes from ${t}`)}catch(e){h(`error`,`[Roo] Failed to remove .roomodes: ${e.message}`)}let n=C.join(e,`.roo`);if(S.existsSync(n)){let e=C.join(n,`mcp.json`);try{S.rmSync(e,{force:!0}),h(`debug`,`[Roo] Removed MCP configuration from ${e}`)}catch(e){h(`error`,`[Roo] Failed to remove MCP configuration: ${e.message}`)}if(S.readdirSync(n).forEach(e=>{if(e.startsWith(`rules-`)){let t=C.join(n,e);try{S.rmSync(t,{recursive:!0,force:!0}),h(`debug`,`[Roo] Removed ${e} directory from ${t}`)}catch(e){h(`error`,`[Roo] Failed to remove ${t}: ${e.message}`)}}}),S.readdirSync(n).length===0)try{S.rmSync(n,{recursive:!0,force:!0}),h(`debug`,`[Roo] Removed empty .roo directory from ${n}`)}catch(e){h(`error`,`[Roo] Failed to remove .roo directory: ${e.message}`)}}}function Ut(e,t){let n=C.join(e,`.roo`,`mcp.json`);try{zt(n)}catch(e){h(`error`,`[Roo] Failed to enhance MCP configuration: ${e.message}`)}}const Wt=G({name:`roo`,displayName:`Roo Code`,url:`roocode.com`,docsUrl:`docs.roocode.com`,toolMappings:pt.ROO_STYLE,mcpConfig:!0,onAdd:Bt,onRemove:Ht,onPostConvert:Ut}),Gt=G({name:`trae`,displayName:`Trae`,url:`trae.ai`,docsUrl:`docs.trae.ai`,mcpConfig:!1});function Kt(e){let t={};if(e.mcpServers){t.servers={};for(let[n,r]of Object.entries(e.mcpServers)){let e={...r};if(e.env){let r={};e.command&&(r.command=e.command),e.args&&(r.args=e.args),e.env&&(r.env=e.env),r.type=`stdio`,Object.keys(e).forEach(t=>{[`command`,`args`,`env`,`type`].includes(t)||(r[t]=e[t])}),t.servers[n]=r}else e.type=`stdio`,t.servers[n]=e}}return t}function qt(e,t){let n=C.join(e,`.vscode`,`mcp.json`);if(!S.existsSync(n)){h(`debug`,`[VS Code] No .vscode/mcp.json found to transform`);return}try{let e=S.readFileSync(n,`utf8`),t=JSON.parse(e);if(t.servers){h(`info`,`[VS Code] mcp.json already in VS Code format, skipping transformation`);return}let r=Kt(t);S.writeFileSync(n,JSON.stringify(r,null,2)+`
+`),h(`info`,`[VS Code] Transformed mcp.json to VS Code format`),h(`debug`,`[VS Code] Renamed mcpServers->servers, added type: "stdio"`)}catch(e){h(`error`,`[VS Code] Failed to transform mcp.json: ${e.message}`)}}function Jt(e){let t=C.join(e,`.vscode`,`mcp.json`);if(!S.existsSync(t)){h(`debug`,`[VS Code] No .vscode/mcp.json found to clean up`);return}try{let e=S.readFileSync(t,`utf8`),n=JSON.parse(e);if(n.servers&&n.servers[`task-master-ai`])if(delete n.servers[`task-master-ai`],Object.keys(n.servers).length===0){S.rmSync(t,{force:!0}),h(`info`,`[VS Code] Removed empty mcp.json file`);let e=C.dirname(t);try{S.readdirSync(e).length===0&&(S.rmSync(e,{recursive:!0,force:!0}),h(`debug`,`[VS Code] Removed empty .vscode directory`))}catch{}}else S.writeFileSync(t,JSON.stringify(n,null,2)+`
+`),h(`info`,`[VS Code] Removed TaskMaster from mcp.json, preserved other configurations`);else h(`debug`,`[VS Code] TaskMaster not found in mcp.json`)}catch(e){h(`error`,`[VS Code] Failed to clean up mcp.json: ${e.message}`)}}const Yt=G({name:`vscode`,displayName:`VS Code`,url:`code.visualstudio.com`,docsUrl:`code.visualstudio.com/docs`,rulesDir:`.github/instructions`,profileDir:`.vscode`,mcpConfigName:`mcp.json`,targetExtension:`.instructions.md`,customReplacements:[{from:/\.cursor\/rules/g,to:`.github/instructions`},{from:/\.cursor\/mcp\.json/g,to:`.vscode/mcp.json`},{from:/\.vscode\/rules/g,to:`.github/instructions`},{from:/^globs:\s*(.+)$/gm,to:`applyTo: "$1"`},{from:/^alwaysApply:\s*(true|false)\s*\n?/gm,to:``},{from:/\[(.+?)\]\(mdc:\.cursor\/rules\/(.+?)\.mdc\)/g,to:`[$1](.github/instructions/$2.instructions.md)`},{from:/rules directory/g,to:`instructions directory`},{from:/cursor rules/gi,to:`VS Code instructions`}],onPostConvert:qt,onRemove:Jt}),Xt=G({name:`windsurf`,displayName:`Windsurf`,url:`windsurf.com`,docsUrl:`docs.windsurf.com`});function Zt(e){let t={};e.mcpServers&&(t.context_servers=e.mcpServers);for(let[n,r]of Object.entries(e))n!==`mcpServers`&&(t[n]=r);return t}function Qt(e,t){}function $t(e){let t=C.join(e,`.rules`);try{S.existsSync(t)&&(S.rmSync(t,{force:!0}),h(`debug`,`[Zed] Removed ${t}`))}catch(e){h(`error`,`[Zed] Failed to remove Zed instructions: ${e.message}`)}let n=C.join(e,`.zed`,`settings.json`);if(!S.existsSync(n)){h(`debug`,`[Zed] No .zed/settings.json found to clean up`);return}try{let t=S.readFileSync(n,`utf8`),r=JSON.parse(t);if(r.context_servers&&r.context_servers[`task-master-ai`])if(delete r.context_servers[`task-master-ai`],Object.keys(r.context_servers).length===0&&(delete r.context_servers,h(`debug`,`[Zed] Removed empty context_servers section`)),Object.keys(r).length===0){S.rmSync(n,{force:!0}),h(`info`,`[Zed] Removed empty settings.json file`);let t=C.join(e,`.zed`);S.existsSync(t)&&S.readdirSync(t).length===0&&(S.rmSync(t,{recursive:!0,force:!0}),h(`debug`,`[Zed] Removed empty .zed directory`))}else S.writeFileSync(n,JSON.stringify(r,null,`	`)+`
+`),h(`info`,`[Zed] Removed TaskMaster from settings.json, preserved other configurations`);else h(`debug`,`[Zed] TaskMaster not found in context_servers`)}catch(e){h(`error`,`[Zed] Failed to clean up settings.json: ${e.message}`)}}function en(e,t){let n=C.join(e,`.zed`,`settings.json`);if(!S.existsSync(n)){h(`debug`,`[Zed] No .zed/settings.json found to transform`);return}try{let e=S.readFileSync(n,`utf8`),t=JSON.parse(e);if(t.context_servers){h(`info`,`[Zed] settings.json already in Zed format, skipping transformation`);return}let r=Zt(t);r.context_servers&&r.context_servers[`task-master-ai`]&&(r.context_servers[`task-master-ai`].source=`custom`),S.writeFileSync(n,JSON.stringify(r,null,`	`)+`
+`),h(`info`,`[Zed] Transformed settings.json to Zed format`),h(`debug`,`[Zed] Renamed mcpServers to context_servers`)}catch(e){h(`error`,`[Zed] Failed to transform settings.json: ${e.message}`)}}const tn=G({name:`zed`,displayName:`Zed`,url:`zed.dev`,docsUrl:`zed.dev/docs`,profileDir:`.zed`,rulesDir:`.`,mcpConfig:!0,mcpConfigName:`settings.json`,includeDefaultRules:!1,fileMap:{"AGENTS.md":`.rules`},onAdd:Qt,onRemove:$t,onPostConvert:en});var nn=e({ampProfile:()=>vt,claudeProfile:()=>Ct,clineProfile:()=>wt,codexProfile:()=>Tt,cursorProfile:()=>Et,geminiProfile:()=>Dt,kiloProfile:()=>Nt,kiroProfile:()=>Pt,opencodeProfile:()=>Rt,rooProfile:()=>Wt,traeProfile:()=>Gt,vscodeProfile:()=>Yt,windsurfProfile:()=>Xt,zedProfile:()=>tn});function K(e){return j.includes(e)}function q(e){if(!K(e))return null;let t=nn[`${e}Profile`];if(!t)throw Error(`Profile not found: static import missing for '${e}'. Valid profiles: ${j.join(`, `)}`);return t}function rn(e,t){let n=e;return t.profileTerms.forEach(e=>{n=(e.to,n.replace(e.from,e.to))}),t.fileExtensions.forEach(e=>{n=n.replace(e.from,e.to)}),n}function an(e,t){let n=e,r=t.toolNames,i=RegExp(`\\b(${Object.keys(r).join(`|`)})\\b`,`g`);return n=n.replace(i,(e,t)=>r[t]||t),t.toolContexts.forEach(e=>{n=n.replace(e.from,e.to)}),t.toolGroups.forEach(e=>{n=n.replace(e.from,e.to)}),n}function on(e,t){let n=e;return t.docUrls.forEach(e=>{n=(e.to,n.replace(e.from,e.to))}),n}function sn(e,t){let{pathPattern:n,replacement:r}=t.fileReferences;return e.replace(n,r)}function cn(e,t,n){let r=e;return r=sn(r,t),r=rn(r,t),r=an(r,t),r=on(r,t),n.forEach(e=>{r=(e.to,r.replace(e.from,e.to))}),r}function ln(e,t){let n=C.join(e,t.rulesDir);if(!S.existsSync(n))return;let r=Object.values(t.fileMap);for(let e of r){let t=C.join(n,e);if(S.existsSync(t))try{S.rmSync(t,{force:!0}),h(`debug`,`[Rule Transformer] Removed rule file: ${e}`)}catch(t){h(`warn`,`[Rule Transformer] Failed to remove rule file ${e}: ${t.message}`)}}}function J(e,t,n){let r=C.join(e,t.rulesDir),i=n?.mode,a=0,o=0;if(i&&(ln(e,t),h(`debug`,`[Rule Transformer] Cleaned up existing rules before adding ${i} mode rules`)),typeof t.onAddRulesProfile==`function`)try{let e=I();t.onAddRulesProfile(r,e),h(`debug`,`[Rule Transformer] Called onAddRulesProfile for ${t.profileName}`)}catch(e){h(`error`,`[Rule Transformer] onAddRulesProfile failed for ${t.profileName}: ${e.message}`),o++}let s=i?ft(t.fileMap,i):t.fileMap,c=Object.keys(s);if(c.length>0){S.existsSync(r)||S.mkdirSync(r,{recursive:!0});for(let e of c){let n=!e.startsWith(`rules/`);try{if(!xe(e)){h(`warn`,`[Rule Transformer] Source file not found: ${e}, skipping`);continue}let i=s[e],o=C.join(r,i),c=C.dirname(o);S.existsSync(c)||S.mkdirSync(c,{recursive:!0});let l=L(e,`utf8`);n||(l=cn(l,t.conversionConfig,t.globalReplacements)),S.writeFileSync(o,l,`utf8`),a++,h(`debug`,`[Rule Transformer] ${n?`Copied`:`Converted`} ${e} -> ${i} for ${t.profileName}`)}catch(r){o++,h(`error`,`[Rule Transformer] Failed to ${n?`copy`:`convert`} ${e} for ${t.profileName}: ${r.message}`)}}}if(t.mcpConfig!==!1)try{Se(e,t.mcpConfigPath),h(`debug`,`[Rule Transformer] Setup MCP configuration for ${t.profileName}`)}catch(e){h(`error`,`[Rule Transformer] MCP setup failed for ${t.profileName}: ${e.message}`)}if(typeof t.onPostConvertRulesProfile==`function`)try{let e=I();t.onPostConvertRulesProfile(r,e),h(`debug`,`[Rule Transformer] Called onPostConvertRulesProfile for ${t.profileName}`)}catch(e){h(`error`,`[Rule Transformer] onPostConvertRulesProfile failed for ${t.profileName}: ${e.message}`)}if(t.slashCommands)try{let n=i?{mode:i}:void 0,r=t.slashCommands.profile.addSlashCommands(e,t.slashCommands.commands,n);r.success?h(`debug`,`[Rule Transformer] Created ${r.count} slash commands in ${r.directory}${i?` (mode: ${i})`:``}`):h(`error`,`[Rule Transformer] Failed to add slash commands for ${t.profileName}: ${r.error}`)}catch(e){h(`error`,`[Rule Transformer] Slash commands failed for ${t.profileName}: ${e.message}`)}return{success:Math.max(a,1),failed:o}}function un(e,t){let n=C.join(e,t.rulesDir),r=C.join(e,t.profileDir),i={profileName:t.profileName,success:!1,skipped:!1,error:null,filesRemoved:[],mcpResult:null,profileDirRemoved:!1,notice:null};try{if(typeof t.onRemoveRulesProfile==`function`)try{t.onRemoveRulesProfile(n),h(`debug`,`[Rule Transformer] Called onRemoveRulesProfile for ${t.profileName}`)}catch(e){h(`error`,`[Rule Transformer] onRemoveRulesProfile failed for ${t.profileName}: ${e.message}`)}let a=Object.keys(t.fileMap);if(a.length>0){if(!S.existsSync(r))return i.success=!0,i.skipped=!0,h(`debug`,`[Rule Transformer] Profile directory does not exist: ${r}`),i;let o=!1;if(S.existsSync(n)){let r=a.map(e=>t.fileMap[e]),s=[];if(n===e||t.rulesDir===`.`){let e=S.readdirSync(n);for(let t of e){if(t===`node_modules`||t===`.git`||t===`dist`)continue;let e=C.join(n,t);try{let n=S.lstatSync(e);n.isFile()?s.push(t):n.isDirectory()&&!n.isSymbolicLink()&&S.readdirSync(e,{recursive:!0}).forEach(e=>{s.push(C.join(t,e.toString()))})}catch{}}}else s=S.readdirSync(n,{recursive:!0});let c=s.filter(e=>{let t=C.join(n,e);try{return S.statSync(t).isFile()}catch{return!1}}).map(e=>e.toString());for(let e of r){let t=C.join(n,e);if(S.existsSync(t))try{S.rmSync(t,{force:!0}),i.filesRemoved.push(e),h(`debug`,`[Rule Transformer] Removed Task Master file: ${e}`)}catch(t){h(`error`,`[Rule Transformer] Failed to remove ${e}: ${t.message}`)}}let l=c.filter(e=>!r.includes(e));o=l.length>0,l.length===0?(S.rmSync(n,{recursive:!0,force:!0}),h(`debug`,`[Rule Transformer] Removed empty rules directory: ${n}`)):o&&(i.notice=`Preserved ${l.length} existing rule files in ${t.rulesDir}`,h(`info`,`[Rule Transformer] ${i.notice}`))}}if(t.mcpConfig!==!1)try{i.mcpResult=Ce(e,t.mcpConfigPath),i.mcpResult.hasOtherServers&&(i.notice?i.notice+=`; preserved other MCP server configurations`:i.notice=`Preserved other MCP server configurations`),h(`debug`,`[Rule Transformer] Processed MCP configuration for ${t.profileName}`)}catch(e){h(`error`,`[Rule Transformer] MCP cleanup failed for ${t.profileName}: ${e.message}`)}if(t.slashCommands)try{let n=t.slashCommands.profile.removeSlashCommands(e,t.slashCommands.commands);n.success&&n.count>0?h(`debug`,`[Rule Transformer] Removed ${n.count} slash commands for ${t.profileName}`):n.success||h(`error`,`[Rule Transformer] Failed to remove slash commands for ${t.profileName}: ${n.error}`)}catch(e){h(`error`,`[Rule Transformer] Slash command cleanup failed for ${t.profileName}: ${e.message}`)}if(S.existsSync(r)){let e=S.readdirSync(r);if(e.length===0&&t.profileDir!==`.`)try{S.rmSync(r,{recursive:!0,force:!0}),i.profileDirRemoved=!0,h(`debug`,`[Rule Transformer] Removed empty profile directory: ${r}`)}catch(e){h(`error`,`[Rule Transformer] Failed to remove profile directory ${r}: ${e.message}`)}else if(e.length>0){let n=`Preserved ${e.length} existing files/folders in ${t.profileDir}`;i.notice?i.notice+=`; ${n.toLowerCase()}`:i.notice=n,h(`info`,`[Rule Transformer] ${n}`)}}i.success=!0,h(`debug`,`[Rule Transformer] Successfully removed ${t.profileName} Task Master files from ${e}`)}catch(e){i.error=e.message,h(`error`,`[Rule Transformer] Failed to remove ${t.profileName} rules: ${e.message}`)}return i}function dn(e){try{let t=JSON.parse(S.readFileSync(e,`utf-8`));for(let e of[`main`,`research`,`fallback`])if(t.models&&t.models[e]){let n=t.models[e].provider,r=t.models[e].modelId;if(s[n]){let i=s[n].find(e=>e.id===r);i&&i.max_tokens&&(t.models[e].maxTokens=i.max_tokens)}}return S.writeFileSync(e,JSON.stringify(t,null,2)),!0}catch(e){return console.error(`Error updating config maxTokens:`,e.message),!1}}const Y={debug:0,info:1,warn:2,error:3,success:4},fn=process.env.TASKMASTER_LOG_LEVEL?Y[process.env.TASKMASTER_LOG_LEVEL.toLowerCase()]:Y.info;function pn(){m()||y()}function X(e,...t){let n={debug:x.gray(`•`),info:x.blue(`→`),warn:x.yellow(`!`),error:x.red(`✗`),success:x.green(`✓`)};if(Y[e]>=fn){let r=n[e]||``;m()||(e===`error`?console.error(r,x.red(...t)):e===`warn`?console.warn(r,x.yellow(...t)):e===`success`?console.log(r,x.green(...t)):e===`info`?console.log(r,x.blue(...t)):console.log(r,...t))}if(process.env.DEBUG===`true`){let n=`[${e.toUpperCase()}] ${t.join(` `)}\n`;S.appendFileSync(`init-debug.log`,n)}}function Z(e){S.existsSync(e)||(S.mkdirSync(e,{recursive:!0}),X(`info`,`Created directory: ${e}`))}function mn(){let e=process.env.HOME||process.env.USERPROFILE,t;if(process.env.SHELL?.includes(`zsh`))t=C.join(e,`.zshrc`);else if(process.env.SHELL?.includes(`bash`))t=C.join(e,`.bashrc`);else return X(`debug`,`Could not determine shell type. Aliases not added.`),!1;try{if(!S.existsSync(t))return X(`debug`,`Shell config file ${t} not found.`),!1;let e=S.readFileSync(t,`utf8`),n=[{name:`tm`,line:`alias tm='task-master'`},{name:`taskmaster`,line:`alias taskmaster='task-master'`},{name:`hamster`,line:`alias hamster='task-master'`},{name:`ham`,line:`alias ham='task-master'`}].filter(t=>!e.includes(t.line));if(n.length===0)return X(`debug`,`All Task Master aliases already exist.`),!0;let r=n.map(e=>e.line).join(`
+`),i=`
+# Task Master aliases added on ${new Date().toLocaleDateString()}
+${r}
+`;return S.appendFileSync(t,i),X(`debug`,`Added ${n.length} alias(es): ${n.map(e=>e.name).join(`, `)}`),!0}catch(e){return X(`debug`,`Failed to add aliases: ${e.message}`),!1}}function hn(e){let t=C.join(e,d);if(S.existsSync(t)){X(`debug`,`State file already exists, preserving current configuration`);return}let n={currentTag:`master`,lastSwitched:new Date().toISOString(),branchTagMapping:{},migrationNoticeShown:!1};try{S.writeFileSync(t,JSON.stringify(n,null,2)),X(`success`,`Created initial state file: ${t}`),X(`info`,`Default tag set to "master" for task organization`)}catch(e){X(`error`,`Failed to create state file: ${e.message}`)}}function Q(e,t,n={}){if(!xe(e)){X(`error`,`Source file not found: ${e}`);return}let r=L(e,`utf8`);if(Object.entries(n).forEach(([e,t])=>{let n=RegExp(`\\{\\{${e}\\}\\}`,`g`);r=r.replace(n,t)}),S.existsSync(t)){let e=C.basename(t);if(e===`.gitignore`){X(`info`,`${t} already exists, merging content...`);let e=S.readFileSync(t,`utf8`),n=new Set(e.split(`
+`).map(e=>e.trim())),i=r.split(`
+`).filter(e=>!n.has(e.trim()));if(i.length>0){let n=`${e.trim()}\n\n# Added by Taskmaster\n${i.join(`
+`)}`;S.writeFileSync(t,n),X(`success`,`Updated ${t} with additional entries`)}else X(`info`,`No new content to add to ${t}`);return}if(e===`README-task-master.md`){X(`info`,`${t} already exists`);let e=C.join(C.dirname(t),`README-task-master.md`);S.writeFileSync(e,r),X(`success`,`Created ${e} (preserved original README-task-master.md)`);return}X(`debug`,`${t} already exists, skipping.`);return}S.writeFileSync(t,r),X(`info`,`Created file: ${t}`)}async function gn(e={}){m()||pn(),e.git===!0?e.initGit=!0:e.git===!1&&(e.initGit=!1),e.gitTasks===!0?e.storeTasksInGit=!0:e.gitTasks===!1&&(e.storeTasksInGit=!1);let t=e.yes||e.name&&e.description,n;if(n=e.rulesExplicitlyProvided?e.rules:[],t){m()||console.log(`SKIPPING PROMPTS - Using defaults or provided values`),e.name,e.description,e.version,e.author;let t=e.dryRun||!1,r=e.initGit===void 0?!0:e.initGit,i=e.storeTasksInGit===void 0?!0:e.storeTasksInGit;if(t)return X(`info`,`DRY RUN MODE: No files will be modified`),X(`info`,`Would initialize Task Master project`),X(`info`,`Would create/update necessary project files`),X(`info`,`${r?`Would initialize Git repository`:`Would skip Git initialization`}`),X(`info`,`${i?`Would store tasks in Git`:`Would exclude tasks from Git`}`),{dryRun:!0};let a=e.storage||`local`;await bn(!0,r,i,t,{...e,preferredLanguage:`English`},n,a,null)}else{X(`debug`,`Required options not provided, proceeding with prompts.`);let t;try{let r=_n();X(`debug`,`Init started - taskmaster_id: ${r}`);let i=await yn();X(`debug`,`Storage selected: ${i} - taskmaster_id: ${r}`);let a=null;if(i===`cloud`)try{let e=f.getInstance(),t=await e.getAuthCredentials();t?(X(`success`,`Already authenticated with Hamster`),a=t):(X(`info`,`Starting authentication flow...`),console.log(x.blue(`
+🔐 Authentication Required
+`)),console.log(x.white(`  Selecting cloud storage will open your browser for authentication.`)),console.log(x.gray(`  This enables sync across devices with Hamster.
+`)),a=await _(e),X(`debug`,`Auth completed - taskmaster_id: ${r}`));let n=await v(e,{promptMessage:`Select an organization to continue:`});n.success||X(`warn`,n.message||`Organization selection required`)}catch(e){X(`error`,`Failed to authenticate: ${e.message}. Falling back to local storage.`),i=`local`}t=A.createInterface({input:process.stdin,output:process.stdout});let o=!0,s=!0;i===`local`?(o=e.initGit===void 0?(await $(t,x.cyan(`Initialize a Git repository in project root? (Y/n): `),e=>{let t=e.trim().toLowerCase()!==`n`,n=t?x.green(`✓`):x.red(`✗`);return x.cyan(`Initialize a Git repository in project root?`)+` `+n+` `+x.dim(t?`Yes`:`No`)})).trim().toLowerCase()!==`n`:e.initGit,s=e.storeTasksInGit===void 0?(await $(t,x.cyan(`Store tasks in Git (tasks.json and tasks/ directory)? (Y/n): `),e=>{let t=e.trim().toLowerCase()!==`n`,n=t?x.green(`✓`):x.red(`✗`);return x.cyan(`Store tasks in Git (tasks.json and tasks/ directory)?`)+` `+n+` `+x.dim(t?`Yes`:`No`)})).trim().toLowerCase()!==`n`:e.storeTasksInGit):(o=!0,s=!1);let c=!1;e.rulesExplicitlyProvided?X(`info`,`Using rule profiles provided via command line: ${n.join(`, `)}`):c=(await $(t,x.cyan(`Set up AI IDE rules for better integration? (Cursor, Windsurf, etc.) (y/N): `),e=>{let t=e.trim().toLowerCase()===`y`,n=t?x.green(`✓`):x.red(`✗`);return x.cyan(`Set up AI IDE rules for better integration?`)+` `+n+` `+x.dim(t?`Yes`:`No`)})).trim().toLowerCase()===`y`;let l=(await $(t,x.cyan(`Preferred response language (English): `))).trim()||`English`;console.log(`
+`+x.bold(`Taskmaster Project Settings:`)),console.log(x.dim(`─`.repeat(50))),console.log(`  `+x.dim(`Storage:`.padEnd(32)),x.white(i===`cloud`?`Hamster Studio`:`Local File Storage`));let u=c?x.green(`✓`):x.dim(`✗`);if(console.log(`  `+x.dim(`AI IDE rules:`.padEnd(32)),u+` `+x.dim(c?`Yes`:`No`)),console.log(`  `+x.dim(`Response language:`.padEnd(32)),x.white(l)),i===`local`){let e=o?x.green(`✓`):x.dim(`✗`);console.log(`  `+x.dim(`Initialize Git repository:`.padEnd(32)),e+` `+x.dim(o?`Yes`:`No`));let t=s?x.green(`✓`):x.dim(`✗`);console.log(`  `+x.dim(`Store tasks in Git:`.padEnd(32)),t+` `+x.dim(s?`Yes`:`No`))}if(console.log(x.dim(`─`.repeat(50))),(await $(t,x.yellow(`
+Do you want to continue with these settings? (Y/n): `))).trim().toLowerCase()===`n`){t.close(),X(`info`,`Project initialization cancelled by user`),process.exit(0);return}let d=e.dryRun||!1;if(d)return X(`info`,`DRY RUN MODE: No files will be modified`),X(`info`,`Would initialize Task Master project`),X(`info`,`Would create/update necessary project files`),X(`info`,`${o?`Would initialize Git repository`:`Would skip Git initialization`}`),X(`info`,`${s?`Would store tasks in Git`:`Would exclude tasks from Git`}`),{dryRun:!0};await bn(!0,o,s,d,{...e,shouldSetupRules:c,preferredLanguage:l},n,i,a),t.close()}catch(e){t&&t.close(),X(`error`,`Error during initialization process: ${e.message}`),process.exit(1)}}}function $(e,t,n){return new Promise(r=>{e.question(t,e=>{A.moveCursor(process.stdout,0,-1),A.cursorTo(process.stdout,0),A.clearLine(process.stdout,0),n&&process.stdout.write(n(e)+`
+`),r(e)})})}function _n(){return w()}function vn(e,t,n){try{if(!S.existsSync(e)){X(`warn`,`Config file does not exist, skipping storage configuration`);return}let n=S.readFileSync(e,`utf8`),r=JSON.parse(n);r.storage||={},t===`cloud`?(r.storage.type=`api`,r.storage.apiEndpoint=process.env.TM_BASE_DOMAIN||process.env.TM_PUBLIC_BASE_DOMAIN||`https://tryhamster.com/api`,r.storage.operatingMode=`team`,X(`debug`,`Connected to Hamster Studio`)):(r.storage.type=`file`,r.storage.operatingMode=`solo`,X(`debug`,`Configured storage for local file storage`)),S.writeFileSync(e,JSON.stringify(r,null,2)),X(`debug`,`Storage configuration updated in config.json`)}catch(e){X(`error`,`Failed to update storage configuration: ${e.message}`)}}async function yn(){if(m())return`local`;try{console.log(x.bold.cyan(`You need a plan before you execute.
+`));let{storageType:e}=await ie.prompt([{type:`list`,name:`storageType`,message:x.white(`How do you want to build it?
+`),choices:[{name:[x.bold(`Solo (Taskmaster)`),``,x.white(`   • Parse your own PRDs into structured task lists and build with any IDE or background agents`),x.white(`   • Agents execute tasks with precision, no scope creep, no going off-track`),x.white(`   • Tasks live in a local JSON file, everything stays in your repo`),x.white(`   • Upgrade to Hamster to bring the Taskmaster experience to your team`),``].join(`
+`),value:`local`,short:`Solo (Taskmaster)`},{name:[x.bold(`Together (Hamster)`),``,x.white(`   • Write a brief with your team. Hamster refines it into a plan.`),x.white(`   • Your team drafts, refines, and aligns on the same page before executing`),x.white(`   • One brief, one plan, one source of truth for execution`),x.white(`   • Access tasks on Taskmaster and execute with any AI agent`),``].join(`
+`),value:`cloud`,short:`Together (Hamster)`}],default:`local`,pageSize:20}]);return e}catch(e){if(e.isTtyError||e.name===`ExitPromptError`)return X(`warn`,`Storage selection cancelled, defaulting to local storage`),`local`;throw e}}async function bn(e,n,s,d,f,h=j,_=`local`,v=null){let y=process.cwd();X(`debug`,`Initializing project in ${y}`),Z(C.join(y,u)),Z(C.join(y,i)),Z(C.join(y,a)),Z(C.join(y,l)),Z(C.join(y,p)),hn(y);let b={year:new Date().getFullYear()},S=_===`cloud`?`team`:`solo`;function w(e){let t=q(e);t?J(y,t,{mode:S}):X(`warn`,`Unknown rule profile: ${e}`)}Q(`env.example`,C.join(y,c),b),Q(`config.json`,C.join(y,t),{...b});let T=C.join(y,t);dn(T)?X(`debug`,`Updated config with correct maxTokens values`):X(`debug`,`Could not update maxTokens in config`),vn(T,_,v);try{let e=L(`gitignore`,`utf8`);ve(C.join(y,o),e,s,X)}catch(e){X(`error`,`Failed to create .gitignore: ${e.message}`)}Q(`example_prd.txt`,C.join(y,r)),Q(`example_prd_rpg.txt`,C.join(y,p,`example_prd_rpg.txt`));try{n===!1?X(`info`,`Git initialization skipped due to --no-git flag.`):n===!0?g()?X(`debug`,`Existing Git repository detected – skipping git init despite --git flag.`):(X(`info`,`Initializing Git repository due to --git flag...`),D(`git init`,{cwd:y,stdio:`ignore`}),X(`success`,`Git repository initialized`)):g()?X(`debug`,`Existing Git repository detected – skipping git init.`):(X(`info`,`No Git repository detected. Initializing one in project root...`),D(`git init`,{cwd:y,stdio:`ignore`}),X(`success`,`Git repository initialized`))}catch{X(`warn`,`Git not available, skipping repository initialization`)}if(f.rulesExplicitlyProvided||f.yes){X(`info`,`Generating profile rules from command-line flags...`);for(let e of h)w(e)}e&&mn();let E={cwd:y,stdio:`inherit`};if(m()&&(E.stdio=`ignore`,X(`info`,`Running npm install silently...`)),f.shouldSetupRules&&!m()&&!d&&!f?.yes&&!f.rulesExplicitlyProvided){console.log(k(x.cyan(`Configuring Rule Profiles...`),{padding:.5,margin:{top:1,bottom:.5},borderStyle:`round`,borderColor:`cyan`,width:60})),X(`info`,`Running interactive rules setup. Please select which rule profiles to include.`);try{D(`npx task-master rules --setup`,{stdio:`inherit`,cwd:y}),X(`success`,`Rule profiles configured.`)}catch(e){X(`error`,`Failed to configure rule profiles:`,e.message),X(`warn`,`You may need to run "task-master rules --setup" manually.`)}}else m()||d||f?.yes?f.rulesExplicitlyProvided?X(`debug`,`Skipping interactive rules setup because --rules flag was used.`):X(`debug`,`Skipping interactive rules setup in non-interactive mode.`):f.shouldSetupRules||X(`debug`,`Skipping rules setup - user declined.`);if(f.preferredLanguage&&!d)try{let e=(await import(`./response-language-LzM2RD6-.js`)).default;e(f.preferredLanguage,{projectRoot:y,silent:!0}),X(`debug`,`Response language set to: ${f.preferredLanguage}`)}catch(e){X(`warn`,`Failed to set response language: ${e.message}`)}else m()&&!d?X(`debug`,`Skipping response language setup in silent (MCP) mode.`):d&&X(`debug`,`DRY RUN: Skipping response language setup.`);if(!m()&&!d&&!f?.yes&&_===`local`){console.log(k(x.cyan(`Configuring AI Models...`),{padding:.5,margin:{top:1,bottom:.5},borderStyle:`round`,borderColor:`cyan`,width:60})),X(`info`,`Running interactive model setup. Please select your preferred AI models.`);try{D(`npx task-master models --setup`,{stdio:`inherit`,cwd:y}),X(`success`,`AI Models configured.`)}catch(e){X(`error`,`Failed to configure AI models:`,e.message),X(`warn`,`You may need to run "task-master models --setup" manually.`)}}else _===`cloud`&&!d?console.log(k(x.green.bold(`✓ AI Models Managed by Hamster - go ham!
+
+`)+x.white(`Hamster handles all AI model configuration for you.
+`)+x.dim(`• Optimized model selection for your tasks
+`)+x.dim(`• No API keys required
+`)+x.dim(`• No extra costs`),{padding:1,margin:{top:1,bottom:.5},borderStyle:`round`,borderColor:`cyan`,width:60})):m()&&!d?(X(`info`,`Skipping interactive model setup in silent (MCP) mode.`),X(`warn`,`Please configure AI models using "task-master models --set-..." or the "models" MCP tool.`)):d?X(`info`,`DRY RUN: Skipping interactive model setup.`):f?.yes&&(X(`info`,`Skipping interactive model setup due to --yes flag.`),X(`info`,`Default AI models will be used. You can configure different models later using "task-master models --setup" or "task-master models --set-..." commands.`));if(e&&!d?(X(`debug`,`Adding shell aliases...`),mn()&&X(`debug`,`Shell aliases added successfully`)):e&&d&&X(`debug`,`DRY RUN: Would add shell aliases (tm, taskmaster)`),!m())if(_===`cloud`){let e=L(`hamster-art.txt`,`utf8`);console.log(`
+`+x.cyan(e)),console.log(``);let t=[x.green.bold(`✓ Connected to Hamster Studio`),``,x.white(`Your team's workspace is ready to go ham!
+`),x.dim(`Draft together. Align once. Build with agents.`),``,x.cyan(`How to orchestrate with Taskmaster:`),x.white(`  • Create your first brief at: `)+x.underline.cyan(`https://tryhamster.com`),x.white(`  • Connect your brief using `)+x.bold(`tm context <brief-url>`)+x.white(` to access tasks in Taskmaster`),x.white(`  • Orchestrate and implement tasks using `)+x.bold(`tm next`)+x.white(` to kickoff any AI agent`),x.white(`  • Run `)+x.bold(`tm help`)+x.white(` to explore other available commands`),x.white(`  • Run `)+x.bold(`tm rules --setup`)+x.white(` to configure AI IDE rules for better integration`)].join(`
+`);console.log(k(t,{padding:1,margin:{top:1,bottom:0,left:0,right:0},borderStyle:`round`,borderColor:`cyan`,width:60}))}else console.log(k(`${ee.multiline(ne.textSync(`Success!`,{font:`Standard`}))}\n${x.green(`Project initialized successfully!`)}`,{padding:1,margin:1,borderStyle:`double`,borderColor:`green`,width:60}));if(!m()){let e;e=_===`cloud`?`${x.cyan.bold(`Here's how to execute your Hamster briefs with Taskmaster`)}\n\n${x.white(`1. `)}${x.yellow(`Create your first brief at`)} ${x.cyan.underline(`https://tryhamster.com`)}\n${x.white(`   └─ `)}${x.dim(`Hamster will write your brief and generate the full task plan`)}\n${x.white(`2. `)}${x.yellow(`Add rules for your AI IDE(s)`)}\n${x.white(`   └─ `)}${x.dim(`CLI: `)}${x.cyan(`tm rules --setup`)}${x.dim(` - Opens interactive setup`)}\n${x.white(`3. `)}${x.yellow(`Connect your brief to Taskmaster`)}\n${x.white(`   └─ `)}${x.dim(`CLI: `)}${x.cyan(`tm context <brief-url> OR tm briefs`)}\n${x.white(`4. `)}${x.yellow(`View your tasks from the brief`)}\n${x.white(`   └─ `)}${x.dim(`CLI: `)}${x.cyan(`tm list`)}${x.dim(` or `)}${x.cyan(`tm list all`)}${x.dim(` (with subtasks)`)}\n${x.white(`5. `)}${x.yellow(`Work on tasks with any AI coding assistant or background agent`)}\n${x.white(`   ├─ `)}${x.dim(`CLI: `)}${x.cyan(`tm next`)}${x.dim(` - Find the next task to work on`)}\n${x.white(`   ├─ `)}${x.dim(`CLI: `)}${x.cyan(`tm show <id>`)}${x.dim(` - View task details`)}\n${x.white(`   ├─ `)}${x.dim(`CLI: `)}${x.cyan(`tm status <id> in-progress`)}${x.dim(` - Mark task started`)}\n${x.white(`   └─ `)}${x.dim(`CLI: `)}${x.cyan(`tm status <id> done`)}${x.dim(` - Mark task complete`)}\n${x.white(`6. `)}${x.yellow(`Add notes or updates to tasks`)}\n${x.white(`   └─ `)}${x.dim(`CLI: `)}${x.cyan(`tm update-task <id> <notes>`)}\n${x.white(`7. `)}${x.green.bold(`Ship it!`)}\n\n${x.dim(`* Run `)}${x.cyan(`tm help`)}${x.dim(` to see all available commands`)}`:`${x.cyan.bold(`Things you should do next:`)}\n\n${x.white(`1. `)}${x.yellow("Configure AI models and add API keys to `.env`")}\n${x.white(`   ├─ `)}${x.dim(`Models: Use `)}${x.cyan(`task-master models`)}${x.dim(` commands`)}\n${x.white(`   └─ `)}${x.dim(`Keys: Add provider API keys to .env (or .cursor/mcp.json)`)}\n${x.white(`2. `)}${x.yellow(`Discuss your idea with AI and create a PRD`)}\n${x.white(`   ├─ `)}${x.dim(`Simple projects: Use `)}${x.cyan(`example_prd.txt`)}${x.dim(` template`)}\n${x.white(`   └─ `)}${x.dim(`Complex systems: Use `)}${x.cyan(`example_prd_rpg.txt`)}${x.dim(` template`)}\n${x.white(`3. `)}${x.yellow(`Parse your PRD to generate initial tasks`)}\n${x.white(`   └─ `)}${x.dim(`CLI: `)}${x.cyan(`task-master parse-prd .taskmaster/docs/prd.txt`)}\n${x.white(`4. `)}${x.yellow(`Analyze task complexity`)}\n${x.white(`   └─ `)}${x.dim(`CLI: `)}${x.cyan(`task-master analyze-complexity --research`)}\n${x.white(`5. `)}${x.yellow(`Expand tasks into subtasks`)}\n${x.white(`   └─ `)}${x.dim(`CLI: `)}${x.cyan(`task-master expand --all --research`)}\n${x.white(`6. `)}${x.yellow(`Start working on tasks`)}\n${x.white(`   └─ `)}${x.dim(`CLI: `)}${x.cyan(`task-master next`)}\n${x.white(`7. `)}${x.green.bold(`Ship it!`)}\n\n${x.dim(`* Run `)}${x.cyan(`task-master --help`)}${x.dim(` to see all available commands`)}\n${x.dim(`* Run `)}${x.cyan(`tm rules --setup`)}${x.dim(` to configure AI IDE rules for better integration`)}`,console.log(k(x.yellow.bold(`Workflow
+`)+`
+`+e,{padding:1,margin:{top:0,bottom:1,left:0,right:0},borderStyle:`round`,borderColor:`yellow`,width:60}))}}const xn={ADD:`add`,REMOVE:`remove`},Sn=`setup`;function Cn(e){return Object.values(xn).includes(e)}function wn(e){try{return q(e).displayName||e}catch{return e}}function Tn(e){let t=[];for(let n of j)try{let r=q(n),i=C.join(e,r.profileDir);if(r.profileDir===`.`||S.existsSync(i)){let i=C.join(e,r.rulesDir);S.existsSync(i)&&Object.values(r.fileMap).some(e=>S.existsSync(C.join(i,e)))&&t.push(n)}}catch{}return t}function En(e,t){let n=Tn(e);return n.length===0?!1:n.filter(e=>!t.includes(e)).length===0}async function Dn(e=process.cwd()){let t=ut({projectRoot:e});if(t.length>0){let e=t.map(e=>wn(e)).join(`, `);console.log(x.cyan(`\n🔍 Auto-detected IDEs: ${e}`)+x.gray(` (pre-selected below)
+`))}let n=j.map(e=>{let t=wn(e),n=q(e),r,i=Object.keys(n.fileMap).length>0,a=n.mcpConfig===!0;return n.includeDefaultRules?i&&a?r=e===`roo`?`Rule profile, MCP config, and agent modes`:`Rule profile and MCP config`:i&&(r=`Rule profile`):r=e===`claude`?`Integration guide with Task Master slash commands`:e===`codex`?`Comprehensive Task Master integration guide`:a?`Integration guide and MCP config`:`Integration guide`,{profileName:e,displayName:t,description:r}}).sort((e,t)=>e.displayName.localeCompare(t.displayName)),r=n.map(({displayName:e,description:t})=>`${x.white(`• `)}${x.yellow(e)}${x.white(` - ${t}`)}`).join(`
+`);console.log(k(`${x.white.bold(`Rule Profiles Setup`)}\n\n${x.white(`Rule profiles help enforce best practices and conventions for Task Master.
+Each profile provides coding guidelines tailored for specific AI coding environments.
+
+`)}${x.cyan(`Available Profiles:`)}\n${r}`,{padding:1,borderColor:`blue`,borderStyle:`round`,margin:{top:1,bottom:1}}));let i=n.map(({profileName:e,displayName:n})=>({name:t.includes(e)?`${n} ${x.dim(`(detected)`)}`:n,value:e,checked:t.includes(e)})),a={type:`checkbox`,name:`ruleProfiles`,message:`Which rule profiles would you like to add to your project?`,choices:i,pageSize:i.length,loop:!1,validate:e=>e.length>0||`You must select at least one.`},{ruleProfiles:o}=await ie.prompt([a]);return o}async function On(e,t,r){let i=[],a=await n(r);for(let n=0;n<e.length;n++){let r=e[n];if(console.log(x.blue(`Processing profile ${n+1}/${e.length}: ${r}...`)),!K(r)){console.warn(`Rule profile for "${r}" not found. Valid profiles: ${j.join(`, `)}. Skipping.`);continue}let o=J(t,q(r),{mode:a});i.push({profileName:r,success:o.success,failed:o.failed}),console.log(x.green(kn(r,o)))}return i}function kn(e,t){return q(e).includeDefaultRules?`Summary for ${e}: ${t.success} files processed, ${t.failed} failed.`:`Summary for ${e}: Integration guide installed.`}function An(e,t){if(t.skipped)return`Summary for ${e}: Skipped (default or protected files)`;if(t.error&&!t.success)return`Summary for ${e}: Failed to remove - ${t.error}`;if(q(e).includeDefaultRules){let n=`Summary for ${e}: Rule profile removed`;return t.notice?`${n} (${t.notice})`:n}else{let n=`Summary for ${e}: Integration guide removed`;return t.notice?`${n} (${t.notice})`:n}}function jn(e){let t=[],n=0,r=0;return e.forEach(e=>{n+=e.success,r+=e.failed,(e.success>0||e.failed===0)&&t.push(e.profileName)}),{successfulProfiles:t,allSuccessfulProfiles:t,totalSuccess:n,totalFailed:r}}function Mn(e){let t=[],n=[],r=[],i=[];return e.forEach(e=>{e.success?t.push(e.profileName):e.skipped?n.push(e.profileName):e.error&&r.push(e),e.notice&&i.push(e)}),{successfulRemovals:t,skippedRemovals:n,failedRemovals:r,removalsWithNotices:i}}export{lt as _,Tn as a,En as c,Cn as d,gn as f,un as g,K as h,kn as i,xn as l,q as m,Mn as n,On as o,J as p,An as r,Dn as s,jn as t,Sn as u,j as v};