specweave 0.3.13 → 0.4.1

package/src/commands/specweave.costs.md

@@ -0,0 +1,261 @@
+---
+name: specweave.costs
+description: Display AI cost dashboard for current or specified increment with real-time savings tracking
+---
+
+# Cost Dashboard Command
+
+You are being invoked via the `/specweave.costs [incrementId]` command.
+
+## Your Task
+
+Display a comprehensive cost dashboard showing:
+1. Token usage breakdown
+2. Cost by model (Sonnet vs Haiku)
+3. Cost by agent
+4. Savings vs baseline (all-Sonnet)
+5. Recent sessions
+
+**Optional**: Export data to JSON/CSV format
+
+## Implementation Steps
+
+### 1. Parse Arguments
+
+```typescript
+// Extract increment ID from command args
+// If not provided, detect current increment from .specweave/increments/
+// Look for increment with status 'in-progress' in metadata.json
+```
+
+### 2. Load Cost Data
+
+```typescript
+import { CostTracker } from '../core/cost-tracker';
+import { CostReporter } from '../utils/cost-reporter';
+import fs from 'fs-extra';
+import path from 'path';
+
+// Initialize cost tracker
+const costTracker = new CostTracker({
+  logPath: '.specweave/logs/costs.json',
+  autoSave: true,
+});
+
+// Load persisted cost data
+await costTracker.loadFromDisk();
+
+// Create reporter
+const reporter = new CostReporter(costTracker);
+```
+
+### 3. Determine Increment ID
+
+```typescript
+// If user provided increment ID
+const userProvidedId = args[0]; // e.g., "0003"
+
+// Otherwise, detect current increment
+const currentIncrement = await detectCurrentIncrement();
+
+const incrementId = userProvidedId || currentIncrement || 'all';
+```
+
+### 4. Generate Dashboard
+
+```typescript
+// Generate ASCII dashboard
+const dashboard = reporter.generateDashboard(
+  incrementId === 'all' ? undefined : incrementId
+);
+
+// Display to user
+console.log(dashboard);
+```
+
+### 5. Offer Export Options
+
+```typescript
+// Ask user if they want to export
+const wantsExport = await askUser('Would you like to export cost data?', {
+  options: ['JSON', 'CSV', 'Both', 'No'],
+});
+
+if (wantsExport !== 'No') {
+  const outputDir = incrementId === 'all'
+    ? '.specweave/logs/reports'
+    : `.specweave/increments/${incrementId}/reports`;
+
+  await fs.ensureDir(outputDir);
+
+  if (wantsExport === 'JSON' || wantsExport === 'Both') {
+    const jsonPath = path.join(outputDir, 'cost-analysis.json');
+    await reporter.exportToJSON(incrementId, jsonPath);
+    console.log(`✅ Exported to ${jsonPath}`);
+  }
+
+  if (wantsExport === 'CSV' || wantsExport === 'Both') {
+    const csvPath = path.join(outputDir, 'cost-history.csv');
+    await reporter.exportToCSV(incrementId, csvPath);
+    console.log(`✅ Exported to ${csvPath}`);
+  }
+}
+```
+
+## Helper Function: Detect Current Increment
+
+```typescript
+async function detectCurrentIncrement(): Promise<string | null> {
+  const incrementsDir = '.specweave/increments';
+
+  if (!await fs.pathExists(incrementsDir)) {
+    return null;
+  }
+
+  const dirs = await fs.readdir(incrementsDir);
+
+  // Filter out _backlog and other special folders
+  const incrementDirs = dirs.filter(d => /^\d{4}-/.test(d));
+
+  // Check each for in-progress status
+  for (const dir of incrementDirs) {
+    const metadataPath = path.join(incrementsDir, dir, 'metadata.json');
+
+    if (await fs.pathExists(metadataPath)) {
+      const metadata = await fs.readJson(metadataPath);
+      if (metadata.status === 'in-progress') {
+        return dir.split('-')[0]; // Extract "0003" from "0003-intelligent-model-selection"
+      }
+    }
+  }
+
+  // If no in-progress, return most recent
+  return incrementDirs.length > 0
+    ? incrementDirs[incrementDirs.length - 1].split('-')[0]
+    : null;
+}
+```
+
+## Output Examples
+
+### Increment-Specific Dashboard
+
+```
+═══════════════════════════════════════════════════════════════
+  Cost Report: Increment 0003
+═══════════════════════════════════════════════════════════════
+
+SUMMARY
+───────────────────────────────────────────────────────────────
+  Total Cost:       $    0.1234
+  Total Savings:    $    0.3456
+  Savings %:              73.7%
+  Total Tokens:         125,432
+  Sessions:                  15
+
+COST BY MODEL
+───────────────────────────────────────────────────────────────
+  sonnet          $    0.0734  ( 59.4%)
+  haiku           $    0.0500  ( 40.6%)
+
+COST BY AGENT
+───────────────────────────────────────────────────────────────
+  pm                        $  0.0500  ( 40.5%)
+  architect                 $  0.0300  ( 24.3%)
+  frontend                  $  0.0234  ( 19.0%)
+  devops                    $  0.0150  ( 12.2%)
+  qa-lead                   $  0.0050  (  4.0%)
+
+RECENT SESSIONS
+───────────────────────────────────────────────────────────────
+  2025-10-31 14:32:15
+  Agent: pm                  Model: sonnet
+  Cost: $ 0.0150    Savings: $ 0.0350
+
+  2025-10-31 13:15:42
+  Agent: frontend            Model: haiku
+  Cost: $ 0.0034    Savings: $ 0.0166
+
+═══════════════════════════════════════════════════════════════
+```
+
+### Overall Dashboard (All Increments)
+
+```
+═══════════════════════════════════════════════════════════════
+  SpecWeave Cost Summary - All Increments
+═══════════════════════════════════════════════════════════════
+
+OVERALL SUMMARY
+───────────────────────────────────────────────────────────────
+  Total Cost:       $    1.2345
+  Total Savings:    $    3.4567
+  Savings %:              73.7%
+  Total Sessions:             42
+
+AGENT STATS
+───────────────────────────────────────────────────────────────
+  Most Expensive:    pm
+  Least Expensive:   qa-lead
+
+COST BY INCREMENT
+───────────────────────────────────────────────────────────────
+  0001                          $  0.5000  (12 sessions)
+  0002                          $  0.4111  (15 sessions)
+  0003                          $  0.3234  (15 sessions)
+
+═══════════════════════════════════════════════════════════════
+
+💡 Tip: Use "/specweave.costs 0003" to see detailed report for increment 0003
+```
+
+## Error Handling
+
+### No Cost Data
+
+```
+No cost data available for increment 0003.
+
+This could mean:
+- The increment hasn't been started yet
+- Cost tracking is not enabled
+- The cost log file is missing
+
+Run /specweave.do to start executing tasks with cost tracking enabled.
+```
+
+### Invalid Increment ID
+
+```
+Increment 0099 not found.
+
+Available increments:
+- 0001-core-framework
+- 0002-core-enhancements
+- 0003-intelligent-model-selection
+
+Use /specweave.costs without arguments to see all increments.
+```
+
+## Important Notes
+
+1. **Cost Data Persistence**: Costs are persisted to `.specweave/logs/costs.json`
+2. **Baseline Calculation**: Savings are calculated vs an all-Sonnet baseline
+3. **Real-Time Updates**: Costs update after each agent invocation
+4. **Export Formats**: JSON for machine parsing, CSV for spreadsheet import
+5. **Privacy**: Cost data is local only, never sent to external services
+
+## Related Commands
+
+- `/specweave.do` - Execute tasks with cost tracking
+- `/specweave.progress` - View progress with cost summary
+- `/specweave.validate` - Validate increment (includes cost checks)
+
+## Success Criteria
+
+After running this command, the user should:
+1. ✅ See a clear cost breakdown
+2. ✅ Understand their savings vs baseline
+3. ✅ Identify most expensive agents/models
+4. ✅ Have option to export data
+5. ✅ Feel confident about cost optimization

