jumpstart-mode 1.1.11 → 1.1.13

package/bin/lib/evidence-collector.js

@@ -0,0 +1,179 @@
+/**
+ * evidence-collector.js — Evidence Collection Automation (Item 25)
+ *
+ * Auto-package screenshots, logs, tests, policy checks,
+ * architecture diagrams, and approvals for audits.
+ *
+ * Usage:
+ *   node bin/lib/evidence-collector.js collect|package|status [options]
+ *
+ * Output: .jumpstart/evidence/
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_OUTPUT_DIR = path.join('.jumpstart', 'evidence');
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'evidence.json');
+
+const EVIDENCE_TYPES = ['test-results', 'approval-records', 'policy-checks', 'architecture-diagrams',
+  'security-scans', 'coverage-reports', 'audit-logs', 'screenshots', 'compliance-checks'];
+
+/**
+ * Default evidence state.
+ * @returns {object}
+ */
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    collections: [],
+    evidence_items: []
+  };
+}
+
+function loadState(stateFile) {
+  const filePath = stateFile || DEFAULT_STATE_FILE;
+  if (!fs.existsSync(filePath)) return defaultState();
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); }
+  catch { return defaultState(); }
+}
+
+function saveState(state, stateFile) {
+  const filePath = stateFile || DEFAULT_STATE_FILE;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  state.last_updated = new Date().toISOString();
+  fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Collect evidence from the project.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function collectEvidence(root, options = {}) {
+  const stateFile = options.stateFile || path.join(root, DEFAULT_STATE_FILE);
+  const state = loadState(stateFile);
+  const items = [];
+
+  // Collect approval records
+  const approvalFile = path.join(root, '.jumpstart', 'state', 'role-approvals.json');
+  if (fs.existsSync(approvalFile)) {
+    items.push({ type: 'approval-records', source: approvalFile, collected_at: new Date().toISOString() });
+  }
+
+  // Collect policy check results
+  const policyFile = path.join(root, '.jumpstart', 'policies.json');
+  if (fs.existsSync(policyFile)) {
+    items.push({ type: 'policy-checks', source: policyFile, collected_at: new Date().toISOString() });
+  }
+
+  // Collect spec artifacts as architecture evidence
+  const specsDir = path.join(root, 'specs');
+  if (fs.existsSync(specsDir)) {
+    const specs = fs.readdirSync(specsDir).filter(f => f.endsWith('.md'));
+    for (const spec of specs) {
+      items.push({ type: 'architecture-diagrams', source: path.join('specs', spec), collected_at: new Date().toISOString() });
+    }
+  }
+
+  // Collect test results if available
+  const testDirs = ['tests', 'test', '__tests__'];
+  for (const td of testDirs) {
+    const testDir = path.join(root, td);
+    if (fs.existsSync(testDir)) {
+      items.push({ type: 'test-results', source: td, collected_at: new Date().toISOString() });
+      break;
+    }
+  }
+
+  state.evidence_items.push(...items);
+  state.collections.push({
+    id: `ev-${Date.now()}`,
+    collected_at: new Date().toISOString(),
+    items_count: items.length,
+    types: [...new Set(items.map(i => i.type))]
+  });
+
+  saveState(state, stateFile);
+
+  return {
+    success: true,
+    items_collected: items.length,
+    types: [...new Set(items.map(i => i.type))],
+    collection_id: state.collections[state.collections.length - 1].id
+  };
+}
+
+/**
+ * Package evidence into an audit-ready bundle.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function packageEvidence(root, options = {}) {
+  const stateFile = options.stateFile || path.join(root, DEFAULT_STATE_FILE);
+  const state = loadState(stateFile);
+  const outputDir = options.outputDir || path.join(root, DEFAULT_OUTPUT_DIR);
+
+  if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+
+  const manifest = {
+    package_id: `audit-${Date.now()}`,
+    created_at: new Date().toISOString(),
+    project_root: root,
+    total_items: state.evidence_items.length,
+    types: [...new Set(state.evidence_items.map(i => i.type))],
+    collections: state.collections.length,
+    items: state.evidence_items
+  };
+
+  const manifestPath = path.join(outputDir, 'audit-manifest.json');
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n', 'utf8');
+
+  return {
+    success: true,
+    package_id: manifest.package_id,
+    output: manifestPath,
+    total_items: manifest.total_items,
+    types: manifest.types
+  };
+}
+
+/**
+ * Get evidence collection status.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function getStatus(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    total_items: state.evidence_items.length,
+    collections: state.collections.length,
+    types: [...new Set(state.evidence_items.map(i => i.type))],
+    last_collection: state.collections.length > 0
+      ? state.collections[state.collections.length - 1]
+      : null
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  collectEvidence,
+  packageEvidence,
+  getStatus,
+  EVIDENCE_TYPES
+};

package/bin/lib/finops-planner.js

@@ -0,0 +1,182 @@
+/**
+ * finops-planner.js — FinOps-Aware Architecture Planning (Item 35)
+ *
+ * Produce estimated run costs and optimization recommendations
+ * before implementation.
+ *
+ * Usage:
+ *   node bin/lib/finops-planner.js estimate|optimize|report [options]
+ *
+ * State file: .jumpstart/state/finops.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'finops.json');
+
+const COST_CATEGORIES = ['compute', 'storage', 'network', 'database', 'ai-ml', 'monitoring', 'third-party', 'licensing'];
+
+const CLOUD_PRICING_ESTIMATES = {
+  compute: { unit: 'vCPU-hour', low: 0.02, medium: 0.05, high: 0.10 },
+  storage: { unit: 'GB-month', low: 0.01, medium: 0.023, high: 0.10 },
+  network: { unit: 'GB-transfer', low: 0.01, medium: 0.08, high: 0.12 },
+  database: { unit: 'instance-hour', low: 0.02, medium: 0.10, high: 0.50 },
+  'ai-ml': { unit: '1K-tokens', low: 0.001, medium: 0.01, high: 0.06 },
+  monitoring: { unit: 'GB-logs-month', low: 0.25, medium: 0.50, high: 1.00 }
+};
+
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    estimates: [],
+    budgets: [],
+    optimizations: []
+  };
+}
+
+function loadState(stateFile) {
+  const filePath = stateFile || DEFAULT_STATE_FILE;
+  if (!fs.existsSync(filePath)) return defaultState();
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); }
+  catch { return defaultState(); }
+}
+
+function saveState(state, stateFile) {
+  const filePath = stateFile || DEFAULT_STATE_FILE;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  state.last_updated = new Date().toISOString();
+  fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Create a cost estimate for a service/component.
+ *
+ * @param {object} estimate - { name, components[] }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function createEstimate(estimate, options = {}) {
+  if (!estimate || !estimate.name) {
+    return { success: false, error: 'estimate.name is required' };
+  }
+
+  const components = estimate.components || [];
+  let totalMonthly = 0;
+  const breakdown = [];
+
+  for (const comp of components) {
+    const category = comp.category || 'compute';
+    const pricing = CLOUD_PRICING_ESTIMATES[category];
+    const tier = comp.tier || 'medium';
+    const quantity = comp.quantity || 1;
+    const hours = comp.hours_per_month || 730; // ~24*30
+
+    let monthlyCost;
+    if (pricing) {
+      const rate = pricing[tier] || pricing.medium;
+      monthlyCost = rate * quantity * (category === 'storage' || category === 'monitoring' ? 1 : hours);
+    } else {
+      monthlyCost = comp.monthly_cost || 0;
+    }
+
+    breakdown.push({
+      name: comp.name || category,
+      category,
+      quantity,
+      monthly_cost: Math.round(monthlyCost * 100) / 100
+    });
+    totalMonthly += monthlyCost;
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const est = {
+    id: `FIN-${Date.now().toString(36).toUpperCase()}`,
+    name: estimate.name,
+    breakdown,
+    monthly_total: Math.round(totalMonthly * 100) / 100,
+    annual_total: Math.round(totalMonthly * 12 * 100) / 100,
+    created_at: new Date().toISOString()
+  };
+
+  state.estimates.push(est);
+  saveState(state, stateFile);
+
+  return { success: true, estimate: est };
+}
+
+/**
+ * Get optimization recommendations.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function getOptimizations(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const recommendations = [];
+
+  for (const est of state.estimates) {
+    for (const comp of est.breakdown) {
+      if (comp.category === 'compute' && comp.monthly_cost > 500) {
+        recommendations.push({ estimate: est.name, component: comp.name, recommendation: 'Consider reserved instances or spot instances', potential_savings: '30-60%' });
+      }
+      if (comp.category === 'storage' && comp.monthly_cost > 100) {
+        recommendations.push({ estimate: est.name, component: comp.name, recommendation: 'Implement storage tiering (hot/warm/cold)', potential_savings: '20-40%' });
+      }
+      if (comp.category === 'ai-ml' && comp.monthly_cost > 200) {
+        recommendations.push({ estimate: est.name, component: comp.name, recommendation: 'Use smaller models for simple tasks, batch requests', potential_savings: '40-70%' });
+      }
+    }
+  }
+
+  return { success: true, recommendations, total: recommendations.length };
+}
+
+/**
+ * Generate FinOps report.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const totalMonthly = state.estimates.reduce((sum, e) => sum + e.monthly_total, 0);
+  const byCategory = {};
+
+  for (const est of state.estimates) {
+    for (const comp of est.breakdown) {
+      byCategory[comp.category] = (byCategory[comp.category] || 0) + comp.monthly_cost;
+    }
+  }
+
+  return {
+    success: true,
+    total_estimates: state.estimates.length,
+    total_monthly: Math.round(totalMonthly * 100) / 100,
+    total_annual: Math.round(totalMonthly * 12 * 100) / 100,
+    by_category: byCategory,
+    estimates: state.estimates
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  createEstimate,
+  getOptimizations,
+  generateReport,
+  COST_CATEGORIES,
+  CLOUD_PRICING_ESTIMATES
+};

package/bin/lib/fitness-functions.js

@@ -0,0 +1,279 @@
+/**
+ * fitness-functions.js — Architectural Fitness Functions
+ *
+ * Continuously evaluate the implemented system against architecture
+ * constraints and NFRs.
+ *
+ * Config: .jumpstart/fitness-functions.json
+ *
+ * Usage:
+ *   node bin/lib/fitness-functions.js evaluate|add|list|report [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_FITNESS_FILE = path.join('.jumpstart', 'fitness-functions.json');
+
+const FITNESS_CATEGORIES = ['dependency', 'structure', 'complexity', 'naming', 'security', 'performance', 'testing'];
+
+/**
+ * Default fitness function registry.
+ * @returns {object}
+ */
+function defaultRegistry() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_evaluated: null,
+    functions: [],
+    evaluation_history: []
+  };
+}
+
+/**
+ * Load fitness function registry from disk.
+ * @param {string} [registryFile]
+ * @returns {object}
+ */
+function loadRegistry(registryFile) {
+  const filePath = registryFile || DEFAULT_FITNESS_FILE;
+  if (!fs.existsSync(filePath)) {
+    return defaultRegistry();
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return defaultRegistry();
+  }
+}
+
+/**
+ * Save fitness function registry to disk.
+ * @param {object} registry
+ * @param {string} [registryFile]
+ */
+function saveRegistry(registry, registryFile) {
+  const filePath = registryFile || DEFAULT_FITNESS_FILE;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(registry, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Add a fitness function.
+ *
+ * @param {object} func - { id, name, category, description, check_type, pattern?, threshold?, target_dirs? }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function addFitnessFunction(func, options = {}) {
+  if (!func || !func.name || !func.description) {
+    return { success: false, error: 'name and description are required' };
+  }
+
+  const category = (func.category || 'structure').toLowerCase();
+  if (!FITNESS_CATEGORIES.includes(category)) {
+    return { success: false, error: `category must be one of: ${FITNESS_CATEGORIES.join(', ')}` };
+  }
+
+  const registryFile = options.registryFile || DEFAULT_FITNESS_FILE;
+  const registry = loadRegistry(registryFile);
+
+  const id = func.id || `ff-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+  if (registry.functions.find(f => f.id === id)) {
+    return { success: false, error: `Fitness function "${id}" already exists` };
+  }
+
+  const newFunc = {
+    id,
+    name: func.name.trim(),
+    category,
+    description: func.description.trim(),
+    check_type: func.check_type || 'pattern',
+    pattern: func.pattern || null,
+    threshold: func.threshold != null ? func.threshold : null,
+    target_dirs: func.target_dirs || ['src'],
+    enabled: func.enabled !== false,
+    created_at: new Date().toISOString()
+  };
+
+  registry.functions.push(newFunc);
+  saveRegistry(registry, registryFile);
+
+  return { success: true, function: newFunc, total: registry.functions.length };
+}
+
+/**
+ * Built-in fitness checks.
+ */
+const BUILTIN_CHECKS = {
+  max_file_length: (content, threshold) => {
+    const lineCount = content.split('\n').length;
+    return { passed: lineCount <= (threshold || 500), value: lineCount, threshold: threshold || 500 };
+  },
+  no_circular_imports: (content) => {
+    const imports = (content.match(/(?:require|import)\s*\(?['"]([^'"]+)['"]\)?/g) || []);
+    return { passed: true, value: imports.length, note: 'static check only' };
+  },
+  max_function_params: (content, threshold) => {
+    const funcPattern = /function\s+\w+\s*\(([^)]*)\)/g;
+    const arrowPattern = /\(([^)]*)\)\s*(?:=>|{)/g;
+    let maxParams = 0;
+    let match;
+    while ((match = funcPattern.exec(content)) !== null) {
+      const params = match[1].split(',').filter(p => p.trim().length > 0).length;
+      if (params > maxParams) maxParams = params;
+    }
+    while ((match = arrowPattern.exec(content)) !== null) {
+      const params = match[1].split(',').filter(p => p.trim().length > 0).length;
+      if (params > maxParams) maxParams = params;
+    }
+    return { passed: maxParams <= (threshold || 5), value: maxParams, threshold: threshold || 5 };
+  },
+  pattern_match: (content, _threshold, pattern) => {
+    if (!pattern) return { passed: true, value: 0 };
+    try {
+      const regex = new RegExp(pattern, 'gi');
+      const matches = content.match(regex) || [];
+      return { passed: matches.length === 0, value: matches.length, pattern };
+    } catch {
+      return { passed: true, value: 0, error: 'invalid regex' };
+    }
+  }
+};
+
+/**
+ * Evaluate all fitness functions against the project.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function evaluateFitness(root, options = {}) {
+  const registryFile = options.registryFile || path.join(root, DEFAULT_FITNESS_FILE);
+  const registry = loadRegistry(registryFile);
+
+  const enabledFuncs = registry.functions.filter(f => f.enabled !== false);
+  const results = [];
+
+  for (const func of enabledFuncs) {
+    const violations = [];
+    const targetDirs = func.target_dirs || ['src'];
+
+    for (const dir of targetDirs) {
+      const absDir = path.join(root, dir);
+      if (!fs.existsSync(absDir)) continue;
+
+      const walk = (d) => {
+        for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+          if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+          const full = path.join(d, entry.name);
+          if (entry.isDirectory()) {
+            walk(full);
+          } else if (entry.isFile() && /\.(js|ts|jsx|tsx|py|go|java|rb|rs)$/.test(entry.name)) {
+            try {
+              const content = fs.readFileSync(full, 'utf8');
+              const rel = path.relative(root, full).replace(/\\/g, '/');
+              let checkResult;
+
+              if (func.check_type === 'max_file_length') {
+                checkResult = BUILTIN_CHECKS.max_file_length(content, func.threshold);
+              } else if (func.check_type === 'max_function_params') {
+                checkResult = BUILTIN_CHECKS.max_function_params(content, func.threshold);
+              } else if (func.check_type === 'pattern' && func.pattern) {
+                checkResult = BUILTIN_CHECKS.pattern_match(content, func.threshold, func.pattern);
+              } else {
+                checkResult = { passed: true, value: 0 };
+              }
+
+              if (!checkResult.passed) {
+                violations.push({
+                  file: rel,
+                  ...checkResult
+                });
+              }
+            } catch {
+              // skip unreadable files
+            }
+          }
+        }
+      };
+      walk(absDir);
+    }
+
+    results.push({
+      id: func.id,
+      name: func.name,
+      category: func.category,
+      passed: violations.length === 0,
+      violations: violations.length,
+      details: violations.slice(0, 10)
+    });
+  }
+
+  const allPassed = results.every(r => r.passed);
+  const evaluation = {
+    evaluated_at: new Date().toISOString(),
+    total_functions: results.length,
+    passed: results.filter(r => r.passed).length,
+    failed: results.filter(r => !r.passed).length,
+    all_passed: allPassed
+  };
+
+  registry.last_evaluated = evaluation.evaluated_at;
+  registry.evaluation_history.push(evaluation);
+  if (registry.evaluation_history.length > 50) {
+    registry.evaluation_history = registry.evaluation_history.slice(-50);
+  }
+  saveRegistry(registry, registryFile);
+
+  return {
+    success: true,
+    all_passed: allPassed,
+    results,
+    summary: evaluation
+  };
+}
+
+/**
+ * List registered fitness functions.
+ *
+ * @param {object} [filter]
+ * @param {object} [options]
+ * @returns {object}
+ */
+function listFitnessFunctions(filter = {}, options = {}) {
+  const registryFile = options.registryFile || DEFAULT_FITNESS_FILE;
+  const registry = loadRegistry(registryFile);
+
+  let functions = registry.functions;
+  if (filter.category) {
+    functions = functions.filter(f => f.category === filter.category);
+  }
+  if (filter.enabled !== undefined) {
+    functions = functions.filter(f => (f.enabled !== false) === filter.enabled);
+  }
+
+  return {
+    success: true,
+    functions,
+    total: functions.length,
+    last_evaluated: registry.last_evaluated
+  };
+}
+
+module.exports = {
+  defaultRegistry,
+  loadRegistry,
+  saveRegistry,
+  addFitnessFunction,
+  evaluateFitness,
+  listFitnessFunctions,
+  BUILTIN_CHECKS,
+  FITNESS_CATEGORIES
+};