jumpstart-mode 1.1.12 → 1.1.13

package/bin/lib/enterprise-templates.js

@@ -0,0 +1,140 @@
+/**
+ * enterprise-templates.js — Guided Enterprise Templates (Item 67)
+ *
+ * Industry-specific templates for healthcare, insurance, banking,
+ * manufacturing, retail, public sector, and internal platform engineering.
+ *
+ * Usage:
+ *   node bin/lib/enterprise-templates.js list|get|apply [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const VERTICALS = [
+  'healthcare', 'insurance', 'banking', 'manufacturing',
+  'retail', 'public-sector', 'platform-engineering'
+];
+
+const TEMPLATE_CATALOG = {
+  healthcare: {
+    label: 'Healthcare',
+    compliance: ['HIPAA', 'HITECH', 'FDA-21-CFR-Part-11'],
+    data_concerns: ['PHI', 'patient-consent', 'de-identification'],
+    nfrs: ['audit-trail', 'data-encryption-at-rest', 'access-control'],
+    personas: ['clinician', 'patient', 'admin', 'compliance-officer']
+  },
+  insurance: {
+    label: 'Insurance',
+    compliance: ['SOC2', 'state-regulations', 'NAIC'],
+    data_concerns: ['PII', 'claims-data', 'underwriting-models'],
+    nfrs: ['audit-trail', 'data-retention', 'fraud-detection'],
+    personas: ['policyholder', 'agent', 'underwriter', 'claims-adjuster']
+  },
+  banking: {
+    label: 'Banking',
+    compliance: ['PCI-DSS', 'SOX', 'GDPR', 'AML-KYC'],
+    data_concerns: ['PII', 'transaction-data', 'account-info'],
+    nfrs: ['encryption', 'audit-trail', 'multi-factor-auth'],
+    personas: ['customer', 'teller', 'relationship-manager', 'risk-officer']
+  },
+  manufacturing: {
+    label: 'Manufacturing',
+    compliance: ['ISO-9001', 'ISO-27001'],
+    data_concerns: ['IoT-sensor-data', 'supply-chain', 'quality-metrics'],
+    nfrs: ['real-time-processing', 'edge-computing', 'uptime-sla'],
+    personas: ['plant-manager', 'operator', 'quality-engineer', 'supply-chain-manager']
+  },
+  retail: {
+    label: 'Retail',
+    compliance: ['PCI-DSS', 'CCPA', 'GDPR'],
+    data_concerns: ['customer-data', 'payment-info', 'inventory'],
+    nfrs: ['scalability', 'low-latency', 'high-availability'],
+    personas: ['shopper', 'store-manager', 'merchandiser', 'support-agent']
+  },
+  'public-sector': {
+    label: 'Public Sector',
+    compliance: ['FedRAMP', 'FISMA', 'Section-508', 'WCAG'],
+    data_concerns: ['citizen-data', 'classified-info', 'FOIA'],
+    nfrs: ['accessibility', 'audit-trail', 'data-sovereignty'],
+    personas: ['citizen', 'case-worker', 'agency-admin', 'auditor']
+  },
+  'platform-engineering': {
+    label: 'Internal Platform Engineering',
+    compliance: ['SOC2', 'internal-governance'],
+    data_concerns: ['service-configs', 'deployment-state', 'metrics'],
+    nfrs: ['self-service', 'golden-paths', 'developer-experience'],
+    personas: ['platform-engineer', 'app-developer', 'sre', 'security-engineer']
+  }
+};
+
+/**
+ * List available enterprise templates.
+ */
+function listTemplates() {
+  return {
+    success: true,
+    verticals: VERTICALS,
+    templates: VERTICALS.map(v => ({
+      id: v,
+      label: TEMPLATE_CATALOG[v].label,
+      compliance_count: TEMPLATE_CATALOG[v].compliance.length,
+      persona_count: TEMPLATE_CATALOG[v].personas.length
+    }))
+  };
+}
+
+/**
+ * Get detailed template for a vertical.
+ */
+function getTemplate(vertical) {
+  if (!VERTICALS.includes(vertical)) {
+    return { success: false, error: `Unknown vertical: ${vertical}. Valid: ${VERTICALS.join(', ')}` };
+  }
+
+  return {
+    success: true,
+    vertical,
+    template: TEMPLATE_CATALOG[vertical]
+  };
+}
+
+/**
+ * Apply template to project configuration.
+ */
+function applyTemplate(root, vertical, options = {}) {
+  if (!VERTICALS.includes(vertical)) {
+    return { success: false, error: `Unknown vertical: ${vertical}. Valid: ${VERTICALS.join(', ')}` };
+  }
+
+  const template = TEMPLATE_CATALOG[vertical];
+  const applied = {
+    vertical,
+    label: template.label,
+    compliance_frameworks: template.compliance,
+    data_concerns: template.data_concerns,
+    nfr_requirements: template.nfrs,
+    personas: template.personas,
+    applied_at: new Date().toISOString()
+  };
+
+  // Save applied template state
+  const stateDir = path.join(root, '.jumpstart', 'state');
+  if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(stateDir, 'enterprise-template.json'),
+    JSON.stringify(applied, null, 2) + '\n', 'utf8'
+  );
+
+  return { success: true, applied };
+}
+
+module.exports = {
+  listTemplates,
+  getTemplate,
+  applyTemplate,
+  VERTICALS,
+  TEMPLATE_CATALOG
+};