package/src/commands/specweave.increment.md

@@ -117,7 +117,51 @@ You are helping the user create a new SpecWeave increment with automatic closure
 - "What's the short name?" (e.g., "user-authentication" for increment 003-user-authentication)
 - "Priority? (P1/P2/P3)" (default: P1)
 
-### Step 4: Activate Increment Planning Workflow
+### Step 4: Detect Suggested Plugins (T-019 - Plugin Auto-Detection)
+
+**🔌 NEW IN v0.4.0**: Auto-detect plugins based on increment description
+
+Before planning, analyze the feature description for plugin keywords and suggest relevant plugins:
+
+```bash
+# Example feature descriptions and their plugin suggestions:
+"Deploy to Kubernetes" → kubernetes plugin
+"Add Stripe payments" → payment-processing plugin
+"Create React dashboard" → frontend-stack plugin
+"Build FastAPI backend" → backend-stack plugin
+"Sync with GitHub issues" → github plugin
+"Integrate with Jira" → jira plugin
+```
+
+**Detection Logic**:
+1. Extract keywords from feature description
+2. Match against plugin triggers (from manifest.json)
+3. Check if plugin already enabled
+4. Suggest new plugins only
+
+**Output Format**:
+```
+💡 Plugin Detection
+
+Analyzing feature: "Add authentication with NextJS and Stripe"
+
+Suggested plugins:
+✅ frontend-stack (NextJS detected)
+✅ payment-processing (Stripe detected)
+
+Would you like to enable these plugins? (Y/n)
+```
+
+**If user confirms**:
+- Enable plugins via PluginManager
+- Plugins become available for increment planning
+- Skills/agents from plugins can be used immediately
+
+**If user declines**:
+- Continue without plugins
+- User can enable later: `specweave plugin enable <name>`
+
+### Step 5: Activate Increment Planning Workflow
 
 **🚨 CRITICAL - YOU MUST USE THE SKILL TOOL:**
 
