jumpstart-mode 1.1.12 → 1.1.13

package/bin/lib/cab-output.js

@@ -0,0 +1,119 @@
+/**
+ * cab-output.js — Change Advisory Board Output Mode (Item 37)
+ *
+ * Generate CAB-ready summaries and implementation risk memos.
+ *
+ * Usage:
+ *   node bin/lib/cab-output.js generate|status [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const CAB_SECTIONS = ['change-description', 'risk-assessment', 'impact-analysis', 'rollback-plan',
+  'testing-summary', 'approval-status', 'implementation-schedule', 'communication-plan'];
+
+/**
+ * Generate a CAB-ready change summary.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generateCABSummary(root, options = {}) {
+  const summary = {
+    id: `CAB-${Date.now()}`,
+    generated_at: new Date().toISOString(),
+    sections: {}
+  };
+
+  // Change description from specs
+  const prdFile = path.join(root, 'specs', 'prd.md');
+  if (fs.existsSync(prdFile)) {
+    try {
+      const content = fs.readFileSync(prdFile, 'utf8');
+      const title = (content.match(/^#\s+(.+)$/m) || [])[1] || 'Untitled';
+      const stories = (content.match(/\bE\d+-S\d+\b/g) || []).length;
+      summary.sections['change-description'] = { present: true, title, user_stories: stories };
+    } catch { summary.sections['change-description'] = { present: false }; }
+  } else {
+    summary.sections['change-description'] = { present: false };
+  }
+
+  // Risk assessment
+  const riskFile = path.join(root, '.jumpstart', 'state', 'risk-register.json');
+  if (fs.existsSync(riskFile)) {
+    try {
+      const risks = JSON.parse(fs.readFileSync(riskFile, 'utf8'));
+      const high = (risks.risks || []).filter(r => r.score >= 15);
+      summary.sections['risk-assessment'] = { present: true, total_risks: (risks.risks || []).length, high_risks: high.length };
+    } catch { summary.sections['risk-assessment'] = { present: false }; }
+  } else {
+    summary.sections['risk-assessment'] = { present: false };
+  }
+
+  // Impact analysis
+  const archFile = path.join(root, 'specs', 'architecture.md');
+  summary.sections['impact-analysis'] = { present: fs.existsSync(archFile) };
+
+  // Rollback plan
+  summary.sections['rollback-plan'] = {
+    present: false,
+    recommendation: 'Define rollback strategy in architecture specs'
+  };
+  if (fs.existsSync(archFile)) {
+    try {
+      const content = fs.readFileSync(archFile, 'utf8');
+      if (/rollback|roll.back|revert/i.test(content)) {
+        summary.sections['rollback-plan'] = { present: true };
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Testing summary
+  const hasTests = fs.existsSync(path.join(root, 'tests')) || fs.existsSync(path.join(root, 'test'));
+  summary.sections['testing-summary'] = { present: hasTests };
+
+  // Approval status
+  const approvalFile = path.join(root, '.jumpstart', 'state', 'role-approvals.json');
+  if (fs.existsSync(approvalFile)) {
+    try {
+      const approvals = JSON.parse(fs.readFileSync(approvalFile, 'utf8'));
+      const workflows = Object.values(approvals.workflows || {});
+      const approved = workflows.filter(w => w.status === 'approved').length;
+      summary.sections['approval-status'] = { present: true, total: workflows.length, approved };
+    } catch { summary.sections['approval-status'] = { present: false }; }
+  } else {
+    summary.sections['approval-status'] = { present: false };
+  }
+
+  // Implementation schedule
+  const planFile = path.join(root, 'specs', 'implementation-plan.md');
+  summary.sections['implementation-schedule'] = { present: fs.existsSync(planFile) };
+
+  // Communication plan
+  summary.sections['communication-plan'] = { present: false, recommendation: 'Add communication plan' };
+
+  const presentSections = Object.values(summary.sections).filter(s => s.present).length;
+  const completeness = Math.round((presentSections / CAB_SECTIONS.length) * 100);
+
+  const riskLevel = summary.sections['risk-assessment'] && summary.sections['risk-assessment'].high_risks > 0
+    ? 'high' : completeness >= 70 ? 'standard' : 'elevated';
+
+  return {
+    success: true,
+    cab_id: summary.id,
+    completeness,
+    risk_level: riskLevel,
+    recommendation: completeness >= 80 ? 'Ready for CAB review' : 'Additional documentation needed',
+    sections: summary.sections,
+    gaps: CAB_SECTIONS.filter(s => !summary.sections[s] || !summary.sections[s].present)
+  };
+}
+
+module.exports = {
+  generateCABSummary,
+  CAB_SECTIONS
+};

package/bin/lib/chat-integration.js

@@ -0,0 +1,122 @@
+/**
+ * chat-integration.js — Slack and Teams Integration (Item 75)
+ *
+ * Notify on approvals, risks, drift, and blockers;
+ * accept structured approvals from chat.
+ *
+ * Usage:
+ *   node bin/lib/chat-integration.js configure|notify|status [options]
+ *
+ * State file: .jumpstart/state/chat-integration.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'chat-integration.json');
+
+const PLATFORMS = ['slack', 'teams'];
+const EVENT_TYPES = ['approval', 'risk', 'drift', 'blocker', 'phase_change', 'comment'];
+
+function defaultState() {
+  return {
+    version: '1.0.0',
+    configurations: [],
+    notifications: [],
+    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');
+}
+
+/**
+ * Configure a chat integration.
+ */
+function configure(platform, options = {}) {
+  if (!PLATFORMS.includes(platform)) {
+    return { success: false, error: `Unknown platform: ${platform}. Valid: ${PLATFORMS.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const config = {
+    id: `CHAT-${Date.now()}`,
+    platform,
+    channel: options.channel || 'general',
+    webhook_url: options.webhook_url || null,
+    events: options.events || EVENT_TYPES,
+    enabled: true,
+    configured_at: new Date().toISOString()
+  };
+
+  state.configurations.push(config);
+  saveState(state, stateFile);
+
+  return { success: true, configuration: config };
+}
+
+/**
+ * Queue a notification.
+ */
+function queueNotification(eventType, message, options = {}) {
+  if (!EVENT_TYPES.includes(eventType)) {
+    return { success: false, error: `Unknown event type: ${eventType}. Valid: ${EVENT_TYPES.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const notification = {
+    id: `NOTIF-${Date.now()}`,
+    event_type: eventType,
+    message,
+    platform: options.platform || 'all',
+    status: 'queued',
+    created_at: new Date().toISOString(),
+    sent_at: null
+  };
+
+  state.notifications.push(notification);
+  saveState(state, stateFile);
+
+  return { success: true, notification };
+}
+
+/**
+ * Get integration status.
+ */
+function getStatus(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    configurations: state.configurations.length,
+    active: state.configurations.filter(c => c.enabled).length,
+    notifications_queued: state.notifications.filter(n => n.status === 'queued').length,
+    notifications_sent: state.notifications.filter(n => n.status === 'sent').length,
+    platforms: state.configurations.map(c => c.platform)
+  };
+}
+
+module.exports = {
+  configure, queueNotification, getStatus,
+  loadState, saveState, defaultState,
+  PLATFORMS, EVENT_TYPES
+};

package/bin/lib/ci-cd-integration.js

@@ -0,0 +1,208 @@
+/**
+ * ci-cd-integration.js — GitHub Actions & Azure DevOps Deep Integration (Item 21)
+ *
+ * Trigger validation, drift checks, reviews, and approvals
+ * automatically in CI/CD pipelines.
+ *
+ * Usage:
+ *   node bin/lib/ci-cd-integration.js generate|validate|status [options]
+ *
+ * State file: .jumpstart/state/ci-cd-integration.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'ci-cd-integration.json');
+
+const SUPPORTED_PLATFORMS = ['github-actions', 'azure-devops'];
+
+const PIPELINE_STAGES = ['validate', 'drift-check', 'review', 'approve', 'promote'];
+
+const BUILT_IN_CHECKS = [
+  { id: 'schema-validation', name: 'Schema Validation', stage: 'validate', command: 'jumpstart-mode validate-all' },
+  { id: 'spec-drift', name: 'Spec Drift Detection', stage: 'drift-check', command: 'jumpstart-mode spec-drift' },
+  { id: 'coverage-check', name: 'Story-to-Task Coverage', stage: 'validate', command: 'jumpstart-mode coverage' },
+  { id: 'secret-scan', name: 'Secret Scanning', stage: 'validate', command: 'jumpstart-mode scan-secrets' },
+  { id: 'freshness-audit', name: 'Documentation Freshness', stage: 'review', command: 'jumpstart-mode freshness-audit' },
+  { id: 'policy-check', name: 'Policy Compliance', stage: 'review', command: 'jumpstart-mode policy check' },
+  { id: 'quality-gate', name: 'Quality Gate', stage: 'approve', command: 'npm test' }
+];
+
+/**
+ * Default CI/CD integration state.
+ * @returns {object}
+ */
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    platform: null,
+    pipelines: [],
+    run_history: []
+  };
+}
+
+/**
+ * Load state from disk.
+ * @param {string} [stateFile]
+ * @returns {object}
+ */
+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(); }
+}
+
+/**
+ * Save state to disk.
+ * @param {object} state
+ * @param {string} [stateFile]
+ */
+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');
+}
+
+/**
+ * Generate a CI/CD pipeline configuration.
+ *
+ * @param {string} platform - 'github-actions' or 'azure-devops'
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generatePipeline(platform, options = {}) {
+  if (!SUPPORTED_PLATFORMS.includes(platform)) {
+    return { success: false, error: `Unsupported platform: ${platform}. Use: ${SUPPORTED_PLATFORMS.join(', ')}` };
+  }
+
+  const checks = options.checks || BUILT_IN_CHECKS;
+  const stages = options.stages || PIPELINE_STAGES;
+
+  if (platform === 'github-actions') {
+    const workflow = {
+      name: 'JumpStart Quality Gate',
+      on: {
+        pull_request: { paths: ['specs/**', '.jumpstart/**', 'src/**', 'tests/**'] },
+        push: { branches: ['main'], paths: ['specs/**', '.jumpstart/**'] }
+      },
+      jobs: {}
+    };
+
+    for (const stage of stages) {
+      const stageChecks = checks.filter(c => c.stage === stage);
+      if (stageChecks.length === 0) continue;
+      workflow.jobs[stage] = {
+        'runs-on': 'ubuntu-latest',
+        steps: [
+          { uses: 'actions/checkout@v4' },
+          { uses: 'actions/setup-node@v4', with: { 'node-version': '20' } },
+          { run: 'npm ci' },
+          ...stageChecks.map(c => ({ name: c.name, run: `npx ${c.command}` }))
+        ]
+      };
+    }
+
+    return { success: true, platform, format: 'yaml', content: workflow, path: '.github/workflows/jumpstart-quality.yml' };
+  }
+
+  if (platform === 'azure-devops') {
+    const pipeline = {
+      trigger: { branches: { include: ['main'] }, paths: { include: ['specs/*', '.jumpstart/*'] } },
+      pool: { vmImage: 'ubuntu-latest' },
+      stages: stages.map(stage => ({
+        stage,
+        displayName: stage.charAt(0).toUpperCase() + stage.slice(1),
+        jobs: [{
+          job: `${stage}_checks`,
+          steps: [
+            { task: 'NodeTool@0', inputs: { versionSpec: '20.x' } },
+            { script: 'npm ci', displayName: 'Install dependencies' },
+            ...checks.filter(c => c.stage === stage).map(c => ({
+              script: `npx ${c.command}`,
+              displayName: c.name
+            }))
+          ]
+        }]
+      }))
+    };
+
+    return { success: true, platform, format: 'yaml', content: pipeline, path: 'azure-pipelines.yml' };
+  }
+
+  return { success: false, error: 'Unknown platform' };
+}
+
+/**
+ * Validate that pipeline configuration is up to date.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function validatePipeline(root, options = {}) {
+  const results = [];
+
+  for (const platform of SUPPORTED_PLATFORMS) {
+    const generated = generatePipeline(platform, options);
+    if (!generated.success) continue;
+
+    const pipelinePath = path.join(root, generated.path);
+    const exists = fs.existsSync(pipelinePath);
+
+    results.push({
+      platform,
+      path: generated.path,
+      exists,
+      up_to_date: exists,
+      expected_checks: (options.checks || BUILT_IN_CHECKS).length
+    });
+  }
+
+  return {
+    success: true,
+    pipelines: results,
+    all_configured: results.some(r => r.exists),
+    recommendations: results.filter(r => !r.exists).map(r => `Configure ${r.platform} pipeline at ${r.path}`)
+  };
+}
+
+/**
+ * Get integration status summary.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function getStatus(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    platform: state.platform,
+    pipelines: state.pipelines.length,
+    last_run: state.run_history.length > 0 ? state.run_history[state.run_history.length - 1] : null,
+    total_runs: state.run_history.length,
+    available_checks: BUILT_IN_CHECKS.length
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  generatePipeline,
+  validatePipeline,
+  getStatus,
+  SUPPORTED_PLATFORMS,
+  PIPELINE_STAGES,
+  BUILT_IN_CHECKS
+};

package/bin/lib/codebase-retrieval.js

@@ -0,0 +1,125 @@
+/**
+ * codebase-retrieval.js — Codebase-Native Retrieval Layer (Item 41)
+ *
+ * Retrieve the right files, ADRs, test patterns, and prior
+ * implementations automatically during execution.
+ *
+ * Usage:
+ *   node bin/lib/codebase-retrieval.js query|index|status [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const RETRIEVABLE_TYPES = ['adrs', 'test-patterns', 'implementations', 'specs', 'configs'];
+
+const FILE_PATTERNS = {
+  adrs: ['specs/decisions/*.md', 'docs/decisions/*.md', 'adr/*.md'],
+  'test-patterns': ['tests/**/*.test.*', 'test/**/*.test.*', '__tests__/**/*'],
+  specs: ['specs/*.md', 'docs/*.md'],
+  configs: ['.jumpstart/*.yaml', '.jumpstart/*.json', 'package.json', 'tsconfig.json']
+};
+
+/**
+ * Index project files by type.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function indexProject(root, options = {}) {
+  const index = {};
+  const excludeDirs = options.excludeDirs || ['node_modules', '.git', 'dist', 'build'];
+
+  function walk(dir, relDir) {
+    if (!fs.existsSync(dir)) return [];
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const rel = path.join(relDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!excludeDirs.includes(entry.name)) {
+          results.push(...walk(path.join(dir, entry.name), rel));
+        }
+      } else if (entry.isFile()) {
+        results.push(rel.replace(/\\/g, '/'));
+      }
+    }
+    return results;
+  }
+
+  const allFiles = walk(root, '');
+
+  // Categorize files
+  index.adrs = allFiles.filter(f => /specs\/decisions\/|docs\/decisions\/|^adr\//i.test(f) && f.endsWith('.md'));
+  index['test-patterns'] = allFiles.filter(f => /\.test\.|\.spec\.|__tests__/i.test(f));
+  index.specs = allFiles.filter(f => /^specs\/.*\.md$/i.test(f));
+  index.configs = allFiles.filter(f => /package\.json$|tsconfig|\.jumpstart\//i.test(f));
+  index.implementations = allFiles.filter(f => /^src\//i.test(f));
+
+  return {
+    success: true,
+    total_files: allFiles.length,
+    indexed: Object.entries(index).reduce((sum, [, files]) => sum + files.length, 0),
+    categories: Object.entries(index).map(([type, files]) => ({ type, count: files.length })),
+    index
+  };
+}
+
+/**
+ * Query for relevant files based on context.
+ *
+ * @param {string} root - Project root.
+ * @param {string} query - Search query.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function queryFiles(root, query, options = {}) {
+  if (!query) return { success: false, error: 'query is required' };
+
+  const idx = indexProject(root, options);
+  const queryLower = query.toLowerCase();
+  const results = [];
+
+  // Search through all indexed files
+  for (const [type, files] of Object.entries(idx.index)) {
+    for (const file of files) {
+      const absPath = path.join(root, file);
+      try {
+        const content = fs.readFileSync(absPath, 'utf8');
+        if (content.toLowerCase().includes(queryLower) || file.toLowerCase().includes(queryLower)) {
+          const lines = content.split('\n');
+          const matchingLines = lines
+            .map((line, i) => ({ line: i + 1, content: line }))
+            .filter(l => l.content.toLowerCase().includes(queryLower))
+            .slice(0, 5);
+
+          results.push({
+            file,
+            type,
+            matches: matchingLines.length,
+            preview: matchingLines
+          });
+        }
+      } catch { /* skip */ }
+    }
+  }
+
+  // Sort by match count
+  results.sort((a, b) => b.matches - a.matches);
+
+  return {
+    success: true,
+    query,
+    total_results: results.length,
+    results: results.slice(0, options.limit || 20)
+  };
+}
+
+module.exports = {
+  indexProject,
+  queryFiles,
+  RETRIEVABLE_TYPES,
+  FILE_PATTERNS
+};