@peakinfer/cli 1.0.133

package/src/version.ts

@@ -0,0 +1,24 @@
+/**
+ * Single source of truth for version
+ * Auto-bumped on each build via npm version patch
+ */
+
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+// Read version from package.json at runtime
+function getPackageVersion(): string {
+  try {
+    // Handle both development (src/) and production (dist/) paths
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const packagePath = join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
+    return pkg.version || '1.0.0';
+  } catch {
+    return '1.0.0';
+  }
+}
+
+export const VERSION = getPackageVersion();
+export const VERSION_DISPLAY = `PeakInfer v${VERSION}`;

package/templates/context-accumulation.yaml

@@ -0,0 +1,23 @@
+# Based on: https://www.kalmantic.com/posts/conversation-history-costs-context-windows-drain-budgets
+# "Why Context Windows Drain AI Budgets 10x Faster"
+
+id: context-accumulation
+name: Context Window Bloat Detection
+version: "1.0"
+category: cost
+severity: warning
+layer: model
+
+match:
+  scope: callsite
+  conditions:
+    - field: usage.tokens_in
+      op: gt
+      value: 50000
+
+output:
+  headline: "High context usage at {{location}}"
+  evidence: "Averaging {{avg_tokens_in}} input tokens per call. Consider sliding window or summarization."
+
+defaults:
+  high_context_threshold: 50000

package/templates/cost-concentration.yaml

@@ -0,0 +1,20 @@
+id: cost-concentration
+name: Cost Concentration
+version: "1.0"
+category: cost
+severity: warning
+layer: application
+
+match:
+  scope: global
+  conditions:
+    - field: top_callsite_cost_percent
+      op: gt
+      value: 50
+
+output:
+  headline: "{{percent}}% of inference cost from one callsite"
+  evidence: "{{model}} at {{location}}"
+
+defaults:
+  threshold_percent: 50

package/templates/dead-code.yaml

@@ -0,0 +1,20 @@
+id: dead-code
+name: Dead Code Detection
+version: "1.0"
+category: drift
+severity: warning
+layer: application
+
+match:
+  scope: joined
+  conditions:
+    - field: codeOnly.length
+      op: gt
+      value: 0
+
+output:
+  headline: "{{count}} callsites in code with no runtime events"
+  evidence: "{{locations}}"
+
+defaults:
+  min_count: 1

package/templates/latency-explainer.yaml

@@ -0,0 +1,23 @@
+id: latency-explainer
+name: Latency Explainer
+version: "1.0"
+category: latency
+severity: warning
+layer: application
+
+match:
+  scope: callsite
+  conditions:
+    - field: usage.latency_p95
+      op: gt
+      value: 3000
+    - field: patterns.streaming
+      op: neq
+      value: true
+
+output:
+  headline: "High tail latency: {{p95}}ms at p95"
+  evidence: "No streaming enabled; full response wait contributes to latency"
+
+defaults:
+  latency_threshold_ms: 3000

package/templates/optimizations/ab-testing-framework.yaml

@@ -0,0 +1,74 @@
+id: ab-testing-framework
+name: A/B Testing for Optimization Validation
+description: Implement A/B testing framework to validate optimization effectiveness
+category: monitoring
+confidence: 0.91
+success_count: 1234
+verified_environments: 61
+contributors:
+  - experimentation_engineer
+  - data_scientist
+last_updated: "2024-12-22"
+
+environment_match:
+  traffic_volume: ">10K/day"
+  optimization_candidates: ">1"
+  statistical_rigor_requirement: high
+
+optimization:
+  technique: ab_testing_framework
+  expected_cost_reduction: "5-15%"
+  effort_estimate: "2-3 weeks"
+  risk_level: low
+
+economics:
+  baseline_calculation:
+    failed_optimization_cost: 20000
+  projected_improvement:
+    optimization_success_rate: 0.85
+  implementation_cost:
+    engineering_hours: 100
+    total_cost: 20000
+
+implementation:
+  prerequisites:
+    - requirement: "Traffic splitting capability"
+    - requirement: "Statistical analysis tools"
+  automated_steps:
+    - step_id: framework_setup
+      name: A/B Framework Setup
+      executable: true
+      commands:
+        - "python scripts/setup_ab_framework.py"
+        - "python scripts/configure_traffic_splitting.py"
+      validation:
+        command: "python scripts/verify_framework.py"
+        success_criteria: "framework_functional"
+    - step_id: analysis
+      name: Statistical Analysis
+      executable: true
+      commands:
+        - "python scripts/configure_metrics.py --primary cost,latency,quality"
+        - "python scripts/setup_significance_testing.py --confidence 0.95"
+      validation:
+        command: "python scripts/test_analysis.py"
+        success_criteria: "analysis_accurate"
+
+monitoring:
+  key_metrics:
+    - metric: experiment_validity
+      target: ">0.95"
+      alert_threshold: "<0.8"
+    - metric: sample_ratio_mismatch
+      target: "<0.01"
+      alert_threshold: ">0.05"
+  rollback_triggers:
+    - condition: "sample_ratio_mismatch > 0.1"
+      action: pause_experiment
+
+results:
+  recent_implementations:
+    - environment: optimization_validation
+      experiments_run: 15
+      successful_optimizations: 12
+      prevented_regressions: 3

