@dragonflymcp/plugin 1.0.0

package/templates/skills/code-coverage-analysis.md.template

@@ -0,0 +1,362 @@
+---
+name: Code Coverage Analysis
+description: Intelligent coverage analysis with gap identification and prioritized test recommendations
+version: 1.0.0
+author: Zen Framework
+applies_to:
+  - quality-concept
+trigger_keywords:
+  - coverage
+  - test coverage
+  - untested
+  - coverage gap
+  - coverage report
+priority: P2
+impact: high
+---
+
+# Code Coverage Analysis Skill
+
+## Purpose
+
+Enable the Quality Concept agent to analyze code coverage reports, identify critical gaps, and recommend prioritized testing strategies.
+
+## Coverage Metrics Framework
+
+### 1. Coverage Types
+
+```yaml
+coverage_types:
+  line_coverage:
+    description: "Percentage of lines executed"
+    calculation: "executed_lines / total_lines * 100"
+    minimum_threshold: 80%
+    ideal_threshold: 90%
+    
+  branch_coverage:
+    description: "Percentage of decision branches taken"
+    calculation: "taken_branches / total_branches * 100"
+    minimum_threshold: 75%
+    ideal_threshold: 85%
+    
+  function_coverage:
+    description: "Percentage of functions called"
+    calculation: "called_functions / total_functions * 100"
+    minimum_threshold: 90%
+    ideal_threshold: 95%
+    
+  statement_coverage:
+    description: "Percentage of statements executed"
+    calculation: "executed_statements / total_statements * 100"
+    minimum_threshold: 80%
+    ideal_threshold: 90%
+    
+  condition_coverage:
+    description: "Each boolean sub-expression evaluated both ways"
+    calculation: "conditions_evaluated_both_ways / total_conditions * 100"
+    minimum_threshold: 70%
+    ideal_threshold: 80%
+    
+  path_coverage:
+    description: "Percentage of possible execution paths"
+    calculation: "exercised_paths / total_paths * 100"
+    note: "Often impractical for complex code"
+```
+
+### 2. Coverage Analysis Matrix
+
+```yaml
+analysis_matrix:
+  by_component_type:
+    api_endpoints:
+      priority: "critical"
+      minimum: 90%
+      focus: "branch + error paths"
+      
+    business_logic:
+      priority: "critical"
+      minimum: 85%
+      focus: "branch + edge cases"
+      
+    data_access:
+      priority: "high"
+      minimum: 80%
+      focus: "query variations + error handling"
+      
+    utilities:
+      priority: "medium"
+      minimum: 75%
+      focus: "line coverage sufficient"
+      
+    ui_components:
+      priority: "medium"
+      minimum: 70%
+      focus: "interaction + state changes"
+      
+    configuration:
+      priority: "low"
+      minimum: 60%
+      focus: "validation paths"
+```
+
+### 3. Gap Detection Algorithm
+
+```python
+def analyze_coverage_gaps(coverage_report, source_files):
+    """
+    Identify and prioritize coverage gaps.
+    """
+    gaps = []
+    
+    for file in coverage_report.files:
+        # Get uncovered lines
+        uncovered = file.uncovered_lines
+        
+        # Classify each gap
+        for line_range in group_consecutive(uncovered):
+            gap = {
+                'file': file.path,
+                'lines': line_range,
+                'type': classify_code_type(file, line_range),
+                'complexity': calculate_complexity(file, line_range),
+                'risk': assess_risk(file, line_range),
+                'priority': calculate_priority(file, line_range),
+            }
+            gaps.append(gap)
+    
+    return sorted(gaps, key=lambda g: g['priority'], reverse=True)
+
+def classify_code_type(file, lines):
+    """Classify what kind of code is uncovered."""
+    code = extract_lines(file, lines)
+    
+    if contains_error_handling(code):
+        return 'error_handling'
+    elif contains_validation(code):
+        return 'validation'
+    elif contains_conditional(code):
+        return 'conditional_logic'
+    elif contains_loop(code):
+        return 'iteration'
+    elif contains_external_call(code):
+        return 'external_integration'
+    else:
+        return 'general'
+```
+
+### 4. Risk Assessment
+
+```yaml
+risk_factors:
+  high_risk:
+    indicators:
+      - error_handling_code: "Untested error paths"
+      - authentication_logic: "Security-critical code"
+      - payment_processing: "Financial transactions"
+      - data_validation: "Input sanitization"
+      - concurrency_code: "Race conditions possible"
+    weight: 3.0
+    
+  medium_risk:
+    indicators:
+      - business_rules: "Core domain logic"
+      - state_transitions: "Complex state management"
+      - external_api_calls: "Integration points"
+      - data_transformations: "Data mapping/conversion"
+    weight: 2.0
+    
+  low_risk:
+    indicators:
+      - logging_statements: "Observability code"
+      - simple_getters: "Accessor methods"
+      - configuration_loading: "Setup code"
+      - debug_code: "Development aids"
+    weight: 1.0
+
+complexity_multiplier:
+  cyclomatic_1_5: 1.0
+  cyclomatic_6_10: 1.5
+  cyclomatic_11_20: 2.0
+  cyclomatic_21_plus: 3.0
+```
+
+### 5. Coverage Report Template
+
+```yaml
+coverage_report:
+  summary:
+    total_lines: 10000
+    covered_lines: 8500
+    line_coverage: 85.0%
+    
+    total_branches: 2000
+    covered_branches: 1600
+    branch_coverage: 80.0%
+    
+    total_functions: 500
+    covered_functions: 475
+    function_coverage: 95.0%
+    
+  by_directory:
+    src/api:
+      lines: 92%
+      branches: 88%
+      status: "✅ Meets threshold"
+      
+    src/services:
+      lines: 78%
+      branches: 72%
+      status: "⚠️ Below threshold"
+      
+    src/utils:
+      lines: 95%
+      branches: 90%
+      status: "✅ Excellent"
+
+  critical_gaps:
+    - file: "src/services/PaymentService.ts"
+      uncovered_lines: [45-67, 89-95]
+      risk: "high"
+      reason: "Error handling in payment processing"
+      recommended_tests:
+        - "Test payment timeout scenario"
+        - "Test invalid card response"
+        - "Test network failure recovery"
+        
+  test_recommendations:
+    immediate:
+      - gap: "PaymentService error handling"
+        effort: "2 hours"
+        impact: "+5% coverage, -1 critical gap"
+        
+    short_term:
+      - gap: "UserService validation"
+        effort: "4 hours"
+        impact: "+3% coverage"
+```
+
+### 6. Branch Coverage Deep Dive
+
+```yaml
+branch_analysis:
+  uncovered_branches:
+    - location: "src/auth/login.ts:45"
+      type: "if-else"
+      covered: "true branch"
+      missing: "false branch"
+      condition: "user.isVerified"
+      test_needed: "Test with unverified user"
+      
+    - location: "src/orders/validate.ts:78"
+      type: "switch"
+      covered: ["PENDING", "CONFIRMED"]
+      missing: ["CANCELLED", "default"]
+      test_needed: "Test cancelled order and unknown status"
+      
+    - location: "src/utils/retry.ts:23"
+      type: "try-catch"
+      covered: "try block"
+      missing: "catch block"
+      test_needed: "Test with failing operation"
+```
+
+### 7. Coverage Trend Analysis
+
+```yaml
+trend_analysis:
+  time_period: "last 30 days"
+  
+  metrics:
+    line_coverage:
+      current: 85.0%
+      previous: 82.0%
+      trend: "+3.0%"
+      status: "improving"
+      
+    branch_coverage:
+      current: 80.0%
+      previous: 81.5%
+      trend: "-1.5%"
+      status: "declining"
+      alert: "Branch coverage decreased"
+      
+  new_code_coverage:
+    period: "this sprint"
+    lines_added: 500
+    lines_covered: 450
+    coverage: 90.0%
+    status: "✅ New code well tested"
+    
+  regressions:
+    - file: "src/services/OrderService.ts"
+      previous: 88%
+      current: 75%
+      cause: "Refactoring without test updates"
+```
+
+### 8. Actionable Recommendations
+
+```yaml
+recommendations:
+  priority_1_critical:
+    description: "Address immediately"
+    items:
+      - file: "PaymentService.ts"
+        action: "Add error handling tests"
+        estimated_time: "2h"
+        coverage_gain: "+5%"
+        
+  priority_2_high:
+    description: "Address this sprint"
+    items:
+      - file: "AuthService.ts"
+        action: "Test edge cases for token refresh"
+        estimated_time: "3h"
+        coverage_gain: "+3%"
+        
+  priority_3_medium:
+    description: "Address when touching code"
+    items:
+      - file: "StringUtils.ts"
+        action: "Add boundary tests"
+        estimated_time: "1h"
+        coverage_gain: "+1%"
+
+test_generation_hints:
+  PaymentService:
+    - scenario: "Network timeout during payment"
+      mock: "HTTP client throws timeout"
+      assert: "Transaction rolled back"
+      
+    - scenario: "Card declined by processor"
+      mock: "Payment API returns declined"
+      assert: "User notified, no charge"
+```
+
+## Integration Commands
+
+```yaml
+coverage_commands:
+  generate_report:
+    jest: "jest --coverage --coverageReporters=json"
+    nyc: "nyc --reporter=json report"
+    
+  analyze_gaps:
+    command: "zen coverage analyze"
+    output: "coverage-gaps.json"
+    
+  check_threshold:
+    command: "zen coverage check --threshold 80"
+    ci_integration: true
+    fail_on_decrease: true
+```
+
+## Output Format
+
+When analyzing coverage, produce:
+
+1. **Summary metrics** with trend indicators
+2. **Critical gaps** sorted by risk and impact
+3. **Specific test recommendations** with effort estimates
+4. **Branch analysis** for complex conditionals
+5. **Coverage improvement roadmap** with priorities

