jumpstart-mode 1.1.12 → 1.1.13

package/bin/lib/delivery-confidence.js

@@ -0,0 +1,361 @@
+/**
+ * delivery-confidence.js — Delivery Confidence Scoring
+ *
+ * Score a planned or implemented feature on completeness, risk,
+ * ambiguity, quality, and enterprise readiness.
+ *
+ * Usage:
+ *   node bin/lib/delivery-confidence.js score|report [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DIMENSIONS = ['completeness', 'risk', 'ambiguity', 'quality', 'enterprise_readiness'];
+
+const WEIGHT_DEFAULTS = {
+  completeness: 0.25,
+  risk: 0.20,
+  ambiguity: 0.20,
+  quality: 0.20,
+  enterprise_readiness: 0.15
+};
+
+const CONFIDENCE_LEVELS = [
+  { min: 90, label: 'Very High', emoji: '🟢' },
+  { min: 75, label: 'High', emoji: '🟡' },
+  { min: 50, label: 'Medium', emoji: '🟠' },
+  { min: 25, label: 'Low', emoji: '🔴' },
+  { min: 0, label: 'Very Low', emoji: '⛔' }
+];
+
+/**
+ * Analyze completeness of an artifact.
+ * @param {string} content
+ * @param {string} artifactType
+ * @returns {object}
+ */
+function analyzeCompleteness(content, artifactType) {
+  const checks = [];
+  const lines = content.split('\n');
+
+  // Check for required sections
+  const hasFrontmatter = content.startsWith('---');
+  checks.push({ check: 'has_frontmatter', passed: hasFrontmatter });
+
+  const hasApproval = content.includes('Phase Gate Approval');
+  checks.push({ check: 'has_approval_section', passed: hasApproval });
+
+  const headingCount = (content.match(/^#{1,4}\s+/gm) || []).length;
+  checks.push({ check: 'has_sections', passed: headingCount >= 3 });
+
+  // Check for placeholder content
+  const placeholders = (content.match(/\[TODO\]|\[TBD\]|\[PLACEHOLDER\]|\[NEEDS CLARIFICATION\]/gi) || []).length;
+  checks.push({ check: 'no_placeholders', passed: placeholders === 0 });
+
+  // Check for empty sections
+  const emptySections = [];
+  let currentHeading = null;
+  let hasContent = false;
+  for (const line of lines) {
+    if (/^#{1,4}\s+/.test(line)) {
+      if (currentHeading && !hasContent) emptySections.push(currentHeading);
+      currentHeading = line.trim();
+      hasContent = false;
+    } else if (line.trim().length > 0) {
+      hasContent = true;
+    }
+  }
+  checks.push({ check: 'no_empty_sections', passed: emptySections.length === 0 });
+
+  // Check minimum content length
+  checks.push({ check: 'sufficient_content', passed: content.length > 500 });
+
+  const passed = checks.filter(c => c.passed).length;
+  return {
+    score: Math.round((passed / checks.length) * 100),
+    checks,
+    gaps: checks.filter(c => !c.passed).map(c => c.check),
+    placeholders_found: placeholders
+  };
+}
+
+/**
+ * Analyze risk factors.
+ * @param {string} content
+ * @returns {object}
+ */
+function analyzeRisk(content) {
+  const risks = [];
+
+  // Check for risk-related keywords
+  const riskKeywords = ['risk', 'concern', 'unknown', 'assumption', 'constraint', 'blocker', 'dependency'];
+  for (const keyword of riskKeywords) {
+    const pattern = new RegExp(`\\b${keyword}s?\\b`, 'gi');
+    const matches = content.match(pattern) || [];
+    if (matches.length > 0) {
+      risks.push({ factor: keyword, mentions: matches.length });
+    }
+  }
+
+  // Check for explicit risk sections
+  const hasRiskSection = /#{1,4}\s+.*risk/i.test(content);
+  const hasMitigations = /mitigation|mitigate|contingency|fallback/i.test(content);
+
+  // Score: more risk identification + mitigations = higher score (better managed)
+  const riskIdentified = risks.length > 0;
+  const score = riskIdentified
+    ? (hasMitigations ? 85 : 55)
+    : (hasRiskSection ? 70 : 40);
+
+  return {
+    score,
+    risk_factors: risks,
+    has_risk_section: hasRiskSection,
+    has_mitigations: hasMitigations
+  };
+}
+
+/**
+ * Analyze ambiguity in content.
+ * @param {string} content
+ * @returns {object}
+ */
+function analyzeAmbiguity(content) {
+  const ambiguousTerms = [
+    'should', 'might', 'could', 'may', 'possibly', 'potentially',
+    'approximately', 'roughly', 'maybe', 'etc', 'and so on',
+    'as needed', 'as appropriate', 'if necessary', 'TBD', 'TBA'
+  ];
+
+  const findings = [];
+  for (const term of ambiguousTerms) {
+    const pattern = new RegExp(`\\b${term}\\b`, 'gi');
+    const matches = content.match(pattern) || [];
+    if (matches.length > 0) {
+      findings.push({ term, count: matches.length });
+    }
+  }
+
+  const totalAmbiguous = findings.reduce((sum, f) => sum + f.count, 0);
+  const wordCount = content.split(/\s+/).length;
+  const ambiguityRate = wordCount > 0 ? totalAmbiguous / wordCount : 0;
+
+  // Lower ambiguity rate = higher score
+  const score = Math.max(0, Math.round(100 - (ambiguityRate * 2000)));
+
+  return {
+    score,
+    ambiguous_terms: findings,
+    total_ambiguous: totalAmbiguous,
+    word_count: wordCount,
+    ambiguity_rate: Math.round(ambiguityRate * 10000) / 100
+  };
+}
+
+/**
+ * Analyze quality indicators.
+ * @param {string} content
+ * @param {string} root
+ * @returns {object}
+ */
+function analyzeQuality(content, root) {
+  const checks = [];
+
+  // Check for acceptance criteria
+  const hasAC = /acceptance\s+criteria/i.test(content);
+  checks.push({ check: 'acceptance_criteria', passed: hasAC });
+
+  // Check for test references
+  const hasTests = /test|spec|verify|validate/i.test(content);
+  checks.push({ check: 'test_references', passed: hasTests });
+
+  // Check for diagrams
+  const hasDiagrams = /```mermaid|flowchart|sequenceDiagram|classDiagram/i.test(content);
+  checks.push({ check: 'has_diagrams', passed: hasDiagrams });
+
+  // Check for traceability IDs
+  const hasTracing = /\b(REQ-\d+|E\d+-S\d+|NFR-\d+|M\d+-T\d+)\b/.test(content);
+  checks.push({ check: 'traceability_ids', passed: hasTracing });
+
+  // Check for code examples
+  const hasCodeExamples = /```\w+/.test(content);
+  checks.push({ check: 'code_examples', passed: hasCodeExamples });
+
+  // Check for cross-references
+  const hasCrossRefs = /\[.*\]\(.*\.md\)/.test(content);
+  checks.push({ check: 'cross_references', passed: hasCrossRefs });
+
+  const passed = checks.filter(c => c.passed).length;
+  return {
+    score: Math.round((passed / checks.length) * 100),
+    checks,
+    gaps: checks.filter(c => !c.passed).map(c => c.check)
+  };
+}
+
+/**
+ * Analyze enterprise readiness.
+ * @param {string} content
+ * @returns {object}
+ */
+function analyzeEnterpriseReadiness(content) {
+  const checks = [];
+
+  // Security considerations
+  const hasSecurity = /security|auth|encryption|RBAC|access control|OWASP/i.test(content);
+  checks.push({ check: 'security_considerations', passed: hasSecurity });
+
+  // Scalability
+  const hasScalability = /scalab|performance|latency|throughput|load/i.test(content);
+  checks.push({ check: 'scalability', passed: hasScalability });
+
+  // Compliance
+  const hasCompliance = /compliance|regulatory|GDPR|HIPAA|SOC|PCI|audit/i.test(content);
+  checks.push({ check: 'compliance', passed: hasCompliance });
+
+  // Monitoring / Observability
+  const hasMonitoring = /monitor|observab|logging|tracing|alert|metric/i.test(content);
+  checks.push({ check: 'monitoring', passed: hasMonitoring });
+
+  // Deployment
+  const hasDeployment = /deploy|CI\/CD|pipeline|container|kubernetes|docker/i.test(content);
+  checks.push({ check: 'deployment', passed: hasDeployment });
+
+  // Documentation
+  const hasDocumentation = /document|README|runbook|wiki|onboard/i.test(content);
+  checks.push({ check: 'documentation', passed: hasDocumentation });
+
+  const passed = checks.filter(c => c.passed).length;
+  return {
+    score: Math.round((passed / checks.length) * 100),
+    checks,
+    gaps: checks.filter(c => !c.passed).map(c => c.check)
+  };
+}
+
+/**
+ * Compute overall delivery confidence score.
+ *
+ * @param {string} content - Artifact content.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function scoreConfidence(content, options = {}) {
+  const weights = { ...WEIGHT_DEFAULTS, ...options.weights };
+  const root = options.root || '.';
+  const artifactType = options.artifactType || 'generic';
+
+  const dimensions = {
+    completeness: analyzeCompleteness(content, artifactType),
+    risk: analyzeRisk(content),
+    ambiguity: analyzeAmbiguity(content),
+    quality: analyzeQuality(content, root),
+    enterprise_readiness: analyzeEnterpriseReadiness(content)
+  };
+
+  const weightedScore = Math.round(
+    dimensions.completeness.score * weights.completeness +
+    dimensions.risk.score * weights.risk +
+    dimensions.ambiguity.score * weights.ambiguity +
+    dimensions.quality.score * weights.quality +
+    dimensions.enterprise_readiness.score * weights.enterprise_readiness
+  );
+
+  const level = CONFIDENCE_LEVELS.find(l => weightedScore >= l.min) || CONFIDENCE_LEVELS[CONFIDENCE_LEVELS.length - 1];
+
+  const allGaps = [
+    ...(dimensions.completeness.gaps || []),
+    ...(dimensions.quality.gaps || []),
+    ...(dimensions.enterprise_readiness.gaps || [])
+  ];
+
+  return {
+    success: true,
+    overall_score: weightedScore,
+    confidence_level: level.label,
+    confidence_emoji: level.emoji,
+    dimensions,
+    top_gaps: allGaps.slice(0, 5),
+    weights_used: weights
+  };
+}
+
+/**
+ * Score a file on disk.
+ *
+ * @param {string} filePath - Path to artifact.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function scoreFile(filePath, options = {}) {
+  if (!fs.existsSync(filePath)) {
+    return { success: false, error: `File not found: ${filePath}` };
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const result = scoreConfidence(content, options);
+  result.file = filePath;
+  return result;
+}
+
+/**
+ * Score all spec artifacts in a project.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function scoreProject(root, options = {}) {
+  const specsDir = path.join(root, 'specs');
+  if (!fs.existsSync(specsDir)) {
+    return { success: false, error: 'specs/ directory not found' };
+  }
+
+  const results = [];
+  const artifacts = ['challenger-brief.md', 'product-brief.md', 'prd.md', 'architecture.md', 'implementation-plan.md'];
+
+  for (const artifact of artifacts) {
+    const fullPath = path.join(specsDir, artifact);
+    if (fs.existsSync(fullPath)) {
+      const result = scoreFile(fullPath, { ...options, root });
+      results.push({ artifact, ...result });
+    }
+  }
+
+  const avgScore = results.length > 0
+    ? Math.round(results.reduce((sum, r) => sum + (r.overall_score || 0), 0) / results.length)
+    : 0;
+
+  const level = CONFIDENCE_LEVELS.find(l => avgScore >= l.min) || CONFIDENCE_LEVELS[CONFIDENCE_LEVELS.length - 1];
+
+  return {
+    success: true,
+    project_score: avgScore,
+    project_confidence: level.label,
+    project_emoji: level.emoji,
+    artifacts: results,
+    summary: {
+      artifacts_scored: results.length,
+      average_score: avgScore,
+      highest: results.length > 0 ? results.reduce((a, b) => (a.overall_score || 0) > (b.overall_score || 0) ? a : b).artifact : null,
+      lowest: results.length > 0 ? results.reduce((a, b) => (a.overall_score || 0) < (b.overall_score || 0) ? a : b).artifact : null
+    }
+  };
+}
+
+module.exports = {
+  analyzeCompleteness,
+  analyzeRisk,
+  analyzeAmbiguity,
+  analyzeQuality,
+  analyzeEnterpriseReadiness,
+  scoreConfidence,
+  scoreFile,
+  scoreProject,
+  DIMENSIONS,
+  WEIGHT_DEFAULTS,
+  CONFIDENCE_LEVELS
+};

package/bin/lib/dependency-upgrade.js

@@ -0,0 +1,153 @@
+/**
+ * dependency-upgrade.js — Dependency Upgrade Autopilot (Item 51)
+ *
+ * Plan, test, patch, and validate framework/library upgrades
+ * in a governed manner.
+ *
+ * Usage:
+ *   node bin/lib/dependency-upgrade.js scan|plan|report [options]
+ *
+ * State file: .jumpstart/state/dependency-upgrades.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'dependency-upgrades.json');
+
+const UPGRADE_TYPES = ['patch', 'minor', 'major'];
+const RISK_BY_TYPE = { patch: 'low', minor: 'medium', major: 'high' };
+
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    scans: [],
+    upgrade_plans: []
+  };
+}
+
+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');
+}
+
+/**
+ * Scan for available dependency upgrades.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function scanUpgrades(root, options = {}) {
+  const packageFile = path.join(root, 'package.json');
+  if (!fs.existsSync(packageFile)) {
+    return { success: false, error: 'package.json not found' };
+  }
+
+  let pkg;
+  try { pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8')); }
+  catch { return { success: false, error: 'Invalid package.json' }; }
+
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const candidates = [];
+
+  for (const [name, version] of Object.entries(deps)) {
+    const clean = version.replace(/^[\^~>=<]/, '');
+    candidates.push({
+      name,
+      current_version: clean,
+      specified: version,
+      type: version.startsWith('^') ? 'minor-range' : version.startsWith('~') ? 'patch-range' : 'fixed',
+      is_dev: !!(pkg.devDependencies && pkg.devDependencies[name])
+    });
+  }
+
+  const stateFile = options.stateFile || path.join(root, DEFAULT_STATE_FILE);
+  const state = loadState(stateFile);
+  state.scans.push({
+    scanned_at: new Date().toISOString(),
+    total: candidates.length
+  });
+  saveState(state, stateFile);
+
+  return { success: true, dependencies: candidates, total: candidates.length };
+}
+
+/**
+ * Create an upgrade plan.
+ *
+ * @param {object} plan - { name, upgrades[] }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function createUpgradePlan(plan, options = {}) {
+  if (!plan || !plan.name) return { success: false, error: 'plan.name is required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const upgradePlan = {
+    id: `UPG-${(state.upgrade_plans.length + 1).toString().padStart(3, '0')}`,
+    name: plan.name,
+    upgrades: (plan.upgrades || []).map(u => ({
+      package: u.package || u.name,
+      from: u.from || u.current_version,
+      to: u.to || u.target_version,
+      type: u.type || 'minor',
+      risk: RISK_BY_TYPE[u.type] || 'medium',
+      status: 'planned',
+      test_result: null
+    })),
+    status: 'draft',
+    created_at: new Date().toISOString()
+  };
+
+  state.upgrade_plans.push(upgradePlan);
+  saveState(state, stateFile);
+
+  return { success: true, plan: upgradePlan };
+}
+
+/**
+ * Generate upgrade report.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    total_plans: state.upgrade_plans.length,
+    total_scans: state.scans.length,
+    plans: state.upgrade_plans,
+    last_scan: state.scans.length > 0 ? state.scans[state.scans.length - 1] : null
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  scanUpgrades,
+  createUpgradePlan,
+  generateReport,
+  UPGRADE_TYPES,
+  RISK_BY_TYPE
+};

package/bin/lib/design-system.js

@@ -0,0 +1,133 @@
+/**
+ * design-system.js — Design System Integration (Item 69)
+ *
+ * Connect to enterprise design tokens, component libraries,
+ * accessibility standards, and brand rules.
+ *
+ * Usage:
+ *   node bin/lib/design-system.js register|check|report [options]
+ *
+ * State file: .jumpstart/state/design-system.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'design-system.json');
+
+const TOKEN_CATEGORIES = ['color', 'typography', 'spacing', 'elevation', 'breakpoint', 'motion'];
+const ACCESSIBILITY_LEVELS = ['A', 'AA', 'AAA'];
+
+function defaultState() {
+  return { version: '1.0.0', tokens: {}, components: [], accessibility: { level: 'AA' }, brand: {}, 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');
+}
+
+/**
+ * Register design tokens.
+ */
+function registerTokens(category, tokens, options = {}) {
+  if (!category || !tokens) return { success: false, error: 'category and tokens are required' };
+  if (!TOKEN_CATEGORIES.includes(category)) {
+    return { success: false, error: `Unknown category: ${category}. Valid: ${TOKEN_CATEGORIES.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+  state.tokens[category] = tokens;
+  saveState(state, stateFile);
+
+  return { success: true, category, token_count: Object.keys(tokens).length };
+}
+
+/**
+ * Register a component.
+ */
+function registerComponent(name, spec, options = {}) {
+  if (!name) return { success: false, error: 'Component name is required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const component = {
+    name,
+    props: spec.props || [],
+    accessibility: spec.accessibility || [],
+    tokens_used: spec.tokens_used || [],
+    registered_at: new Date().toISOString()
+  };
+
+  state.components.push(component);
+  saveState(state, stateFile);
+
+  return { success: true, component };
+}
+
+/**
+ * Check design system compliance.
+ */
+function checkCompliance(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const issues = [];
+  const tokenCategories = Object.keys(state.tokens);
+  
+  for (const required of ['color', 'typography', 'spacing']) {
+    if (!tokenCategories.includes(required)) {
+      issues.push({ type: 'missing_tokens', category: required, severity: 'warning' });
+    }
+  }
+
+  for (const comp of state.components) {
+    if (!comp.accessibility || comp.accessibility.length === 0) {
+      issues.push({ type: 'missing_accessibility', component: comp.name, severity: 'warning' });
+    }
+  }
+
+  return {
+    success: true,
+    compliant: issues.length === 0,
+    issues,
+    token_categories: tokenCategories.length,
+    components: state.components.length,
+    accessibility_level: state.accessibility.level
+  };
+}
+
+/**
+ * Generate design system report.
+ */
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    tokens: Object.fromEntries(Object.entries(state.tokens).map(([k, v]) => [k, Object.keys(v).length])),
+    components: state.components.length,
+    accessibility_level: state.accessibility.level,
+    brand: state.brand
+  };
+}
+
+module.exports = {
+  registerTokens, registerComponent, checkCompliance, generateReport,
+  loadState, saveState, defaultState, TOKEN_CATEGORIES, ACCESSIBILITY_LEVELS
+};