@uniswap/ai-toolkit-nx-claude 0.5.29 → 0.5.30-next.1

package/dist/content/commands/agnostic/explain-file.md

@@ -1,303 +0,0 @@
----
-description: Comprehensive code explanation using multi-agent analysis for architecture, patterns, security, and performance insights.
-argument-hint: <path|glob> [--depth overview|deep|architectural] [--focus patterns|security|performance|all]
-allowed-tools: Read(*), Grep(*), Bash(git show:*), Bash(git ls-files:*), Task(subagent_type:code-explainer), Task(subagent_type:security-analyzer), Task(subagent_type:performance-analyzer), Task(subagent_type:context-loader)
----
-
-## Inputs
-
-Parse arguments from `$ARGUMENTS`:
-
-- **path**: File path, directory, or glob pattern (required)
-- **--depth**: Analysis depth (overview|deep|architectural) - default: overview
-- **--focus**: Specific aspects to emphasize (patterns|security|performance|all) - default: all
-- **--compare**: Compare with another file/version for diff analysis
-- **--context**: Include surrounding context analysis (default: true for deep/architectural)
-
-Examples:
-
-- `/explain-file src/auth/login.ts`
-- `/explain-file src/api/*.ts --depth deep --focus security`
-- `/explain-file src/core/ --depth architectural`
-- `/explain-file src/utils/validator.ts --compare src/utils/validator.old.ts`
-
-## Task
-
-Provide comprehensive code explanation through multi-agent analysis:
-
-1. **Code Structure Analysis**: Understand architecture and design patterns
-2. **Dependency Mapping**: Trace imports and external dependencies
-3. **Risk Assessment**: Identify potential issues and vulnerabilities
-4. **Performance Analysis**: Evaluate computational complexity
-5. **Pattern Recognition**: Identify design patterns and anti-patterns
-
-## Orchestration Strategy
-
-### Single File Analysis (Default)
-
-For simple file explanations, direct delegation:
-
-```typescript
-{
-  agent: "code-explainer",
-  params: {
-    path: parsedPath,
-    depth: depth,
-    focus: ["structure", "patterns", "risks"]
-  }
-}
-```
-
-### Deep Analysis (--depth deep)
-
-Coordinate multiple specialized agents:
-
-```typescript
-{
-  parallel: [
-    {
-      agent: 'code-explainer',
-      focus: 'architecture-and-patterns',
-    },
-    {
-      agent: 'security-analyzer',
-      focus: 'vulnerability-assessment',
-    },
-    {
-      agent: 'performance-analyzer',
-      focus: 'complexity-analysis',
-    },
-  ];
-}
-```
-
-### Architectural Analysis (--depth architectural)
-
-Full system context analysis:
-
-1. **Context Loading Phase**:
-
-   - Invoke **context-loader** to map surrounding architecture
-   - Identify integration points and dependencies
-   - Build system-level understanding
-
-2. **Multi-Agent Analysis**:
-   - **code-explainer**: Core functionality and patterns
-   - **security-analyzer**: Security boundaries and risks
-   - **performance-analyzer**: Scalability implications
-   - **refactorer**: Improvement opportunities
-
-## Output Format
-
-```typescript
-{
-  summary: {
-    purpose: string; // Primary responsibility
-    complexity: 'simple' | 'moderate' | 'complex' | 'highly-complex';
-    loc: number; // Lines of code
-    maintainability: number; // Score 0-100
-  };
-
-  architecture: {
-    patterns: Array<{
-      pattern: string; // e.g., "Singleton", "Factory", "Observer"
-      location: string; // Where in the code
-      implementation: string; // How it's implemented
-      quality: 'excellent' | 'good' | 'acceptable' | 'needs-improvement';
-    }>;
-    structure: {
-      layers: string[]; // Architectural layers detected
-      components: Array<{
-        name: string;
-        responsibility: string;
-        dependencies: string[];
-      }>;
-      coupling: 'loose' | 'moderate' | 'tight';
-    };
-  };
-
-  functionality: {
-    mainPurpose: string;
-    keyFeatures: string[];
-    dataFlow: Array<{
-      input: string;
-      processing: string;
-      output: string;
-    }>;
-    sideEffects: string[]; // External state changes
-    invariants: string[]; // Conditions that must always hold
-  };
-
-  dependencies: {
-    imports: Array<{
-      module: string;
-      type: 'external' | 'internal' | 'relative';
-      usage: string;
-      risk: 'low' | 'medium' | 'high';
-    }>;
-    exports: Array<{
-      name: string;
-      type: string;
-      consumers: string[]; // Who uses this export
-    }>;
-    circular: string[]; // Any circular dependencies detected
-  };
-
-  risks: {
-    security: Array<{
-      type: string; // e.g., "SQL Injection", "XSS"
-      severity: 'critical' | 'high' | 'medium' | 'low';
-      location: string;
-      mitigation: string;
-    }>;
-    performance: Array<{
-      issue: string; // e.g., "N+1 queries", "Memory leak"
-      impact: 'high' | 'medium' | 'low';
-      location: string;
-      suggestion: string;
-    }>;
-    maintainability: Array<{
-      issue: string; // e.g., "High complexity", "Code duplication"
-      metric: string; // Specific metric violated
-      suggestion: string;
-    }>;
-  };
-
-  improvements: {
-    immediate: string[]; // Quick wins
-    refactoring: Array<{
-      type: string; // e.g., "Extract method", "Introduce parameter object"
-      rationale: string;
-      effort: 'low' | 'medium' | 'high';
-      impact: 'low' | 'medium' | 'high';
-    }>;
-    architectural: string[]; // Larger structural improvements
-  };
-
-  testing: {
-    coverage: number; // Estimated test coverage
-    testability: 'high' | 'medium' | 'low';
-    suggestedTests: string[]; // Types of tests needed
-    mockingStrategy: string; // How to mock dependencies
-  };
-
-  documentation: {
-    inline: 'comprehensive' | 'adequate' | 'minimal' | 'missing';
-    publicApi: boolean; // Has public API documentation
-    examples: boolean; // Has usage examples
-    suggestions: string[]; // Documentation improvements
-  };
-}
-```
-
-## Specialized Analysis Modes
-
-### Pattern Focus
-
-When `--focus patterns`:
-
-- Emphasize design pattern identification
-- Analyze SOLID principle compliance
-- Identify anti-patterns and code smells
-- Suggest pattern-based refactoring
-
-### Security Focus
-
-When `--focus security`:
-
-- Deep vulnerability scanning
-- Input validation analysis
-- Authentication/authorization review
-- Dependency vulnerability check
-- Sensitive data handling
-
-### Performance Focus
-
-When `--focus performance`:
-
-- Algorithm complexity analysis (Big O)
-- Memory usage patterns
-- Database query optimization
-- Caching opportunities
-- Async/concurrent processing
-
-## Comparison Mode
-
-When `--compare` is specified:
-
-```typescript
-{
-  comparison: {
-    added: string[]; // New functionality
-    removed: string[]; // Deleted functionality
-    modified: Array<{
-      component: string;
-      before: string;
-      after: string;
-      impact: string;
-    }>;
-    improvements: string[]; // Positive changes
-    regressions: string[]; // Negative changes
-    riskDelta: 'increased' | 'decreased' | 'unchanged';
-  };
-}
-```
-
-## Examples
-
-### Basic File Explanation
-
-```bash
-/explain-file src/utils/validator.ts
-# Quick overview of the validator utility
-```
-
-### Deep Security Analysis
-
-```bash
-/explain-file src/api/auth.ts --depth deep --focus security
-# Comprehensive security analysis of authentication code
-```
-
-### Architectural Analysis
-
-```bash
-/explain-file src/core/ --depth architectural
-# Full architectural analysis of core module
-```
-
-### Comparison Analysis
-
-```bash
-/explain-file src/service.ts --compare main:src/service.ts
-# Compare current version with main branch
-```
-
-## Integration Points
-
-### IDE Integration
-
-- Hover explanations for complex code
-- Inline risk indicators
-- Architecture visualization
-
-### Documentation Generation
-
-- Auto-generate API documentation
-- Create architecture diagrams
-- Generate README sections
-
-### Code Review
-
-- Automated explanation for reviewers
-- Risk assessment for changes
-- Pattern compliance checking
-
-## Best Practices
-
-1. **Start Simple**: Use overview mode for quick understanding
-2. **Deep Dive Strategically**: Use deep analysis for critical code
-3. **Focus Areas**: Use focused analysis for specific concerns
-4. **Regular Analysis**: Run on changed files during review
-5. **Document Findings**: Save architectural analyses for onboarding
-6. **Track Improvements**: Monitor risk scores over time

