devstack 0.1.0

package/vendor/skills/skills/pal/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: pal
+description: Comprehensive Pal MCP toolkit for code analysis, debugging, planning, refactoring, code review, and execution tracing. Provides systematic workflows with expert validation for complex development tasks.
+---
+
+# Pal MCP Toolkit
+
+The Pal MCP toolkit provides specialized tools for comprehensive code analysis and development workflows. Each tool follows a multi-step workflow pattern with expert validation.
+
+## Quick Reference: Tool Selection
+
+| Task Type                                         | Tool                   | Reference                             |
+| ------------------------------------------------- | ---------------------- | ------------------------------------- |
+| Architecture & code analysis before complex tasks | `mcp__zen__analyze`    | [analyze.md](references/analyze.md)   |
+| Bug investigation & root cause analysis           | `mcp__zen__debug`      | [debug.md](references/debug.md)       |
+| Strategic planning & task breakdown               | `mcp__zen__planner`    | [planner.md](references/planner.md)   |
+| Code smell detection & refactoring                | `mcp__zen__refactor`   | [refactor.md](references/refactor.md) |
+| Code review after completing tasks                | `mcp__zen__codereview` | [review.md](references/review.md)     |
+| Execution flow & dependency tracing               | `mcp__zen__tracer`     | [tracer.md](references/tracer.md)     |
+
+## Critical Workflow Requirements
+
+<critical>
+
+### Mandatory Completion Rules
+
+- **NEVER** stop a workflow before `next_step_required: false` is returned
+- **ALWAYS** increment `step_number` and call the tool again when `next_step_required: true`
+- **TASK INVALIDATION**: Incomplete workflows result in immediate task rejection
+- **NO EXCEPTIONS**: Even if analysis seems complete after step 1, you MUST complete all steps
+
+### Model Requirement
+
+- **MANDATORY**: Always use `model: "anthropic/claude-opus-4.6"` for ALL Pal MCP tool calls
+- **NEVER** use any other model when calling Pal MCP tools
+
+### Workflow Validation Checklist
+
+1. Check `next_step_required` in every response
+2. If `true`, call the tool again with incremented `step_number`
+3. Never proceed with implementation while `next_step_required: true`
+4. Workflow is complete ONLY when `next_step_required: false`
+
+</critical>
+
+## Tool Overview
+
+### Analyze (`mcp__zen__analyze`)
+
+**When to Use:**
+
+- Before complex tasks to understand existing architecture
+- Architecture review and system design assessment
+- Performance, security, and technical debt analysis
+
+**Key Parameters:**
+
+- `analysis_type`: `"architecture"` | `"performance"` | `"security"` | `"quality"` | `"general"`
+- `output_format`: `"summary"` | `"detailed"` | `"actionable"`
+
+See [references/analyze.md](references/analyze.md) for complete documentation.
+
+---
+
+### Debug (`mcp__zen__debug`)
+
+**When to Use:**
+
+- Bug investigation and root cause analysis
+- Performance issues, memory leaks, race conditions
+- Integration failures and service communication problems
+
+**Key Parameters:**
+
+- `hypothesis`: Current theory about the root cause
+- `confidence`: `"exploring"` | `"low"` | `"medium"` | `"high"` | `"very_high"` | `"almost_certain"` | `"certain"`
+
+See [references/debug.md](references/debug.md) for complete documentation.
+
+---
+
+### Planner (`mcp__zen__planner`)
+
+**When to Use:**
+
+- Breaking down complex tasks into manageable steps
+- System design and architectural decisions
+- Migration planning and implementation strategies
+
+**Key Parameters:**
+
+- `is_step_revision`: For refining previous steps
+- `is_branch_point`: For exploring alternative approaches
+- `branch_id`: Naming alternative approaches
+
+See [references/planner.md](references/planner.md) for complete documentation.
+
+---
+
+### Refactor (`mcp__zen__refactor`)
+
+**When to Use:**
+
+- Addressing code smells and technical debt
+- Decomposing large modules or classes
+- Modernizing legacy patterns
+
+**Key Parameters:**
+
+- `refactor_type`: `"codesmells"` | `"decompose"` | `"modernize"` | `"organization"`
+- `focus_areas`: `["performance", "readability", "maintainability", "security"]`
+
+See [references/refactor.md](references/refactor.md) for complete documentation.
+
+---
+
+### Code Review (`mcp__zen__codereview`)
+
+**When to Use:**
+
+- After completing a task (MANDATORY)
+- Before submitting pull requests
+- Validating implementation against project standards
+
+**Key Parameters:**
+
+- `review_type`: `"full"` for comprehensive analysis
+- `severity_filter`: `"all"` to catch all severity levels
+- `focus_on`: Specific areas like "performance", "security", "type-safety"
+
+See [references/review.md](references/review.md) for complete documentation.
+
+---
+
+### Tracer (`mcp__zen__tracer`)
+
+**When to Use:**
+
+- Understanding code execution paths
+- Mapping dependencies before refactoring
+- Debugging complex flows
+
+**Key Parameters:**
+
+- `trace_mode`: `"precision"` (execution flow) | `"dependencies"` (structural analysis) | `"ask"`
+- `target_description`: Clear description of what to trace and why
+
+See [references/tracer.md](references/tracer.md) for complete documentation.
+
+## Common Required Parameters
+
+All Pal MCP tools require these base parameters:
+
+```json
+{
+  "step": "Description of current step",
+  "step_number": 1,
+  "total_steps": 2,
+  "next_step_required": true,
+  "findings": "Findings from this step",
+  "model": "anthropic/claude-opus-4.6"
+}
+```
+
+## File Path Requirements
+
+- **ALWAYS** use full absolute paths for `relevant_files`
+- Include files directly involved in the analysis
+- Include related files that provide context
+- Include test files when relevant
+
+## Typical Workflow Pattern
+
+1. **Start**: Call the tool with `step_number: 1` and initial strategy
+2. **Iterate**: Increment `step_number` and refine findings based on previous step
+3. **Continue**: Keep calling until `next_step_required: false`
+4. **Complete**: Only proceed with implementation after workflow completes
+
+## Violation Examples (Task Rejection)
+
+- Calling a Pal tool once and proceeding to implementation
+- Skipping steps because analysis seems complete
+- Starting implementation before `next_step_required: false`
+- Using a model other than `anthropic/claude-opus-4.6`

