name: codebase_analysis_pipeline
version: "2.0"
type: analysis
description: "Comprehensive codebase analysis with multi-dimensional insights"

metadata:
  category: analysis
  sub_category: codebase
  estimated_duration: "5-30 minutes"
  resource_requirements:
    memory: "medium-high"
    compute: "medium"

inputs:
  codebase_path:
    type: string
    description: "Root path of codebase to analyze"
    required: true
    validation:
      pattern: "^[/\\w.-]+$"
  
  analysis_depth:
    type: string
    enum: ["shallow", "standard", "deep", "exhaustive"]
    default: "standard"
    description: "Depth of analysis to perform"
  
  focus_areas:
    type: array
    items:
      type: string
      enum: ["architecture", "patterns", "complexity", "dependencies", "quality", "documentation"]
    default: ["architecture", "patterns", "complexity"]
    description: "Specific areas to focus analysis on"

steps:
  - name: scan_codebase
    type: file_scan
    config:
      patterns:
        - "**/*.{ex,exs}"
        - "**/*.{js,jsx,ts,tsx}"
        - "**/*.{py,rb,go,java}"
        - "**/mix.exs"
        - "**/package.json"
        - "**/requirements.txt"
      ignore_patterns:
        - "**/node_modules/**"
        - "**/_build/**"
        - "**/deps/**"
        - "**/.git/**"
    outputs:
      - file_list

  - name: build_dependency_graph
    type: dependency_analysis
    inputs:
      files: "{{ file_list }}"
    config:
      analysis_type: "{{ analysis_depth }}"
      include_external: true
      resolve_versions: true
    outputs:
      - dependency_graph
      - external_dependencies
      - circular_dependencies

  - name: analyze_architecture
    type: llm_analysis
    when: "{{ 'architecture' in focus_areas }}"
    inputs:
      dependency_graph: "{{ dependency_graph }}"
      file_samples: "{{ file_list | sample(20) | read_files }}"
    prompt: |
      Analyze the software architecture of this codebase:
      
      Dependency structure:
      {{ dependency_graph | to_yaml }}
      
      Code samples:
      {{ file_samples }}
      
      Identify:
      1. Architectural patterns (MVC, hexagonal, layered, etc.)
      2. Core domain boundaries
      3. Integration points
      4. Coupling and cohesion analysis
      5. Architectural smells or anti-patterns
      
      Format as structured analysis with clear sections.
    outputs:
      - architecture_analysis

  - name: detect_patterns
    type: pattern_detection
    when: "{{ 'patterns' in focus_areas }}"
    inputs:
      files: "{{ file_list }}"
    config:
      patterns_to_detect:
        - design_patterns
        - anti_patterns
        - code_smells
        - security_patterns
    outputs:
      - detected_patterns
      - pattern_locations

  - name: measure_complexity
    type: complexity_analysis
    when: "{{ 'complexity' in focus_areas }}"
    inputs:
      files: "{{ file_list }}"
    config:
      metrics:
        - cyclomatic_complexity
        - cognitive_complexity
        - lines_of_code
        - nesting_depth
        - coupling_metrics
    outputs:
      - complexity_metrics
      - complexity_hotspots

  - name: generate_insights
    type: llm_synthesis
    inputs:
      architecture: "{{ architecture_analysis | default('N/A') }}"
      patterns: "{{ detected_patterns | default([]) }}"
      complexity: "{{ complexity_metrics | default({}) }}"
      dependencies: "{{ dependency_graph }}"
    prompt: |
      Synthesize the codebase analysis results into actionable insights:
      
      {{ inputs | to_yaml }}
      
      Generate:
      1. Executive summary (3-5 key findings)
      2. Health score (0-100) with justification
      3. Top 5 improvement recommendations
      4. Risk assessment
      5. Technical debt evaluation
      
      Be specific and actionable.
    outputs:
      - codebase_insights
      - health_score
      - recommendations