package/dist/content/commands/agnostic/explore.md

@@ -1,82 +0,0 @@
----
-description: Deep dive into a codebase area to build comprehensive understanding before creating and implementing a plan.
-argument-hint: <natural language description of what you want to understand>
-allowed-tools: Bash(git ls-files:*), Bash(find:*), Fetch(*), Bash(git log:*), Bash(git show:*), Bash(npx nx graph:*)
----
-
-## Inputs
-
-Accept natural language description and intelligently extract:
-
-- `topic`: The main area/feature/component (inferred from the description)
-- `files`: Specific files mentioned (look for file paths with extensions)
-- `focus`: Specific aspects emphasized (e.g., "focusing on X", "especially Y", "particularly Z")
-
-Examples:
-
-- `/explore authentication system`
-- `/explore I want to understand the scrapers, especially error handling`
-- `/explore show me how the data pipeline works in src/pipeline.ts and src/transform.ts`
-- `/explore explain the Nx configuration focusing on package dependencies`
-
-## Task
-
-Build a comprehensive mental model of the specified codebase area:
-
-1. Map out the relevant files and directory structure
-2. Understand the architecture and design patterns
-3. Identify dependencies and integration points
-4. Note conventions, gotchas, and edge cases
-5. Prepare actionable context for implementation work
-
-## Delegation
-
-Invoke **context-loader** with:
-
-- `topic`: Inferred from the natural language description
-- `files`: Extracted file paths from the description (optional)
-- `focus`: Specific aspects mentioned in the description (optional)
-
-## Output
-
-Return the structured analysis from context-loader:
-
-- `summary`: Executive summary of the area
-- `key-components`: Core files and their responsibilities
-- `patterns`: Conventions and patterns to follow
-- `dependencies`: External dependencies and integrations
-- `data-flow`: How data moves through the system
-- `gotchas`: Non-obvious behaviors and pitfalls
-- `implementation-notes`: Key considerations for new work
-- `testing-approach`: How this area is tested
-
-## Workflow Integration (Optional)
-
-This command is **Step 1** of the implementation workflow:
-
-1. **Explore** → 2. Plan → 3. Review → 4. Execute
-
-### Next Steps
-
-After exploring an area, the context findings are automatically available for:
-
-- `/plan <task>` - Creates implementation plan using the explored context
-- The plan command will automatically leverage your exploration findings
-
-### Example Workflow
-
-```bash
-# Step 1: Explore and understand the area
-/explore authentication system
-
-# Step 2: Plan implementation with automatic context
-/plan add two-factor authentication
-
-# Step 3: Review the generated plan
-/review-plan auth-2fa-plan.md
-
-# Step 4: Execute the approved plan
-/execute-plan auth-2fa-plan.md
-```
-
-**Note for Claude Code**: Store the context-loader findings in memory for automatic use by the `/plan` command in the same session.