package/vendor/skills/skills/pal/references/analyze.md

@@ -0,0 +1,77 @@
+# Pal Analyze Reference
+
+Expert guidance for using the Pal MCP analyze tool for comprehensive code and architecture analysis.
+
+## When to Use
+
+- **Before complex tasks:** Understand existing architecture and code structure before making changes
+- **Architecture review:** Assess system design and identify architectural improvements
+- **Performance analysis:** Identify bottlenecks and optimization opportunities
+- **Security assessment:** Evaluate security posture and identify vulnerabilities
+- **Technical debt:** Assess code quality and identify refactoring needs
+- **System understanding:** Gain comprehensive understanding of codebase structure and patterns
+
+## Analysis Scope
+
+The analyze tool must examine:
+
+- **Architecture patterns:** System design, component relationships, architectural decisions, design patterns
+- **Code quality:** Maintainability, readability, complexity, code organization
+- **Performance characteristics:** Algorithm efficiency, scalability, resource usage, optimization opportunities
+- **Security posture:** Vulnerability patterns, security best practices, risk assessment
+- **Technical debt:** Legacy patterns, deprecated code, refactoring needs, modernization opportunities
+- **System structure:** Module boundaries, dependency graphs, interface contracts, integration points
+
+## Required Parameters
+
+```json
+{
+  "step": "Analyze architecture and code structure",
+  "step_number": 1,
+  "total_steps": 2,
+  "next_step_required": true,
+  "findings": "Initial analysis findings",
+  "relevant_files": ["/absolute/path/to/file.ts"],
+  "model": "anthropic/claude-opus-4.6"
+}
+```
+
+## Analysis Types
+
+Use `analysis_type` to specify focus:
+
+- `"architecture"` - System design and architectural pattern analysis
+- `"performance"` - Performance bottlenecks and optimization analysis
+- `"security"` - Security-focused analysis and vulnerability assessment
+- `"quality"` - Code quality, maintainability, and technical debt analysis
+- `"general"` - Comprehensive multi-faceted analysis (default)
+
+## Output Formats
+
+Use `output_format` to control detail level:
+
+- `"summary"` - High-level overview and key findings
+- `"detailed"` - Comprehensive analysis with full context (default)
+- `"actionable"` - Focused recommendations and improvement plans
+
+## Relevant Files
+
+- Include full absolute paths to files or directories to analyze
+- Include related files that form part of the system architecture
+- Include configuration files if analyzing system configuration
+- Include test files to understand testing patterns and coverage
+
+## Analysis Process
+
+1. Start with `step_number: 1` and outline analysis strategy
+2. Progressively build understanding through multiple steps
+3. Document `findings` at each step covering architecture, performance, security, and quality
+4. Update `confidence` as analysis deepens
+5. Continue until comprehensive understanding is achieved (`next_step_required: false`)
+
+## Critical Requirements
+
+- **MANDATORY**: Use Pal MCP analyze tool **BEFORE INITIATING COMPLEX TASKS** or **WHEN NEEDING ARCHITECTURAL INSIGHTS**
+- **TASK INVALIDATION**: Task will be invalidated if you skip using the analyze tool when required or don't complete ALL steps
+- **NO EXCEPTIONS**: Complete the entire analyze workflow (all steps until `next_step_required: false`) before proceeding with implementation
+- **COMPLETE ALL STEPS**: Never stop in the middle of steps - completing partial workflows invalidates the task