package/bin/lib/environment-promotion.js

@@ -0,0 +1,220 @@
+/**
+ * environment-promotion.js — Environment Promotion Governance (Item 22)
+ *
+ * Track readiness from dev to test to stage to prod with
+ * quality gates tied to environments.
+ *
+ * Usage:
+ *   node bin/lib/environment-promotion.js promote|status|gate [options]
+ *
+ * State file: .jumpstart/state/environment-promotion.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'environment-promotion.json');
+
+const ENVIRONMENTS = ['dev', 'test', 'staging', 'prod'];
+
+const DEFAULT_GATES = {
+  dev: ['unit-tests', 'lint', 'build'],
+  test: ['integration-tests', 'coverage-threshold', 'security-scan'],
+  staging: ['e2e-tests', 'performance-tests', 'approval-required'],
+  prod: ['release-readiness', 'change-advisory', 'final-approval']
+};
+
+/**
+ * Default promotion state.
+ * @returns {object}
+ */
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    current_environment: 'dev',
+    environments: ENVIRONMENTS.map(env => ({
+      name: env,
+      status: env === 'dev' ? 'active' : 'pending',
+      gates: (DEFAULT_GATES[env] || []).map(g => ({ name: g, passed: false, checked_at: null })),
+      promoted_at: null,
+      promoted_by: null
+    })),
+    promotion_history: []
+  };
+}
+
+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');
+}
+
+/**
+ * Check if an environment's gates are all passed.
+ *
+ * @param {string} environment
+ * @param {object} [options]
+ * @returns {object}
+ */
+function checkGates(environment, options = {}) {
+  if (!ENVIRONMENTS.includes(environment)) {
+    return { success: false, error: `Invalid environment: ${environment}. Must be one of: ${ENVIRONMENTS.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+  const env = state.environments.find(e => e.name === environment);
+  if (!env) return { success: false, error: `Environment not found: ${environment}` };
+
+  const passed = env.gates.filter(g => g.passed);
+  const failed = env.gates.filter(g => !g.passed);
+
+  return {
+    success: true,
+    environment,
+    all_passed: failed.length === 0,
+    passed: passed.map(g => g.name),
+    pending: failed.map(g => g.name),
+    total: env.gates.length,
+    ready_to_promote: failed.length === 0
+  };
+}
+
+/**
+ * Record a gate check result.
+ *
+ * @param {string} environment
+ * @param {string} gateName
+ * @param {boolean} passed
+ * @param {object} [options]
+ * @returns {object}
+ */
+function recordGateResult(environment, gateName, passed, options = {}) {
+  if (!ENVIRONMENTS.includes(environment)) {
+    return { success: false, error: `Invalid environment: ${environment}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+  const env = state.environments.find(e => e.name === environment);
+  if (!env) return { success: false, error: `Environment not found: ${environment}` };
+
+  const gate = env.gates.find(g => g.name === gateName);
+  if (!gate) return { success: false, error: `Gate not found: ${gateName}` };
+
+  gate.passed = passed;
+  gate.checked_at = new Date().toISOString();
+  saveState(state, stateFile);
+
+  return { success: true, environment, gate: gateName, passed, checked_at: gate.checked_at };
+}
+
+/**
+ * Promote to the next environment.
+ *
+ * @param {string} targetEnv
+ * @param {object} [options]
+ * @returns {object}
+ */
+function promote(targetEnv, options = {}) {
+  if (!ENVIRONMENTS.includes(targetEnv)) {
+    return { success: false, error: `Invalid environment: ${targetEnv}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const targetIdx = ENVIRONMENTS.indexOf(targetEnv);
+  const currentIdx = ENVIRONMENTS.indexOf(state.current_environment);
+
+  if (targetIdx <= currentIdx) {
+    return { success: false, error: `Cannot promote backward from ${state.current_environment} to ${targetEnv}` };
+  }
+
+  // Check all intermediate gates
+  for (let i = currentIdx; i < targetIdx; i++) {
+    const env = state.environments.find(e => e.name === ENVIRONMENTS[i]);
+    if (env) {
+      const pending = env.gates.filter(g => !g.passed);
+      if (pending.length > 0) {
+        return {
+          success: false,
+          error: `Gates not passed for ${ENVIRONMENTS[i]}: ${pending.map(g => g.name).join(', ')}`
+        };
+      }
+    }
+  }
+
+  state.current_environment = targetEnv;
+  const envObj = state.environments.find(e => e.name === targetEnv);
+  if (envObj) {
+    envObj.status = 'active';
+    envObj.promoted_at = new Date().toISOString();
+    envObj.promoted_by = options.promotedBy || null;
+  }
+
+  state.promotion_history.push({
+    from: ENVIRONMENTS[currentIdx],
+    to: targetEnv,
+    promoted_at: new Date().toISOString(),
+    promoted_by: options.promotedBy || null
+  });
+
+  saveState(state, stateFile);
+
+  return {
+    success: true,
+    from: ENVIRONMENTS[currentIdx],
+    to: targetEnv,
+    current_environment: state.current_environment
+  };
+}
+
+/**
+ * Get promotion status.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function getStatus(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    current_environment: state.current_environment,
+    environments: state.environments.map(e => ({
+      name: e.name,
+      status: e.status,
+      gates_passed: e.gates.filter(g => g.passed).length,
+      gates_total: e.gates.length,
+      ready: e.gates.every(g => g.passed)
+    })),
+    promotion_history: state.promotion_history
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  checkGates,
+  recordGateResult,
+  promote,
+  getStatus,
+  ENVIRONMENTS,
+  DEFAULT_GATES
+};

package/bin/lib/estimation-studio.js

@@ -0,0 +1,130 @@
+/**
+ * estimation-studio.js — Feature Estimation Studio (Item 72)
+ *
+ * T-shirt sizing, story points, ideal days, ROM cost,
+ * and confidence ranges for feature estimation.
+ *
+ * Usage:
+ *   node bin/lib/estimation-studio.js estimate|report|calibrate [options]
+ *
+ * State file: .jumpstart/state/estimations.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'estimations.json');
+
+const TSHIRT_SIZES = ['XS', 'S', 'M', 'L', 'XL', 'XXL'];
+const TSHIRT_TO_POINTS = { XS: 1, S: 2, M: 3, L: 5, XL: 8, XXL: 13 };
+const TSHIRT_TO_DAYS = { XS: 0.5, S: 1, M: 2, L: 5, XL: 10, XXL: 20 };
+
+const CONFIDENCE_LEVELS = ['low', 'medium', 'high'];
+const CONFIDENCE_RANGES = {
+  low: { min_multiplier: 0.5, max_multiplier: 3.0 },
+  medium: { min_multiplier: 0.75, max_multiplier: 1.5 },
+  high: { min_multiplier: 0.9, max_multiplier: 1.2 }
+};
+
+function defaultState() {
+  return { version: '1.0.0', estimates: [], calibration: { velocity: null }, last_updated: null };
+}
+
+function loadState(stateFile) {
+  const fp = stateFile || DEFAULT_STATE_FILE;
+  if (!fs.existsSync(fp)) return defaultState();
+  try { return JSON.parse(fs.readFileSync(fp, 'utf8')); }
+  catch { return defaultState(); }
+}
+
+function saveState(state, stateFile) {
+  const fp = stateFile || DEFAULT_STATE_FILE;
+  const dir = path.dirname(fp);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  state.last_updated = new Date().toISOString();
+  fs.writeFileSync(fp, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Estimate a feature.
+ */
+function estimateFeature(name, tshirtSize, options = {}) {
+  if (!name || !tshirtSize) return { success: false, error: 'name and tshirtSize are required' };
+  if (!TSHIRT_SIZES.includes(tshirtSize)) {
+    return { success: false, error: `Invalid size: ${tshirtSize}. Valid: ${TSHIRT_SIZES.join(', ')}` };
+  }
+
+  const confidence = options.confidence || 'medium';
+  const range = CONFIDENCE_RANGES[confidence] || CONFIDENCE_RANGES.medium;
+  const points = TSHIRT_TO_POINTS[tshirtSize];
+  const days = TSHIRT_TO_DAYS[tshirtSize];
+  const dailyRate = options.dailyRate || 800;
+
+  const estimate = {
+    id: `EST-${Date.now()}`,
+    name,
+    tshirt_size: tshirtSize,
+    story_points: points,
+    ideal_days: days,
+    confidence,
+    rom_cost: {
+      min: Math.round(days * dailyRate * range.min_multiplier),
+      expected: Math.round(days * dailyRate),
+      max: Math.round(days * dailyRate * range.max_multiplier)
+    },
+    created_at: new Date().toISOString()
+  };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+  state.estimates.push(estimate);
+  saveState(state, stateFile);
+
+  return { success: true, estimate };
+}
+
+/**
+ * Generate estimation report.
+ */
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const totalPoints = state.estimates.reduce((s, e) => s + e.story_points, 0);
+  const totalDays = state.estimates.reduce((s, e) => s + e.ideal_days, 0);
+  const totalCostMin = state.estimates.reduce((s, e) => s + e.rom_cost.min, 0);
+  const totalCostMax = state.estimates.reduce((s, e) => s + e.rom_cost.max, 0);
+
+  return {
+    success: true,
+    total_features: state.estimates.length,
+    total_story_points: totalPoints,
+    total_ideal_days: totalDays,
+    total_rom_cost: { min: totalCostMin, max: totalCostMax },
+    by_size: TSHIRT_SIZES.reduce((acc, size) => {
+      acc[size] = state.estimates.filter(e => e.tshirt_size === size).length;
+      return acc;
+    }, {}),
+    estimates: state.estimates
+  };
+}
+
+/**
+ * Set calibration data.
+ */
+function calibrate(velocity, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+  state.calibration.velocity = velocity;
+  state.calibration.updated_at = new Date().toISOString();
+  saveState(state, stateFile);
+  return { success: true, velocity };
+}
+
+module.exports = {
+  estimateFeature, generateReport, calibrate,
+  loadState, saveState, defaultState,
+  TSHIRT_SIZES, TSHIRT_TO_POINTS, TSHIRT_TO_DAYS, CONFIDENCE_LEVELS, CONFIDENCE_RANGES
+};

package/bin/lib/event-modeling.js

@@ -0,0 +1,133 @@
+/**
+ * event-modeling.js — Event-Driven Architecture Modeling (Item 85)
+ *
+ * Topics, events, idempotency, retries, DLQs, sagas,
+ * and observability patterns.
+ *
+ * Usage:
+ *   node bin/lib/event-modeling.js define|validate|report [options]
+ *
+ * State file: .jumpstart/state/event-modeling.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'event-modeling.json');
+
+const EVENT_TYPES = ['domain-event', 'integration-event', 'command', 'query'];
+const PATTERNS = ['saga', 'choreography', 'orchestration', 'cqrs', 'event-sourcing'];
+
+function defaultState() {
+  return { version: '1.0.0', topics: [], events: [], sagas: [], last_updated: null };
+}
+
+function loadState(stateFile) {
+  const fp = stateFile || DEFAULT_STATE_FILE;
+  if (!fs.existsSync(fp)) return defaultState();
+  try { return JSON.parse(fs.readFileSync(fp, 'utf8')); }
+  catch { return defaultState(); }
+}
+
+function saveState(state, stateFile) {
+  const fp = stateFile || DEFAULT_STATE_FILE;
+  const dir = path.dirname(fp);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  state.last_updated = new Date().toISOString();
+  fs.writeFileSync(fp, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+function defineTopic(name, options = {}) {
+  if (!name) return { success: false, error: 'Topic name is required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const topic = {
+    id: `TOPIC-${Date.now()}`,
+    name,
+    partitions: options.partitions || 1,
+    retention: options.retention || '7d',
+    dlq: options.dlq || false,
+    created_at: new Date().toISOString()
+  };
+
+  state.topics.push(topic);
+  saveState(state, stateFile);
+
+  return { success: true, topic };
+}
+
+function defineEvent(name, topicId, options = {}) {
+  if (!name || !topicId) return { success: false, error: 'name and topicId are required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const event = {
+    id: `EVT-${Date.now()}`,
+    name,
+    topic: topicId,
+    type: options.type || 'domain-event',
+    schema: options.schema || {},
+    idempotency_key: options.idempotency_key || null,
+    retry_policy: options.retry_policy || { max_retries: 3, backoff: 'exponential' },
+    created_at: new Date().toISOString()
+  };
+
+  if (!EVENT_TYPES.includes(event.type)) {
+    return { success: false, error: `Unknown type: ${event.type}. Valid: ${EVENT_TYPES.join(', ')}` };
+  }
+
+  state.events.push(event);
+  saveState(state, stateFile);
+
+  return { success: true, event };
+}
+
+function defineSaga(name, steps, options = {}) {
+  if (!name || !steps || !Array.isArray(steps)) {
+    return { success: false, error: 'name and steps array are required' };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const saga = {
+    id: `SAGA-${Date.now()}`,
+    name,
+    steps: steps.map((s, i) => ({ order: i + 1, ...s })),
+    compensation: options.compensation || 'manual',
+    created_at: new Date().toISOString()
+  };
+
+  state.sagas.push(saga);
+  saveState(state, stateFile);
+
+  return { success: true, saga };
+}
+
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    total_topics: state.topics.length,
+    total_events: state.events.length,
+    total_sagas: state.sagas.length,
+    topics_with_dlq: state.topics.filter(t => t.dlq).length,
+    events_by_type: state.events.reduce((acc, e) => { acc[e.type] = (acc[e.type] || 0) + 1; return acc; }, {}),
+    topics: state.topics,
+    events: state.events,
+    sagas: state.sagas
+  };
+}
+
+module.exports = {
+  defineTopic, defineEvent, defineSaga, generateReport,
+  loadState, saveState, defaultState,
+  EVENT_TYPES, PATTERNS
+};