package/templates/optimizations/api-gateway-optimization.yaml

@@ -0,0 +1,81 @@
+id: api-gateway-optimization
+name: API Gateway Traffic Optimization
+description: Optimize API gateway for AI inference traffic patterns
+category: application_optimization
+confidence: 0.90
+success_count: 1234
+verified_environments: 58
+contributors:
+  - gateway_specialist
+  - traffic_engineer
+last_updated: "2024-12-25"
+
+environment_match:
+  gateway_type:
+    - kong
+    - nginx
+    - envoy
+  daily_requests: ">100K"
+  inference_traffic_percent: ">50%"
+
+optimization:
+  technique: gateway_optimization
+  expected_latency_improvement: "20-40%"
+  expected_cost_reduction: "15-25%"
+  effort_estimate: "1-2 weeks"
+  risk_level: low
+
+economics:
+  baseline_calculation:
+    gateway_overhead_ms: 50
+  projected_improvement:
+    optimized_overhead_ms: 20
+    latency_reduction_percent: 60
+  implementation_cost:
+    engineering_hours: 60
+    total_cost: 12000
+
+implementation:
+  prerequisites:
+    - requirement: "Gateway configuration access"
+    - requirement: "Traffic analytics"
+  automated_steps:
+    - step_id: traffic_analysis
+      name: Traffic Pattern Analysis
+      executable: true
+      commands:
+        - "python scripts/analyze_gateway_traffic.py"
+        - "python scripts/identify_optimization_opportunities.py"
+      validation:
+        command: "python scripts/validate_analysis.py"
+        success_criteria: "patterns_identified"
+    - step_id: optimization
+      name: Gateway Optimization
+      executable: true
+      commands:
+        - "python scripts/configure_connection_pooling.py"
+        - "python scripts/enable_request_coalescing.py"
+        - "python scripts/optimize_routing.py"
+      validation:
+        command: "python scripts/benchmark_gateway.py"
+        success_criteria: "latency_reduction > 0.2"
+        rollback_command: "python scripts/revert_gateway_config.py"
+
+monitoring:
+  key_metrics:
+    - metric: gateway_latency_p95
+      target: "<30ms"
+      alert_threshold: ">50ms"
+    - metric: connection_pool_utilization
+      target: "60-80%"
+      alert_threshold: ">95%"
+  rollback_triggers:
+    - condition: "error_rate > 1% for 5 minutes"
+      action: automatic_rollback
+
+results:
+  recent_implementations:
+    - environment: ai_api_gateway
+      baseline_latency_ms: 55
+      optimized_latency_ms: 22
+      latency_reduction_percent: 60

package/templates/optimizations/api-model-routing-strategy.yaml