package/vendor/skills/skills/pal/references/debug.md

@@ -0,0 +1,78 @@
+# Pal Debug Reference
+
+Expert guidance for using the Pal MCP debug tool for systematic debugging and root cause analysis.
+
+## When to Use
+
+- **Bug investigation:** Systematic root cause analysis for reported bugs
+- **Performance issues:** Debugging slow operations, memory leaks, or resource exhaustion
+- **Integration failures:** Investigating API failures, service communication problems
+- **Race conditions:** Identifying concurrency issues and timing problems
+- **Before complex tasks:** Understanding existing issues before making changes
+
+## Debugging Scope
+
+The debug tool must analyze:
+
+- **Root cause identification:** Systematic investigation of error sources, failure points, and contributing factors
+- **Error patterns:** Recurring issues, exception types, error propagation paths
+- **State analysis:** Data inconsistencies, state corruption, race conditions
+- **Execution anomalies:** Unexpected behavior, performance degradation, memory issues
+- **Integration problems:** API failures, service communication issues, external dependency failures
+- **Hypothesis testing:** Systematic validation of theories about the issue
+
+## Required Parameters
+
+```json
+{
+  "step": "Investigate reported issue",
+  "step_number": 1,
+  "total_steps": 3,
+  "next_step_required": true,
+  "findings": "Initial investigation findings",
+  "hypothesis": "Initial theory about the root cause",
+  "confidence": "exploring",
+  "model": "anthropic/claude-opus-4.6"
+}
+```
+
+## Debugging Approach
+
+- Provide clear description of the issue or problem to investigate
+- Include `hypothesis` if you have initial theories about the root cause
+- Specify `relevant_context` (methods, functions, or components involved)
+- Use `confidence` levels to track investigation progress
+
+## Confidence Levels
+
+Track investigation progress with confidence levels:
+
+1. `"exploring"` - Starting investigation
+2. `"low"` - Early theories, limited evidence
+3. `"medium"` - Some evidence supports hypothesis
+4. `"high"` - Strong evidence for root cause
+5. `"very_high"` - Very confident in findings
+6. `"almost_certain"` - Nearly confirmed
+7. `"certain"` - Root cause definitively identified
+
+## Relevant Files
+
+- Include full absolute paths to files where the issue manifests
+- Include related files that might be involved in the problem
+- Include test files that reproduce or verify the issue
+- Include configuration files if the issue might be configuration-related
+
+## Investigation Process
+
+1. Start with `step_number: 1` and provide initial findings
+2. Progressively refine `hypothesis` based on evidence gathered
+3. Update `confidence` as investigation progresses
+4. Document all `findings` at each step
+5. Continue until root cause is identified (`next_step_required: false`)
+
+## Critical Requirements
+
+- **MANDATORY**: Use Pal MCP debug tool **WHEN DEBUGGING ISSUES** or **BEFORE INITIATING COMPLEX TASKS**
+- **TASK INVALIDATION**: Task will be invalidated if you skip using the debug tool when debugging issues or don't complete ALL steps
+- **NO EXCEPTIONS**: Complete the entire debug workflow (all steps until `next_step_required: false`) before proceeding with fixes or implementation
+- **COMPLETE ALL STEPS**: Never stop in the middle of steps - completing partial workflows invalidates the task