outputs:
  analysis_report:
    type: structured_report
    includes:
      - codebase_insights
      - health_score
      - recommendations
      - architecture_analysis
      - complexity_metrics
      - detected_patterns
  
  dependency_visualization:
    type: graph
    source: dependency_graph
    format: ["dot", "mermaid", "json"]
  
  actionable_items:
    type: task_list
    source: recommendations
    priority_ranked: true

name: security_audit_pipeline
version: "2.0"
type: analysis
description: "Comprehensive security vulnerability and compliance analysis"

metadata:
  category: analysis
  sub_category: security
  compliance_frameworks: ["OWASP", "CWE", "SANS"]
  severity_threshold: "medium"

inputs:
  target_path:
    type: string
    required: true
    description: "Path to audit"
  
  scan_types:
    type: array
    items:
      type: string
      enum: ["sast", "dependency", "secrets", "configuration", "compliance"]
    default: ["sast", "dependency", "secrets"]
  
  severity_filter:
    type: string
    enum: ["critical", "high", "medium", "low", "all"]
    default: "medium"

steps:
  - name: static_analysis
    type: sast_scan
    when: "{{ 'sast' in scan_types }}"
    config:
      scanners:
        - semgrep
        - bandit
        - eslint-security
      rules_sets:
        - owasp-top-10
        - cwe-top-25
        - custom-rules
    outputs:
      - sast_findings

  - name: dependency_scan
    type: dependency_vulnerability_scan
    when: "{{ 'dependency' in scan_types }}"
    config:
      databases:
        - nvd
        - github-advisory
        - snyk
      check_transitive: true
      license_check: true
    outputs:
      - vulnerable_dependencies
      - license_issues

  - name: secret_detection
    type: secret_scan
    when: "{{ 'secrets' in scan_types }}"
    config:
      patterns:
        - api_keys
        - passwords
        - tokens
        - certificates
      entropy_threshold: 4.5
    outputs:
      - detected_secrets

  - name: analyze_attack_surface
    type: llm_analysis
    inputs:
      sast: "{{ sast_findings | default([]) }}"
      deps: "{{ vulnerable_dependencies | default([]) }}"
      secrets: "{{ detected_secrets | default([]) }}"
    prompt: |
      Analyze the attack surface based on findings:
      
      Static Analysis: {{ sast | count }} findings
      Vulnerable Dependencies: {{ deps | count }} issues
      Exposed Secrets: {{ secrets | count }} detected
      
      Details:
      {{ inputs | to_yaml }}
      
      Provide:
      1. Attack surface assessment
      2. Exploitability analysis
      3. Risk prioritization matrix
      4. Remediation roadmap
      5. Security posture score (0-100)
    outputs:
      - attack_surface_analysis
      - security_score

  - name: generate_remediation_plan
    type: remediation_generator
    inputs:
      findings: "{{ steps | collect_findings }}"
      severity_filter: "{{ severity_filter }}"
    config:
      include_patches: true
      estimate_effort: true
      group_by: ["severity", "type", "component"]
    outputs:
      - remediation_plan
      - effort_estimates

outputs:
  security_report:
    type: security_report
    format: ["json", "html", "pdf"]
    includes:
      - executive_summary
      - findings_by_severity
      - attack_surface_analysis
      - remediation_plan
  
  compliance_status:
    type: compliance_matrix
    frameworks: "{{ metadata.compliance_frameworks }}"
    
  ci_integration:
    type: ci_friendly_output
    fail_on: "{{ severity_filter }}"

name: performance_analysis_pipeline
version: "2.0"
type: analysis
description: "Performance profiling and optimization recommendation"

metadata:
  category: analysis
  sub_category: performance
  profiling_tools: ["perf", "flamegraph", "telemetry"]

inputs:
  application_path:
    type: string
    required: true
  
  analysis_scenarios:
    type: array
    items:
      type: object
      properties:
        name: string
        load_profile: string
        duration: integer
    default:
      - name: "baseline"
        load_profile: "normal"
        duration: 300