@@ -149,7 +193,7 @@ The increment-planner skill will:
 - ✅ Quality gates enforced
 - ❌ Direct file writing bypasses entire workflow
 
-### Step 5: Skill Tool Invocation (MANDATORY)
+### Step 6: Skill Tool Invocation (MANDATORY)
 
 **BEFORE PROCEEDING, USE THE SKILL TOOL:**
 
@@ -158,9 +202,9 @@ You must literally call the Skill tool like this:
 Skill(command: "increment-planner")
 ```
 
-Wait for the skill to complete. Do NOT continue to Step 6 until the increment-planner skill returns.
+Wait for the skill to complete. Do NOT continue to Step 7 until the increment-planner skill returns.
 
-### Step 6: Alternative Approach (ONLY IF SKILL FAILS)
+### Step 7: Alternative Approach (ONLY IF SKILL FAILS)
 
 **Only use this if Skill tool is unavailable or fails:**
 

package/src/commands/specweave.ml-pipeline.md

@@ -0,0 +1,292 @@
+# Machine Learning Pipeline - Multi-Agent MLOps Orchestration
+
+Design and implement a complete ML pipeline for: $ARGUMENTS
+
+## Thinking
+
+This workflow orchestrates multiple specialized agents to build a production-ready ML pipeline following modern MLOps best practices. The approach emphasizes:
+
+- **Phase-based coordination**: Each phase builds upon previous outputs, with clear handoffs between agents
+- **Modern tooling integration**: MLflow/W&B for experiments, Feast/Tecton for features, KServe/Seldon for serving
+- **Production-first mindset**: Every component designed for scale, monitoring, and reliability
+- **Reproducibility**: Version control for data, models, and infrastructure
+- **Continuous improvement**: Automated retraining, A/B testing, and drift detection
+
+The multi-agent approach ensures each aspect is handled by domain experts:
+- Data engineers handle ingestion and quality
+- Data scientists design features and experiments
+- ML engineers implement training pipelines
+- MLOps engineers handle production deployment
+- Observability engineers ensure monitoring
+
+## Phase 1: Data & Requirements Analysis
+
+<Task>
+subagent_type: data-engineer
+prompt: |
+  Analyze and design data pipeline for ML system with requirements: $ARGUMENTS
+
+  Deliverables:
+  1. Data source audit and ingestion strategy:
+     - Source systems and connection patterns
+     - Schema validation using Pydantic/Great Expectations
+     - Data versioning with DVC or lakeFS
+     - Incremental loading and CDC strategies
+
+  2. Data quality framework:
+     - Profiling and statistics generation
+     - Anomaly detection rules
+     - Data lineage tracking
+     - Quality gates and SLAs
+
+  3. Storage architecture:
+     - Raw/processed/feature layers
+     - Partitioning strategy
+     - Retention policies
+     - Cost optimization
+
+  Provide implementation code for critical components and integration patterns.
+</Task>
+
+<Task>
+subagent_type: data-scientist
+prompt: |
+  Design feature engineering and model requirements for: $ARGUMENTS
+  Using data architecture from: {phase1.data-engineer.output}
+
+  Deliverables:
+  1. Feature engineering pipeline:
+     - Transformation specifications
+     - Feature store schema (Feast/Tecton)
+     - Statistical validation rules
+     - Handling strategies for missing data/outliers
+
+  2. Model requirements:
+     - Algorithm selection rationale
+     - Performance metrics and baselines
+     - Training data requirements
+     - Evaluation criteria and thresholds
+
+  3. Experiment design:
+     - Hypothesis and success metrics
+     - A/B testing methodology
+     - Sample size calculations
+     - Bias detection approach
+
+  Include feature transformation code and statistical validation logic.
+</Task>
+
+## Phase 2: Model Development & Training
+
+<Task>
+subagent_type: ml-engineer
+prompt: |
+  Implement training pipeline based on requirements: {phase1.data-scientist.output}
+  Using data pipeline: {phase1.data-engineer.output}
+
+  Build comprehensive training system:
+  1. Training pipeline implementation:
+     - Modular training code with clear interfaces
+     - Hyperparameter optimization (Optuna/Ray Tune)
+     - Distributed training support (Horovod/PyTorch DDP)
+     - Cross-validation and ensemble strategies
+
+  2. Experiment tracking setup:
+     - MLflow/Weights & Biases integration
+     - Metric logging and visualization
+     - Artifact management (models, plots, data samples)
+     - Experiment comparison and analysis tools
+
+  3. Model registry integration:
+     - Version control and tagging strategy
+     - Model metadata and lineage
+     - Promotion workflows (dev -> staging -> prod)
+     - Rollback procedures
+
+  Provide complete training code with configuration management.
+</Task>
+
+<Task>
+subagent_type: python-pro
+prompt: |
+  Optimize and productionize ML code from: {phase2.ml-engineer.output}
+
+  Focus areas:
+  1. Code quality and structure:
+     - Refactor for production standards
+     - Add comprehensive error handling
+     - Implement proper logging with structured formats
+     - Create reusable components and utilities
+
+  2. Performance optimization:
+     - Profile and optimize bottlenecks
+     - Implement caching strategies
+     - Optimize data loading and preprocessing
+     - Memory management for large-scale training
+
+  3. Testing framework:
+     - Unit tests for data transformations
+     - Integration tests for pipeline components
+     - Model quality tests (invariance, directional)
+     - Performance regression tests
+
+  Deliver production-ready, maintainable code with full test coverage.
+</Task>
+
+## Phase 3: Production Deployment & Serving
+
+<Task>
+subagent_type: mlops-engineer
+prompt: |
+  Design production deployment for models from: {phase2.ml-engineer.output}
+  With optimized code from: {phase2.python-pro.output}
+
+  Implementation requirements:
+  1. Model serving infrastructure:
+     - REST/gRPC APIs with FastAPI/TorchServe
+     - Batch prediction pipelines (Airflow/Kubeflow)
+     - Stream processing (Kafka/Kinesis integration)
+     - Model serving platforms (KServe/Seldon Core)
+
+  2. Deployment strategies:
+     - Blue-green deployments for zero downtime
+     - Canary releases with traffic splitting
+     - Shadow deployments for validation
+     - A/B testing infrastructure
+
+  3. CI/CD pipeline:
+     - GitHub Actions/GitLab CI workflows
+     - Automated testing gates
+     - Model validation before deployment
+     - ArgoCD for GitOps deployment
+
+  4. Infrastructure as Code:
+     - Terraform modules for cloud resources
+     - Helm charts for Kubernetes deployments
+     - Docker multi-stage builds for optimization
+     - Secret management with Vault/Secrets Manager
+
+  Provide complete deployment configuration and automation scripts.
+</Task>
+
+<Task>
+subagent_type: kubernetes-architect
+prompt: |
+  Design Kubernetes infrastructure for ML workloads from: {phase3.mlops-engineer.output}
+
+  Kubernetes-specific requirements:
+  1. Workload orchestration:
+     - Training job scheduling with Kubeflow
+     - GPU resource allocation and sharing
+     - Spot/preemptible instance integration
+     - Priority classes and resource quotas
+
+  2. Serving infrastructure:
+     - HPA/VPA for autoscaling
+     - KEDA for event-driven scaling
+     - Istio service mesh for traffic management
+     - Model caching and warm-up strategies
+
+  3. Storage and data access:
+     - PVC strategies for training data
+     - Model artifact storage with CSI drivers
+     - Distributed storage for feature stores
+     - Cache layers for inference optimization
+
+  Provide Kubernetes manifests and Helm charts for entire ML platform.
+</Task>
+
+## Phase 4: Monitoring & Continuous Improvement
+
+<Task>
+subagent_type: observability-engineer
+prompt: |
+  Implement comprehensive monitoring for ML system deployed in: {phase3.mlops-engineer.output}
+  Using Kubernetes infrastructure: {phase3.kubernetes-architect.output}
+
+  Monitoring framework:
+  1. Model performance monitoring:
+     - Prediction accuracy tracking
+     - Latency and throughput metrics
+     - Feature importance shifts
+     - Business KPI correlation
+
+  2. Data and model drift detection:
+     - Statistical drift detection (KS test, PSI)
+     - Concept drift monitoring
+     - Feature distribution tracking
+     - Automated drift alerts and reports
+
+  3. System observability:
+     - Prometheus metrics for all components
+     - Grafana dashboards for visualization
+     - Distributed tracing with Jaeger/Zipkin
+     - Log aggregation with ELK/Loki
+
+  4. Alerting and automation:
+     - PagerDuty/Opsgenie integration
+     - Automated retraining triggers
+     - Performance degradation workflows
+     - Incident response runbooks
+
+  5. Cost tracking:
+     - Resource utilization metrics
+     - Cost allocation by model/experiment
+     - Optimization recommendations
+     - Budget alerts and controls
+
+  Deliver monitoring configuration, dashboards, and alert rules.
+</Task>
+
+## Configuration Options
+
+- **experiment_tracking**: mlflow | wandb | neptune | clearml
+- **feature_store**: feast | tecton | databricks | custom
+- **serving_platform**: kserve | seldon | torchserve | triton
+- **orchestration**: kubeflow | airflow | prefect | dagster
+- **cloud_provider**: aws | azure | gcp | multi-cloud
+- **deployment_mode**: realtime | batch | streaming | hybrid
+- **monitoring_stack**: prometheus | datadog | newrelic | custom
+
+## Success Criteria
+
+1. **Data Pipeline Success**:
+   - < 0.1% data quality issues in production
+   - Automated data validation passing 99.9% of time
+   - Complete data lineage tracking
+   - Sub-second feature serving latency
+
+2. **Model Performance**:
+   - Meeting or exceeding baseline metrics
+   - < 5% performance degradation before retraining
+   - Successful A/B tests with statistical significance
+   - No undetected model drift > 24 hours
+
+3. **Operational Excellence**:
+   - 99.9% uptime for model serving
+   - < 200ms p99 inference latency
+   - Automated rollback within 5 minutes
+   - Complete observability with < 1 minute alert time
+
+4. **Development Velocity**:
+   - < 1 hour from commit to production
+   - Parallel experiment execution
+   - Reproducible training runs
+   - Self-service model deployment
+
+5. **Cost Efficiency**:
+   - < 20% infrastructure waste
+   - Optimized resource allocation
+   - Automatic scaling based on load
+   - Spot instance utilization > 60%
+
+## Final Deliverables
+
+Upon completion, the orchestrated pipeline will provide:
+- End-to-end ML pipeline with full automation
+- Comprehensive documentation and runbooks
+- Production-ready infrastructure as code
+- Complete monitoring and alerting system
+- CI/CD pipelines for continuous improvement
+- Cost optimization and scaling strategies
+- Disaster recovery and rollback procedures