package/vendor/skills/skills/pal/references/planner.md

@@ -0,0 +1,101 @@
+# Pal Planner Reference
+
+Expert guidance for using the Pal MCP planner tool for strategic planning and task breakdown.
+
+## When to Use
+
+- **Before complex tasks:** Break down complex tasks into manageable steps with clear dependencies
+- **System design:** Plan architectural decisions and component design
+- **Migration planning:** Develop migration strategies and execution plans
+- **Project planning:** Define milestones, timelines, and resource requirements
+- **Architectural decisions:** Evaluate technology choices and design alternatives
+- **Implementation strategy:** Plan phased implementation and incremental delivery
+
+## Planning Scope
+
+The planner tool must analyze:
+
+- **Task breakdown:** Decomposing complex tasks into manageable steps, identifying dependencies, sequencing work
+- **System design:** Architectural decisions, component design, interface definitions, integration strategies
+- **Migration strategies:** Migration paths, data transformation, backward compatibility, rollback plans
+- **Project planning:** Milestone definition, resource allocation, timeline estimation, risk assessment
+- **Architectural decisions:** Technology choices, pattern selection, trade-off analysis, design alternatives
+- **Implementation strategy:** Phased approach, incremental delivery, testing strategy, deployment plan
+
+## Required Parameters
+
+```json
+{
+  "step": "Current planning phase description",
+  "step_number": 1,
+  "total_steps": 3,
+  "next_step_required": true,
+  "model": "anthropic/claude-opus-4.6"
+}
+```
+
+## Planning Approach
+
+- Provide clear `step` description for each planning phase
+- Use `step_number` to track planning progress (starts at 1)
+- Set `total_steps` to estimated planning phases needed
+- Use `next_step_required` to indicate if more planning is needed
+- Document `findings` at each step covering task breakdown, dependencies, and strategy
+
+## Advanced Features
+
+### Step Revision
+
+Use to refine previous steps as understanding deepens:
+
+```json
+{
+  "is_step_revision": true,
+  "revises_step_number": 2
+}
+```
+
+### Branch Exploration
+
+Use to explore alternative approaches:
+
+```json
+{
+  "is_branch_point": true,
+  "branch_from_step": 1,
+  "branch_id": "approach-A"
+}
+```
+
+### Scope Adjustment
+
+```json
+{
+  "more_steps_needed": true
+}
+```
+
+## Relevant Files
+
+- Include full absolute paths to files or directories relevant to the planning scope
+- Include related files that inform architectural decisions
+- Include configuration files if planning system configuration changes
+- Include test files to understand testing requirements and strategies
+
+## Planning Process
+
+1. Start with `step_number: 1` and outline the planning strategy
+2. Progressively build the plan through multiple steps
+3. Document `findings` at each step covering task breakdown, dependencies, and implementation strategy
+4. Revise steps as needed using `is_step_revision` and `revises_step_number`
+5. Create branches for alternative approaches when exploring options
+6. Continue until comprehensive plan is achieved (`next_step_required: false`)
+
+## Critical Requirements
+
+- **MANDATORY**: Use Pal MCP planner tool **BEFORE INITIATING COMPLEX TASKS** or **WHEN NEEDING STRATEGIC PLANNING**
+- **TASK INVALIDATION**: Task will be invalidated if you skip using the planner tool when required or don't complete ALL steps
+- **NO EXCEPTIONS**: Complete the entire planning workflow (all steps until `next_step_required: false`) before proceeding with implementation
+- **COMPLETE ALL STEPS**: Never stop in the middle of steps - completing partial workflows invalidates the task
+- Use step revision capabilities to refine plans as understanding deepens
+- Use branching capabilities to explore alternative approaches when multiple viable options exist