package/dist/content/commands/agnostic/fix-bug.md

@@ -1,273 +0,0 @@
----
-description: Comprehensively diagnose bugs with root cause analysis, systematic fixes, regression tests, and prevention strategies.
-argument-hint: <error text or pointer> [--run-tests] [--deep-analysis] [--generate-tests] [--prevention-mode]
-allowed-tools: Bash(npm test:*), Bash(pnpm test:*), Bash(npm test:*), Bash(yarn test:*), Bash(npm run lint*), Bash(pnpm lint*), Bash(npm lint*), Bash(yarn lint*)
----
-
-## Inputs
-
-- `$ARGUMENTS`: Error message, stack trace, failing test output, or bug description
-- `--run-tests`: Execute project test suites to capture live failure output
-- `--deep-analysis`: Perform comprehensive Five Whys analysis and system-level investigation
-- `--generate-tests`: Automatically create regression tests with edge case coverage
-- `--prevention-mode`: Focus on prevention strategies and system improvements
-
-## Phase 1: Enhanced Debugging & Analysis
-
-### Initial Diagnosis
-
-Use **debug-assistant** with enhanced capabilities to:
-
-1. **Error Pattern Recognition**:
-
-   - Classify error type (runtime, compilation, logic, integration, performance)
-   - Identify error patterns and common causes
-   - Check for known issue signatures in codebase
-   - Analyze error frequency and impact scope
-
-2. **Multi-File Context Analysis**:
-
-   - Trace error propagation across modules
-   - Identify all affected files and dependencies
-   - Map data flow through the error chain
-   - Check for cascading failures
-
-3. **Five Whys Root Cause Analysis**:
-   - Why did the error occur? (immediate cause)
-   - Why did the immediate cause happen? (contributing factors)
-   - Why did those factors exist? (system conditions)
-   - Why were those conditions present? (process gaps)
-   - Why weren't these gaps prevented? (root cause)
-
-### Deep System Analysis
-
-If `--deep-analysis` is provided:
-
-1. **Causal Chain Mapping**:
-
-   - Primary cause identification
-   - Secondary contributing factors
-   - Environmental conditions
-   - Timing dependencies
-   - Resource constraints
-
-2. **System-Level vs Code-Level Classification**:
-
-   - Code logic errors
-   - Architecture problems
-   - Configuration issues
-   - Infrastructure limitations
-   - Process failures
-
-3. **Impact Assessment**:
-   - Affected user scenarios
-   - Performance implications
-   - Security considerations
-   - Data integrity risks
-
-## Phase 2: Systematic Fix Implementation
-
-### Fix Strategy Development
-
-Based on root cause analysis, develop:
-
-1. **Immediate Fix Plan**:
-
-   - Minimal code changes required
-   - Risk assessment of each change
-   - Rollback strategy if needed
-   - Testing approach
-
-2. **Implementation Approach**:
-   - Use **refactorer** for minimal, surgical patches
-   - Prioritize backwards compatibility
-   - Implement defensive programming practices
-   - Add appropriate error handling
-
-### Code Quality Assurance
-
-- Ensure fix follows project coding standards
-- Verify no introduction of new vulnerabilities
-- Maintain existing API contracts
-- Optimize for maintainability
-
-## Phase 3: Comprehensive Test Generation
-
-### Regression Test Suite
-
-Use **test-writer** to create:
-
-1. **Core Regression Tests**:
-
-   - Test the exact scenario that failed
-   - Verify the fix resolves the issue
-   - Ensure no side effects introduced
-
-2. **Edge Case Coverage**:
-
-   - Boundary conditions that led to the bug
-   - Input validation scenarios
-   - Error state handling
-   - Resource exhaustion cases
-
-3. **Multi-Level Testing**:
-
-   - **Unit Tests**: Component-level validation
-   - **Integration Tests**: Cross-module interactions
-   - **End-to-End Tests**: Full user workflow validation
-   - **Performance Tests**: Resource usage verification
-
-4. **Test Coverage Metrics**:
-   - Measure code coverage improvement
-   - Identify untested paths
-   - Ensure critical paths are covered
-   - Track test execution performance
-
-## Phase 4: Prevention Strategy Implementation
-
-### Code-Level Improvements
-
-1. **Defensive Programming**:
-
-   - Input validation enhancements
-   - Error boundary implementations
-   - Graceful degradation patterns
-   - Resource cleanup procedures
-
-2. **Type Safety & Validation**:
-   - Strengthen type definitions
-   - Add runtime validation
-   - Implement schema validation
-   - Use assertion libraries
-
-### System-Level Enhancements
-
-1. **Monitoring & Observability**:
-
-   - Add logging for critical paths
-   - Implement health checks
-   - Create performance metrics
-   - Set up alerting thresholds
-
-2. **Configuration Management**:
-   - Externalize configuration
-   - Add configuration validation
-   - Implement feature flags
-   - Create environment-specific settings
-
-### Process Improvements
-
-1. **Code Review Guidelines**:
-
-   - Add specific review criteria
-   - Create bug pattern checklists
-   - Implement pair programming for critical code
-   - Establish security review requirements
-
-2. **Testing Strategy**:
-
-   - Enhance CI/CD pipeline
-   - Add pre-commit hooks
-   - Implement property-based testing
-   - Create mutation testing
-
-3. **Documentation Updates**:
-   - Update API documentation
-   - Create troubleshooting guides
-   - Document known limitations
-   - Add deployment procedures
-
-## Enhanced Output Structure
-
-### Comprehensive Report
-
-```json
-{
-  "errorAnalysis": {
-    "errorType": "string",
-    "errorPattern": "string",
-    "severity": "critical|high|medium|low",
-    "scope": "string[]"
-  },
-  "rootCauseAnalysis": {
-    "fiveWhys": {
-      "why1": "immediate cause",
-      "why2": "contributing factors",
-      "why3": "system conditions",
-      "why4": "process gaps",
-      "why5": "root cause"
-    },
-    "causalChain": "string[]",
-    "contributingFactors": "string[]",
-    "systemLevel": "boolean",
-    "codeLevel": "boolean"
-  },
-  "fixImplementation": {
-    "strategy": "string",
-    "patches": [
-      {
-        "file": "string",
-        "description": "string",
-        "changes": "string",
-        "riskLevel": "low|medium|high"
-      }
-    ],
-    "rollbackPlan": "string"
-  },
-  "regressionTests": {
-    "unitTests": "TestCase[]",
-    "integrationTests": "TestCase[]",
-    "e2eTests": "TestCase[]",
-    "coverageMetrics": {
-      "before": "number",
-      "after": "number",
-      "improvement": "number"
-    }
-  },
-  "preventionRecommendations": {
-    "codeLevel": {
-      "defensiveProgramming": "string[]",
-      "typeValidation": "string[]",
-      "errorHandling": "string[]"
-    },
-    "systemLevel": {
-      "monitoring": "string[]",
-      "configuration": "string[]",
-      "infrastructure": "string[]"
-    },
-    "processLevel": {
-      "codeReview": "string[]",
-      "testing": "string[]",
-      "documentation": "string[]",
-      "cicd": "string[]"
-    }
-  },
-  "implementationPlan": {
-    "immediate": "string[]",
-    "shortTerm": "string[]",
-    "longTerm": "string[]"
-  }
-}
-```
-
-## Agent Orchestration Strategy
-
-### Primary Agents
-
-1. **debug-assistant**: Enhanced with Five Whys methodology, pattern recognition, and multi-file analysis
-2. **refactorer**: Minimal, surgical code fixes with risk assessment
-3. **test-writer**: Comprehensive test suite generation with coverage analysis
-
-### Secondary Agents (as needed)
-
-1. **security-analyst**: For security-related bugs
-2. **performance-optimizer**: For performance issues
-3. **architect**: For system-level design problems
-4. **devops-engineer**: For infrastructure and deployment issues
-
-### Workflow Orchestration
-
-1. **Sequential Analysis**: Root cause → Fix → Test → Prevention
-2. **Parallel Processing**: Where appropriate for independent analysis
-3. **Iterative Refinement**: Based on test results and validation
-4. **Quality Gates**: Validation at each phase before proceeding