@@ -0,0 +1,126 @@
+id: api-model-routing-strategy
+name: Multi-Provider Model Routing for Cost-Quality Optimization
+description: Route API requests to appropriate model tiers based on task complexity, achieving 60-80% cost reduction
+category: api_optimization
+confidence: 0.93
+success_count: 2341
+verified_environments: 112
+contributors:
+  - inference_squeeze
+  - api_optimizer
+  - cost_engineer
+last_updated: "2025-01-20"
+source: "Inference Squeeze Chapter 4 - Smart Model Routing"
+
+environment_match:
+  api_usage: multi_provider
+  monthly_api_cost: ">$5K"
+  task_complexity: variable
+  quality_tolerance: task_dependent
+
+optimization:
+  technique: tiered_model_routing
+  expected_cost_reduction: "60-80%"
+  expected_quality_impact: "<2%"
+  effort_estimate: "1-2 weeks"
+  risk_level: low
+
+economics:
+  baseline_calculation:
+    monthly_api_calls: 500000
+    premium_model_cost_per_call: 0.03
+    current_monthly_cost: 15000
+  projected_improvement:
+    task_distribution:
+      extraction: 0.40
+      qa: 0.35
+      generation: 0.25
+    tier_costs:
+      extraction: 0.003
+      qa: 0.01
+      generation: 0.03
+    new_avg_cost: 0.0117
+    monthly_savings: 9150
+  implementation_cost:
+    engineering_hours: 80
+    total_cost: 16000
+
+implementation:
+  prerequisites:
+    - requirement: "Task classification capability"
+      validation: "Ability to categorize requests by complexity"
+    - requirement: "Multi-provider API access"
+      validation: "API keys for OpenAI, Anthropic, or alternatives"
+  automated_steps:
+    - step_id: task_analysis
+      name: Analyze Task Distribution
+      executable: true
+      commands:
+        - "Audit last 30 days of API calls by task type"
+        - "Categorize: extraction, QA, summarization, generation, reasoning"
+        - "Measure quality requirements per task type"
+      validation:
+        command: "Task distribution documented with quality thresholds"
+        success_criteria: "task_types_identified AND quality_thresholds_set"
+        rollback_command: "Revert to single-model configuration"
+    - step_id: routing_rules
+      name: Define Routing Rules
+      executable: true
+      commands:
+        - "Map task types to model tiers"
+        - "Define fallback logic for edge cases"
+        - "Set quality thresholds for tier escalation"
+      routing_matrix:
+        extraction:
+          primary: "claude-3-haiku / gpt-4o-mini"
+          cost_per_1k_tokens: 0.25
+        qa:
+          primary: "claude-3-5-sonnet / gpt-4o-mini"
+          cost_per_1k_tokens: 3.00
+        generation:
+          primary: "claude-3-5-sonnet / gpt-4o"
+          cost_per_1k_tokens: 15.00
+        reasoning:
+          primary: "claude-opus-4 / o1-preview"
+          cost_per_1k_tokens: 75.00
+      validation:
+        command: "Routing matrix validated"
+        success_criteria: "all_task_types_mapped AND fallbacks_defined"
+        rollback_command: "Disable routing, use premium model"
+    - step_id: implementation
+      name: Implement Routing Layer
+      executable: true
+      commands:
+        - "Add task classifier to API gateway"
+        - "Implement model selector based on classification"
+        - "Add quality monitoring and fallback triggers"
+      validation:
+        command: "Test routing with sample requests"
+        success_criteria: "routing_accuracy > 0.93 AND quality_maintained"
+        rollback_command: "Revert to single-model configuration"
+
+monitoring:
+  key_metrics:
+    - metric: cost_per_successful_task
+      target: "<baseline * 0.4"
+      alert_threshold: ">baseline * 0.6"
+    - metric: task_quality_score
+      target: ">0.95"
+      alert_threshold: "<0.92"
+    - metric: routing_accuracy
+      target: ">0.93"
+      alert_threshold: "<0.88"
+  rollback_triggers:
+    - condition: "quality_score < 0.90 for 1 hour"
+      action: escalate_to_premium_model
+    - condition: "routing_accuracy < 0.85 for 30 minutes"
+      action: disable_routing_use_premium
+
+results:
+  case_study:
+    environment: Legal document processing SaaS
+    baseline_monthly_cost: 47000
+    optimized_monthly_cost: 14100
+    cost_reduction_percent: 70
+    quality_retention: 97.2
+    implementation_days: 12

package/templates/optimizations/auto-scaling-optimization.yaml