package/vendor/skills/skills/pal/references/refactor.md

@@ -0,0 +1,88 @@
+# Pal Refactor Reference
+
+Expert guidance for using the Pal MCP refactor tool for code refactoring analysis.
+
+## When to Use
+
+- Refactoring existing code to improve quality
+- Addressing code smells and technical debt
+- Decomposing large modules or classes
+- Modernizing legacy patterns
+- Reorganizing code structure
+
+## Refactoring Scope
+
+The refactor tool must analyze:
+
+- **Code smells:** Duplication, long methods, complex conditionals, god objects, tight coupling
+- **Decomposition opportunities:** Extracting functions, splitting classes, modularizing components
+- **Modernization needs:** Updating patterns, adopting new language features, improving APIs
+- **Organization improvements:** File structure, module boundaries, dependency management
+
+## Required Parameters
+
+```json
+{
+  "step": "Analyze code for refactoring opportunities",
+  "step_number": 1,
+  "total_steps": 2,
+  "next_step_required": true,
+  "findings": "Initial analysis findings",
+  "model": "anthropic/claude-opus-4.6"
+}
+```
+
+## Refactoring Types
+
+Use `refactor_type` to specify focus:
+
+- `"codesmells"` - Identify and address code smells
+- `"decompose"` - Break down large modules/classes
+- `"modernize"` - Update to modern patterns
+- `"organization"` - Improve file/module structure
+
+## Focus Areas
+
+Specify `focus_areas` for specific concerns:
+
+```json
+{
+  "focus_areas": ["performance", "readability", "maintainability", "security"]
+}
+```
+
+## Style Guide Examples
+
+Include reference files for target patterns:
+
+```json
+{
+  "style_guide_examples": ["/absolute/path/to/reference-file.ts"]
+}
+```
+
+## Relevant Files
+
+- Include full absolute paths to files requiring refactoring
+- Include related files that might be affected by the refactoring
+- Include reference files that demonstrate target patterns or styles
+
+## Greenfield Approach
+
+This project is in alpha - prioritize quality over backwards compatibility:
+
+- Supporting old and new patterns introduces unnecessary complexity
+- Never sacrifice quality for backwards compatibility
+
+## Implementation Principles
+
+- **NEVER** use workarounds - always prefer good and well-designed solutions
+- **ALWAYS** follow the rules from `.cursor/rules` and double-check which rules apply before starting
+- **ALWAYS** check dependent file APIs before writing tests to avoid incorrect code
+
+## Critical Requirements
+
+- **MANDATORY**: Use Pal MCP refactor tool to find the best approach for refactoring
+- **TASK INVALIDATION**: Task will be invalidated if you skip using the refactor tool when required or don't complete ALL steps
+- **NO EXCEPTIONS**: Complete the entire refactor workflow (all steps until `next_step_required: false`) before proceeding with implementation
+- **COMPLETE ALL STEPS**: Never stop in the middle of steps - completing partial workflows invalidates the task

package/vendor/skills/skills/pal/references/review.md