steps:
  - name: static_performance_analysis
    type: code_analysis
    config:
      checks:
        - n_plus_one_queries
        - inefficient_algorithms
        - memory_leaks
        - blocking_operations
        - cache_opportunities
    outputs:
      - static_issues

  - name: setup_profiling
    type: profiling_setup
    config:
      tools: "{{ metadata.profiling_tools }}"
      sampling_rate: 1000
      include_memory: true
      include_io: true
    outputs:
      - profiling_config

  - name: run_performance_scenarios
    type: scenario_runner
    inputs:
      scenarios: "{{ analysis_scenarios }}"
      config: "{{ profiling_config }}"
    config:
      parallel: false
      warmup_duration: 60
      collect_metrics:
        - cpu_usage
        - memory_usage
        - io_operations
        - network_calls
        - database_queries
    outputs:
      - performance_data
      - flame_graphs
      - metrics_timeline

  - name: identify_bottlenecks
    type: bottleneck_analysis
    inputs:
      performance_data: "{{ performance_data }}"
      static_issues: "{{ static_issues }}"
    config:
      threshold_percentile: 95
      minimum_impact: 5
    outputs:
      - bottlenecks
      - hotspots

  - name: generate_optimizations
    type: llm_optimization
    inputs:
      bottlenecks: "{{ bottlenecks }}"
      flame_graphs: "{{ flame_graphs }}"
      code_context: "{{ bottlenecks | extract_code_context }}"
    prompt: |
      Analyze performance bottlenecks and suggest optimizations:
      
      Bottlenecks:
      {{ bottlenecks | to_yaml }}
      
      Code context:
      {{ code_context }}
      
      Generate:
      1. Root cause analysis for each bottleneck
      2. Specific optimization recommendations
      3. Implementation code examples
      4. Expected performance improvement
      5. Trade-offs and considerations
      
      Prioritize by impact and implementation effort.
    outputs:
      - optimization_recommendations
      - implementation_examples

outputs:
  performance_report:
    type: performance_report
    includes:
      - executive_summary
      - bottleneck_analysis
      - optimization_roadmap
      - before_after_comparisons
  
  optimization_patches:
    type: code_patches
    source: implementation_examples
    
  monitoring_config:
    type: monitoring_setup
    metrics: "{{ bottlenecks | to_monitoring_metrics }}"

name: dependency_analysis_pipeline
version: "2.0"
type: analysis
description: "Deep dependency analysis with security and compliance checks"

metadata:
  category: analysis
  sub_category: dependencies
  supported_ecosystems: ["npm", "hex", "pip", "gem", "cargo", "go"]

inputs:
  project_path:
    type: string
    required: true
  
  analysis_types:
    type: array
    items:
      type: string
      enum: ["security", "licenses", "updates", "usage", "graph"]
    default: ["security", "licenses", "updates"]
  
  include_transitive:
    type: boolean
    default: true