@@ -0,0 +1,85 @@
+id: auto-scaling-optimization
+name: Auto-scaling Optimization
+description: Optimize auto-scaling for AI inference workloads with predictive scaling
+category: scaling
+confidence: 0.89
+success_count: 1456
+verified_environments: 68
+contributors:
+  - scaling_engineer
+  - infrastructure_architect
+last_updated: "2024-12-21"
+
+environment_match:
+  traffic_pattern: variable
+  current_scaling: reactive
+  cost_sensitivity: high
+
+optimization:
+  technique: predictive_autoscaling
+  expected_cost_reduction: "20-40%"
+  expected_latency_improvement: "30-50%"
+  effort_estimate: "2-3 weeks"
+  risk_level: medium
+
+economics:
+  baseline_calculation:
+    overprovisioning_percent: 40
+  projected_improvement:
+    optimized_utilization: 0.75
+    cost_reduction_percent: 30
+  implementation_cost:
+    engineering_hours: 120
+    total_cost: 24000
+
+implementation:
+  prerequisites:
+    - requirement: "Auto-scaling infrastructure"
+    - requirement: "Historical traffic data"
+    - requirement: "Kubernetes or cloud autoscaler"
+  automated_steps:
+    - step_id: traffic_analysis
+      name: Traffic Pattern Analysis
+      executable: true
+      commands:
+        - "python scripts/analyze_traffic_patterns.py --history 30d"
+        - "python scripts/build_prediction_model.py"
+      validation:
+        command: "python scripts/validate_predictions.py"
+        success_criteria: "prediction_accuracy > 0.85"
+    - step_id: scaling_config
+      name: Scaling Configuration
+      executable: true
+      commands:
+        - "python scripts/configure_predictive_scaling.py"
+        - "python scripts/set_scaling_bounds.py --min 2 --max 50"
+        - "python scripts/enable_scale_down_delay.py --delay 300"
+      validation:
+        command: "python scripts/test_scaling.py"
+        success_criteria: "scaling_responsive"
+        rollback_command: "python scripts/revert_scaling_config.py"
+
+monitoring:
+  key_metrics:
+    - metric: prediction_accuracy
+      target: ">0.85"
+      alert_threshold: "<0.7"
+    - metric: resource_utilization
+      target: "60-80%"
+      alert_threshold: "<40% OR >90%"
+    - metric: cold_start_rate
+      target: "<0.01"
+      alert_threshold: ">0.05"
+  rollback_triggers:
+    - condition: "cold_start_rate > 0.1 for 10 minutes"
+      action: automatic_rollback
+    - condition: "utilization < 30% for 30 minutes"
+      action: alert_and_investigation
+
+results:
+  recent_implementations:
+    - environment: inference_cluster
+      baseline_overprovisioning: 45
+      optimized_utilization: 72
+      cost_reduction_percent: 35
+      latency_improvement_percent: 40

package/templates/optimizations/batch-utilization-diagnostic.yaml

@@ -0,0 +1,142 @@
+id: batch-utilization-diagnostic
+name: API Batch Utilization Diagnostic and Optimization
+description: Identify batch optimization opportunities in API workloads - 5-minute diagnostic that reveals 50-70% cost savings
+category: api_optimization
+confidence: 0.91
+success_count: 1876
+verified_environments: 89
+contributors:
+  - inference_squeeze
+  - batch_expert
+  - api_architect
+last_updated: "2025-01-20"
+source: "Inference Squeeze Chapter 3 - Batch Utilization Diagnostic"
+
+environment_match:
+  api_pattern: real_time_or_mixed
+  request_pattern: individual_calls
+  latency_tolerance: variable
+  monthly_requests: ">50K"
+
+optimization:
+  technique: request_batching
+  expected_cost_reduction: "50-70%"
+  expected_latency_impact: "50-200ms additional wait"
+  effort_estimate: "3-5 days"
+  risk_level: low
+
+economics:
+  baseline_calculation:
+    individual_requests_per_day: 10000
+    avg_tokens_per_request: 500
+    cost_per_token: 0.00003
+    daily_cost: 150
+  projected_improvement:
+    batch_discount: 0.50
+    new_daily_cost: 75
+    monthly_savings: 2250
+  implementation_cost:
+    engineering_hours: 24
+    total_cost: 4800
+
+diagnostic:
+  five_minute_test:
+    step_1:
+      question: "What percentage of requests require <1s response?"
+      low_batch_signal: ">80% require immediate response"
+      high_batch_signal: "<50% require immediate response"
+    step_2:
+      question: "Can requests be queued for 5-60 seconds?"
+      low_batch_signal: "No, real-time required"
+      high_batch_signal: "Yes, async processing acceptable"
+    step_3:
+      question: "Are requests independent (no dependencies)?"
+      low_batch_signal: "No, requests depend on each other"
+      high_batch_signal: "Yes, can process in any order"
+    step_4:
+      question: "What is your current batch size?"
+      interpretation:
+        batch_1: "6-8x cost reduction possible"
+        batch_2_4: "3-4x cost reduction possible"
+        batch_8_16: "1.5-2x cost reduction possible"
+        batch_32_plus: "Already optimized"
+
+implementation:
+  prerequisites:
+    - requirement: "Request queue infrastructure"
+      validation: "Redis, SQS, or equivalent available"
+    - requirement: "Async processing capability"
+      validation: "Can handle delayed responses"
+  automated_steps:
+    - step_id: workload_analysis
+      name: Analyze Request Patterns
+      executable: true
+      commands:
+        - "Audit latency requirements per endpoint"
+        - "Identify async-eligible workloads"
+        - "Calculate potential batch sizes by endpoint"
+      validation:
+        command: "Request patterns documented"
+        success_criteria: "latency_requirements_mapped AND async_eligible_identified"
+        rollback_command: "Continue with individual requests"
+    - step_id: queue_implementation
+      name: Implement Request Queuing
+      executable: true
+      commands:
+        - "Add message queue (Redis, SQS, etc.)"
+        - "Configure batch collection windows (50-500ms)"
+        - "Implement batch processor with OpenAI Batch API or similar"
+      validation:
+        command: "Test batch processing"
+        success_criteria: "batch_size > 8 AND latency_within_tolerance"
+        rollback_command: "Disable queuing"
+    - step_id: latency_tiers
+      name: Define Latency Tiers
+      executable: true
+      tiers:
+        real_time:
+          max_wait: "0ms"
+          batch_size: 1
+          use_case: "Interactive chat, autocomplete"
+        near_real_time:
+          max_wait: "500ms"
+          batch_size: 8
+          use_case: "Document processing, search"
+        batch:
+          max_wait: "5s"
+          batch_size: 32
+          use_case: "Bulk analysis, reporting"
+        async:
+          max_wait: "24h"
+          batch_size: 1000
+          use_case: "Batch processing, training data"
+      validation:
+        command: "Validate tier assignments"
+        success_criteria: "all_endpoints_tiered"
+        rollback_command: "Revert to real-time only"
+
+monitoring:
+  key_metrics:
+    - metric: avg_batch_size
+      target: ">16"
+      alert_threshold: "<8"
+    - metric: batch_api_utilization
+      target: ">60%"
+      alert_threshold: "<40%"
+    - metric: queue_wait_time_p95
+      target: "<configured_max"
+      alert_threshold: ">configured_max * 1.5"
+  rollback_triggers:
+    - condition: "avg_batch_size < 4 for 1 hour"
+      action: review_batch_configuration
+    - condition: "queue_wait_time_p95 > SLA for 15 minutes"
+      action: reduce_batch_window
+
+results:
+  case_study:
+    environment: E-commerce product description generation
+    baseline_cost_per_item: 0.12
+    optimized_cost_per_item: 0.04
+    cost_reduction_percent: 67
+    items_processed_daily: 50000
+    monthly_savings: 120000