@@ -0,0 +1,61 @@
+# Pal Code Review Reference
+
+Expert guidance for using the Pal MCP codereview tool for comprehensive code review.
+
+## When to Use
+
+- **AFTER FINISHING A TASK** - Mandatory code review before considering task complete
+- When reviewing code changes for quality and correctness
+- Before submitting pull requests
+- When validating implementation against project standards
+
+## Review Scope
+
+The review must cover:
+
+- **Project standards compliance:** Coding style, naming conventions, architecture patterns
+- **Potential issues:** Bugs, edge cases, error handling gaps, race conditions
+- **Performance improvements:** Inefficient algorithms, unnecessary re-renders, memory leaks, optimization opportunities
+- **Code smells:** Duplication, long methods, complex conditionals, god objects, tight coupling
+- **Security vulnerabilities:** Injection risks, authentication flaws, data exposure
+- **Maintainability concerns:** Hardcoded values, magic numbers, unclear abstractions, technical debt
+- **Type safety issues:** Unsafe type assertions, missing null checks, incorrect type usage
+- **Test coverage gaps:** Untested edge cases, missing error scenarios
+
+## Required Parameters
+
+```json
+{
+  "step": "Review implementation for quality and correctness",
+  "step_number": 1,
+  "total_steps": 2,
+  "next_step_required": true,
+  "findings": "Initial review findings",
+  "relevant_files": ["/absolute/path/to/file.ts"],
+  "model": "anthropic/claude-opus-4.6"
+}
+```
+
+## Review Configuration
+
+- Use `review_type: "full"` for comprehensive analysis
+- Use `severity_filter: "all"` to catch all severity levels
+- Specify `focus_on` areas if specific concerns exist (e.g., "performance", "security", "type-safety")
+- Include project standards in `standards` parameter when available
+
+## Relevant Files
+
+- Include full absolute paths to files that were changed or reviewed
+- Include related files that might be affected by the changes
+- Include test files to verify coverage
+
+## Report All Findings
+
+Present all issues found regardless of severity - don't filter out recommendations that seem unrelated to the immediate task.
+
+## Critical Requirements
+
+- **MANDATORY**: Use Pal MCP codereview tool **AFTER FINISH A TASK** to perform comprehensive code review
+- **TASK INVALIDATION**: Task will be invalidated if you skip using the codereview tool after finishing a task or don't complete ALL steps
+- **NO EXCEPTIONS**: Complete the entire codereview workflow (all steps until `next_step_required: false`) before considering the task complete
+- **COMPLETE ALL STEPS**: Never stop in the middle of steps - completing partial workflows invalidates the task

package/vendor/skills/skills/pal/references/tracer.md

@@ -0,0 +1,66 @@
+# Pal Tracer Reference
+
+Expert guidance for using the Pal MCP tracer tool for code execution flow and dependency analysis.
+
+## When to Use
+
+- **Before complex tasks:** Understand existing code structure and execution patterns
+- **Debugging:** Trace execution flow to identify where issues occur
+- **Refactoring:** Map dependencies before making architectural changes
+- **Code review:** Understand complex code paths before reviewing
+- **Onboarding:** Learn how a system works by tracing key flows
+
+## Tracing Scope
+
+The tracer must analyze:
+
+- **Execution flow:** Method call chains, control flow, data flow through functions
+- **Dependency relationships:** Imports, exports, module dependencies, class hierarchies
+- **Call patterns:** How functions are invoked, callback chains, event handlers
+- **Data transformations:** How data flows through the system, state changes
+- **Integration points:** API boundaries, service boundaries, external dependencies
+- **Architectural understanding:** Component relationships, system structure
+
+## Required Parameters
+
+```json
+{
+  "step": "Trace execution flow for feature X",
+  "step_number": 1,
+  "total_steps": 2,
+  "next_step_required": true,
+  "findings": "Initial trace findings",
+  "target_description": "Trace how user authentication flows from login endpoint to database",
+  "trace_mode": "precision",
+  "model": "anthropic/claude-opus-4.6"
+}
+```
+
+## Trace Mode Selection
+
+- `"precision"` - Execution flow analysis (method calls, control flow, runtime behavior)
+- `"dependencies"` - Structural analysis (imports, exports, static relationships, module structure)
+- `"ask"` - Let the tool determine the appropriate mode based on context
+
+## Target Description
+
+Provide clear, specific description of what to trace:
+
+- **Good:** "Trace how user authentication flows from login endpoint to database"
+- **Good:** "Map dependencies for the payment processing module"
+- **Bad:** "Trace the code" (too vague)
+
+Include context about why tracing is needed (debugging, understanding architecture, refactoring planning).
+
+## Relevant Files
+
+- Include full absolute paths to files involved in the trace
+- Start with entry points (main functions, API endpoints, component roots)
+- Include related files that might be part of the execution path or dependency graph
+
+## Critical Requirements
+
+- **MANDATORY**: Use Pal MCP tracer tool **BEFORE INITIATING A TASK** or **WHEN DEBUGGING COMPLEX FLOWS**
+- **TASK INVALIDATION**: Task will be invalidated if you skip using the tracer tool when required or don't complete ALL steps
+- **NO EXCEPTIONS**: Complete the entire tracer workflow (all steps until `next_step_required: false`) before proceeding with implementation
+- **COMPLETE ALL STEPS**: Never stop in the middle of steps - completing partial workflows invalidates the task