steps:
  - name: detect_package_managers
    type: ecosystem_detection
    inputs:
      path: "{{ project_path }}"
    outputs:
      - detected_ecosystems
      - manifest_files

  - name: build_dependency_tree
    type: dependency_resolver
    inputs:
      manifests: "{{ manifest_files }}"
      include_transitive: "{{ include_transitive }}"
    config:
      parallel_resolution: true
      include_dev_dependencies: true
      resolve_conflicts: true
    outputs:
      - dependency_tree
      - version_conflicts

  - name: security_analysis
    type: vulnerability_check
    when: "{{ 'security' in analysis_types }}"
    inputs:
      dependencies: "{{ dependency_tree }}"
    config:
      vulnerability_databases:
        - nvd
        - github_advisory
        - ecosystem_specific
      include_cvss_scores: true
      check_poc_exploits: true
    outputs:
      - vulnerabilities
      - risk_score

  - name: license_analysis
    type: license_check
    when: "{{ 'licenses' in analysis_types }}"
    inputs:
      dependencies: "{{ dependency_tree }}"
    config:
      approved_licenses:
        - MIT
        - Apache-2.0
        - BSD-3-Clause
      check_compatibility: true
      include_obligations: true
    outputs:
      - license_summary
      - compatibility_issues
      - obligations

  - name: update_analysis
    type: version_check
    when: "{{ 'updates' in analysis_types }}"
    inputs:
      dependencies: "{{ dependency_tree }}"
    config:
      update_strategy: "conservative"
      check_breaking_changes: true
      include_changelogs: true
    outputs:
      - available_updates
      - breaking_changes
      - update_recommendations

  - name: usage_analysis
    type: code_usage_scan
    when: "{{ 'usage' in analysis_types }}"
    inputs:
      dependencies: "{{ dependency_tree }}"
      codebase: "{{ project_path }}"
    config:
      track_imports: true
      identify_unused: true
      measure_coupling: true
    outputs:
      - usage_statistics
      - unused_dependencies
      - coupling_metrics

  - name: generate_insights
    type: llm_analysis
    inputs:
      tree: "{{ dependency_tree }}"
      vulnerabilities: "{{ vulnerabilities | default([]) }}"
      licenses: "{{ license_summary | default({}) }}"
      updates: "{{ available_updates | default([]) }}"
      usage: "{{ usage_statistics | default({}) }}"
    prompt: |
      Analyze the dependency landscape:
      
      Total dependencies: {{ tree | count_total }}
      Direct: {{ tree | count_direct }}
      Transitive: {{ tree | count_transitive }}
      
      Vulnerabilities: {{ vulnerabilities | count }}
      License issues: {{ licenses.issues | count }}
      Available updates: {{ updates | count }}
      
      Details:
      {{ inputs | to_yaml }}
      
      Generate:
      1. Dependency health score (0-100)
      2. Critical action items (security/legal risks)
      3. Optimization opportunities (remove unused, consolidate)
      4. Update strategy recommendation
      5. Long-term dependency management plan
    outputs:
      - dependency_insights
      - health_score
      - action_plan

outputs:
  dependency_report:
    type: comprehensive_report
    includes:
      - health_score
      - vulnerability_summary
      - license_compliance
      - update_roadmap
      - usage_insights
  
  dependency_graph:
    type: visualization
    format: ["svg", "interactive_html", "dot"]
    
  remediation_scripts:
    type: shell_scripts
    actions:
      - update_vulnerable
      - remove_unused
      - fix_licenses

component: ast_parser
type: analysis
description: "Parse code into Abstract Syntax Tree"

inputs:
  source_code: string
  language: string

config:
  parsers:
    elixir: "elixir_ast"
    javascript: "babel"
    python: "ast"
    ruby: "parser"

outputs:
  ast: object
  parse_errors: array

component: pattern_matcher
type: analysis
description: "Match patterns in code using AST or regex"

inputs:
  target: string | object  # code or AST
  patterns: array

config:
  pattern_types:
    - ast_patterns
    - regex_patterns
    - semantic_patterns

outputs:
  matches: array
  match_locations: array

component: vulnerability_scanner
type: security
description: "Scan for known vulnerabilities"

inputs:
  target_type: string  # "code" | "dependencies" | "configuration"
  target_data: any

config:
  databases:
    - nvd
    - cve
    - ecosystem_specific
  
  severity_scoring: "cvss_v3"

outputs:
  vulnerabilities: array
  severity_distribution: object

component: profiler
type: performance
description: "Profile code execution"

inputs:
  executable: string
  arguments: array
  scenario: object

config:
  profiling_types:
    - cpu
    - memory
    - io
    - network
  
  output_formats:
    - flamegraph
    - callgrind
    - json

outputs:
  profile_data: object
  visualizations: array

integration: ci_cd
triggers:
  - pull_request
  - pre_commit
  - scheduled

configuration:
  fail_conditions:
    security_severity: "high"
    performance_regression: 10
    complexity_increase: 20
  
  reporting:
    formats: ["junit", "github_annotations", "slack"]

integration: ide
supported:
  - vscode
  - intellij
  - neovim

features:
  - real_time_analysis
  - inline_suggestions
  - refactoring_actions

test_scenarios:
  - name: "Small Elixir project"
    fixture: "test/fixtures/small_elixir"
    expected_findings: 5-10
    max_duration: 60s
    
  - name: "Large JavaScript monorepo"
    fixture: "test/fixtures/large_js"
    expected_findings: 50-100
    max_duration: 600s