analysis

What it does

analysis provides systematic analytical operations for understanding code, skills, processes, data, and patterns. It helps extract insights, identify improvements, recognize patterns, and make data-driven decisions.

Purpose: Transform raw information into actionable insights through systematic analysis

The 5 Analysis Operations:

1. Code Analysis - Quality, complexity, patterns, technical debt
2. Skill Analysis - Effectiveness, usage patterns, improvement opportunities
3. Process Analysis - Efficiency, bottlenecks, optimization opportunities
4. Data Analysis - Metrics, trends, statistical insights
5. Pattern Recognition - Cross-artifact patterns, recurring themes, systemic insights

Key Benefits:

• Data-Driven Decisions: Base improvements on evidence, not assumptions
• Pattern Discovery: Identify recurring themes across multiple artifacts
• Quality Insights: Understand code/skill quality objectively
• Process Optimization: Find bottlenecks and inefficiencies
• Trend Identification: Spot improving/degrading patterns over time

How it works

Operation 1: Code Analysis

Purpose: Analyze code for quality, complexity, patterns, and technical debt Process:

1. Define Analysis Scope
   • Which code to analyze? (files, modules, entire codebase)
   • What aspects? (quality, complexity, patterns, debt)
   • What questions to answer?
2. Gather Code Metrics
   • Lines of code (LOC)
   • Function/class count
   • Cyclomatic complexity
   • Duplication levels
   • Comment density
3. Identify Patterns
   • Common code patterns used
   • Recurring structures
   • Naming conventions
   • Architecture patterns
   • Design patterns applied
4. Detect Code Smells
   • Long functions (>50 lines)
   • Deep nesting (>3 levels)
   • Duplicated code
   • Complex conditionals
   • Poor naming
5. Generate Insights
   • Overall quality assessment
   • Complexity hotspots
   • Refactoring priorities
   • Pattern recommendations
   • Technical debt inventory

Validation Checklist:

• [ ] Analysis scope clearly defined
• [ ] Key metrics collected
• [ ] Patterns identified (at least 2-3)
• [ ] Code smells detected (if any)
• [ ] Quality assessment completed
• [ ] Actionable insights generated
• [ ] Recommendations prioritized

Outputs:

• Code quality assessment
• Complexity metrics
• Identified patterns
• Code smells list
• Refactoring recommendations
• Technical debt inventory

Time Estimate: 30-90 minutes (varies by scope)

Example:

Code Analysis: Authentication Module
=====================================

Scope: auth/ directory (15 files, 3,200 LOC)

Metrics:
- Total LOC: 3,200
- Functions: 85
- Classes: 12
- Average function length: 25 lines (good)
- Cyclomatic complexity: Average 4.2 (acceptable)

Patterns Identified:
1. Decorator pattern for authentication checks (used 12x)
2. Strategy pattern for auth methods (OAuth, JWT, API key)
3. Factory pattern for token generation

Code Smells Detected:
❌ 3 functions >100 lines (validate_token, process_oauth, refresh_session)
❌ 2 files with >15% code duplication
⚠️ 5 functions with complexity >10
⚠️ Inconsistent error handling (some raise, some return None)

Quality Assessment: 7/10 (Good with improvements needed)

Recommendations:
1. [High] Refactor 3 long functions into smaller units
2. [High] Extract duplicated code to shared utilities
3. [Medium] Standardize error handling (use exceptions consistently)
4. [Low] Add docstrings to 8 functions missing them

Technical Debt Estimate: 8-12 hours to address all issues

Operation 2: Skill Analysis

Purpose: Analyze skill effectiveness, usage patterns, and identify improvement opportunities ...