package/templates/skills/code-style-enforcement.md.template

@@ -0,0 +1,294 @@
+---
+name: Code Style Enforcement
+description: Ensure consistent code style with project-aware formatting and linting
+version: 1.0.0
+author: Zen Framework
+applies_to:
+  - implementation-concept
+trigger_keywords:
+  - style
+  - formatting
+  - lint
+  - code style
+  - consistent
+  - prettier
+  - eslint
+priority: P3
+impact: medium
+---
+
+# Code Style Enforcement Skill
+
+## Purpose
+
+Enable the Implementation Concept agent to generate code that matches project conventions and passes all linting/formatting checks.
+
+## Style Detection Framework
+
+### 1. Project Convention Detection
+
+```yaml
+detection_sources:
+  configuration_files:
+    eslint:
+      files: [".eslintrc", ".eslintrc.js", ".eslintrc.json", "eslint.config.js"]
+      priority: 1
+      
+    prettier:
+      files: [".prettierrc", ".prettierrc.js", "prettier.config.js"]
+      priority: 1
+      
+    typescript:
+      files: ["tsconfig.json"]
+      priority: 1
+      
+    editorconfig:
+      files: [".editorconfig"]
+      priority: 2
+      
+  existing_code:
+    method: "Pattern analysis of existing files"
+    sample_size: "10-20 files"
+    priority: 3
+```
+
+### 2. Common Style Rules
+
+```yaml
+style_dimensions:
+  indentation:
+    options: ["2 spaces", "4 spaces", "tabs"]
+    detect_from: [".editorconfig", "prettier", "existing code"]
+    
+  quotes:
+    options: ["single", "double"]
+    detect_from: ["eslint", "prettier", "existing code"]
+    
+  semicolons:
+    options: [true, false]
+    detect_from: ["eslint", "prettier", "existing code"]
+    
+  trailing_commas:
+    options: ["none", "es5", "all"]
+    detect_from: ["prettier", "existing code"]
+    
+  line_length:
+    common_values: [80, 100, 120]
+    detect_from: ["prettier", "eslint", ".editorconfig"]
+    
+  bracket_spacing:
+    options: [true, false]
+    example_true: "{ foo: bar }"
+    example_false: "{foo: bar}"
+    
+  arrow_function_parens:
+    options: ["always", "avoid"]
+    example_always: "(x) => x"
+    example_avoid: "x => x"
+```
+
+### 3. Language-Specific Conventions
+
+```yaml
+typescript_conventions:
+  type_annotations:
+    explicit_return_types: "Required for exported functions"
+    parameter_types: "Always required"
+    inference: "Allow for local variables"
+    
+  naming:
+    interfaces: "PascalCase, no 'I' prefix"
+    types: "PascalCase"
+    enums: "PascalCase"
+    enum_members: "SCREAMING_SNAKE_CASE or PascalCase"
+    
+  imports:
+    order: ["builtin", "external", "internal", "parent", "sibling", "index"]
+    group_separation: "blank line between groups"
+    type_imports: "Use 'import type' when possible"
+    
+  null_handling:
+    prefer: "undefined over null"
+    optional_chaining: "Use ?. instead of && chains"
+    nullish_coalescing: "Use ?? instead of || for defaults"
+
+javascript_conventions:
+  variable_declaration:
+    prefer: "const over let"
+    avoid: "var"
+    
+  functions:
+    prefer: "arrow functions for callbacks"
+    named: "function declarations for hoisting"
+    
+  objects:
+    shorthand: "Use property shorthand"
+    computed: "Use computed properties when needed"
+    spread: "Prefer spread over Object.assign"
+```
+
+### 4. Code Organization Patterns
+
+```yaml
+file_organization:
+  imports_order:
+    1: "React/framework imports"
+    2: "Third-party libraries"
+    3: "Internal absolute imports"
+    4: "Relative imports"
+    5: "Style imports"
+    6: "Type imports"
+    
+  component_structure:
+    1: "Type definitions"
+    2: "Constants"
+    3: "Helpers (if small)"
+    4: "Component definition"
+    5: "Styled components (if colocated)"
+    
+  class_structure:
+    1: "Static properties"
+    2: "Instance properties"
+    3: "Constructor"
+    4: "Lifecycle methods"
+    5: "Public methods"
+    6: "Private methods"
+    
+  function_structure:
+    1: "Parameter validation"
+    2: "Early returns"
+    3: "Main logic"
+    4: "Return statement"
+```
+
+### 5. Documentation Style
+
+```yaml
+documentation_conventions:
+  jsdoc:
+    when_required:
+      - exported_functions
+      - public_class_methods
+      - complex_logic
+    format: |
+      /**
+       * Brief description.
+       * 
+       * @param paramName - Parameter description
+       * @returns Description of return value
+       * @throws {ErrorType} When error occurs
+       * @example
+       * ```ts
+       * functionName(arg);
+       * ```
+       */
+       
+  inline_comments:
+    when_needed:
+      - non_obvious_logic
+      - workarounds
+      - todo_items
+    format:
+      single_line: "// Comment"
+      todo: "// TODO: Description"
+      fixme: "// FIXME: Description"
+      
+  tsdoc:
+    prefer_over_jsdoc: true
+    tags: ["@param", "@returns", "@throws", "@example", "@remarks"]
+```
+
+### 6. Naming Conventions
+
+```yaml
+naming_rules:
+  variables:
+    style: "camelCase"
+    boolean_prefix: ["is", "has", "should", "can", "will"]
+    array_suffix: "Avoid 'List', prefer plural"
+    
+  functions:
+    style: "camelCase"
+    verb_prefix: ["get", "set", "create", "update", "delete", "fetch", "handle"]
+    event_handlers: "handle{Event}" or "on{Event}"
+    
+  classes:
+    style: "PascalCase"
+    suffix_by_type:
+      services: "Service"
+      controllers: "Controller"
+      repositories: "Repository"
+      factories: "Factory"
+      
+  constants:
+    exported: "SCREAMING_SNAKE_CASE"
+    local: "camelCase"
+    
+  files:
+    components: "PascalCase.tsx"
+    utilities: "camelCase.ts"
+    tests: "{name}.test.ts or {name}.spec.ts"
+    styles: "{ComponentName}.styles.ts or {component}.module.css"
+```
+
+### 7. Style Enforcement Checklist
+
+```yaml
+pre_generation_checklist:
+  - detect_project_style: "Analyze existing code and configs"
+  - identify_linter_rules: "Parse ESLint/Prettier config"
+  - note_naming_patterns: "Observe existing names"
+  - check_import_style: "Absolute vs relative preferences"
+  
+post_generation_validation:
+  - consistent_indentation: "Match project standard"
+  - correct_quotes: "Match quote style"
+  - proper_semicolons: "Match semicolon style"
+  - sorted_imports: "Match import order"
+  - naming_conventions: "Match existing patterns"
+  - documentation_format: "Match JSDoc style"
+```
+
+### 8. Auto-Fix Integration
+
+```yaml
+auto_fix_tools:
+  prettier:
+    command: "npx prettier --write {file}"
+    formats: ["ts", "tsx", "js", "jsx", "json", "md", "css"]
+    
+  eslint:
+    command: "npx eslint --fix {file}"
+    fixes: "Auto-fixable rule violations"
+    
+  import_sort:
+    command: "npx eslint --fix --rule 'import/order: error'"
+    alternatives: ["eslint-plugin-import", "prettier-plugin-organize-imports"]
+```
+
+## Output Format
+
+When generating code, apply detected styles:
+
+```yaml
+style_report:
+  detected_conventions:
+    indentation: "2 spaces"
+    quotes: "single"
+    semicolons: false
+    trailing_commas: "es5"
+    line_length: 100
+    
+  applied_patterns:
+    naming:
+      functions: "camelCase"
+      components: "PascalCase"
+    imports:
+      order: "framework → external → internal"
+      type_imports: "separate"
+      
+  validation:
+    eslint_passed: true
+    prettier_formatted: true
+    type_check_passed: true
+```