package/templates/optimizations/comprehensive-apm.yaml

@@ -0,0 +1,76 @@
+id: comprehensive-apm
+name: Comprehensive Application Performance Monitoring
+description: Implement end-to-end APM for AI inference workloads
+category: monitoring
+confidence: 0.92
+success_count: 1567
+verified_environments: 72
+contributors:
+  - observability_engineer
+  - sre_specialist
+last_updated: "2024-12-24"
+
+environment_match:
+  observability_maturity: low
+  production_traffic: true
+  incident_frequency: ">2/month"
+
+optimization:
+  technique: comprehensive_apm
+  expected_cost_reduction: "10-20%"
+  effort_estimate: "2-3 weeks"
+  risk_level: low
+
+economics:
+  baseline_calculation:
+    incident_cost_monthly: 15000
+  projected_improvement:
+    incident_reduction_percent: 50
+    monthly_savings: 7500
+  implementation_cost:
+    engineering_hours: 120
+    total_cost: 24000
+
+implementation:
+  prerequisites:
+    - requirement: "APM tool access (Datadog/NewRelic/etc)"
+    - requirement: "Instrumentation capability"
+  automated_steps:
+    - step_id: instrumentation
+      name: Instrumentation Setup
+      executable: true
+      commands:
+        - "python scripts/setup_apm_agent.py"
+        - "python scripts/instrument_inference_calls.py"
+        - "python scripts/configure_custom_metrics.py"
+      validation:
+        command: "python scripts/verify_instrumentation.py"
+        success_criteria: "coverage > 0.95"
+    - step_id: dashboards
+      name: Dashboard Configuration
+      executable: true
+      commands:
+        - "python scripts/create_inference_dashboard.py"
+        - "python scripts/setup_alerts.py"
+      validation:
+        command: "python scripts/test_alerting.py"
+        success_criteria: "alerts_functional"
+
+monitoring:
+  key_metrics:
+    - metric: instrumentation_coverage
+      target: ">0.95"
+      alert_threshold: "<0.8"
+    - metric: metric_cardinality
+      target: "<100K"
+      alert_threshold: ">500K"
+  rollback_triggers:
+    - condition: "APM overhead > 5% latency impact"
+      action: reduce_sampling
+
+results:
+  recent_implementations:
+    - environment: production_api
+      baseline_mttr_hours: 4
+      optimized_mttr_hours: 1.5
+      improvement_percent: 62.5