jumpstart-mode 1.1.11 → 1.1.13

package/bin/lib/collaboration.js

@@ -0,0 +1,168 @@
+/**
+ * collaboration.js — Real-Time Collaboration Sessions (Item 65)
+ *
+ * Multiple humans and multiple agents working against
+ * the same initiative safely with conflict detection.
+ *
+ * Usage:
+ *   node bin/lib/collaboration.js create|join|status|lock [options]
+ *
+ * State file: .jumpstart/state/collaboration.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'collaboration.json');
+
+const PARTICIPANT_ROLES = ['owner', 'editor', 'reviewer', 'observer'];
+
+function defaultState() {
+  return {
+    version: '1.0.0',
+    sessions: [],
+    locks: [],
+    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');
+}
+
+/**
+ * Create a collaboration session.
+ */
+function createSession(name, options = {}) {
+  if (!name) return { success: false, error: 'Session name is required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const session = {
+    id: `COLLAB-${Date.now()}`,
+    name,
+    status: 'active',
+    owner: options.owner || 'system',
+    participants: [{ name: options.owner || 'system', role: 'owner', joined_at: new Date().toISOString() }],
+    artifacts: options.artifacts || [],
+    created_at: new Date().toISOString(),
+    ended_at: null
+  };
+
+  state.sessions.push(session);
+  saveState(state, stateFile);
+
+  return { success: true, session };
+}
+
+/**
+ * Join an existing session.
+ */
+function joinSession(sessionId, participant, options = {}) {
+  if (!sessionId || !participant) return { success: false, error: 'sessionId and participant name are required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const session = state.sessions.find(s => s.id === sessionId);
+  if (!session) return { success: false, error: `Session ${sessionId} not found` };
+  if (session.status !== 'active') return { success: false, error: 'Session is not active' };
+
+  const role = options.role || 'editor';
+  if (!PARTICIPANT_ROLES.includes(role)) {
+    return { success: false, error: `Invalid role. Valid: ${PARTICIPANT_ROLES.join(', ')}` };
+  }
+
+  session.participants.push({ name: participant, role, joined_at: new Date().toISOString() });
+  saveState(state, stateFile);
+
+  return { success: true, session };
+}
+
+/**
+ * Acquire a lock on an artifact.
+ */
+function acquireLock(artifact, owner, options = {}) {
+  if (!artifact || !owner) return { success: false, error: 'artifact and owner are required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const existingLock = state.locks.find(l => l.artifact === artifact && l.released_at === null);
+  if (existingLock) {
+    return { success: false, error: `Artifact ${artifact} is locked by ${existingLock.owner}` };
+  }
+
+  const lock = {
+    id: `LOCK-${Date.now()}`,
+    artifact,
+    owner,
+    acquired_at: new Date().toISOString(),
+    released_at: null
+  };
+
+  state.locks.push(lock);
+  saveState(state, stateFile);
+
+  return { success: true, lock };
+}
+
+/**
+ * Release a lock.
+ */
+function releaseLock(lockId, options = {}) {
+  if (!lockId) return { success: false, error: 'lockId is required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const lock = state.locks.find(l => l.id === lockId);
+  if (!lock) return { success: false, error: `Lock ${lockId} not found` };
+
+  lock.released_at = new Date().toISOString();
+  saveState(state, stateFile);
+
+  return { success: true, lock };
+}
+
+/**
+ * Get collaboration status.
+ */
+function getStatus(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    active_sessions: state.sessions.filter(s => s.status === 'active').length,
+    active_locks: state.locks.filter(l => l.released_at === null).length,
+    sessions: state.sessions,
+    locks: state.locks.filter(l => l.released_at === null)
+  };
+}
+
+module.exports = {
+  createSession,
+  joinSession,
+  acquireLock,
+  releaseLock,
+  getStatus,
+  loadState,
+  saveState,
+  defaultState,
+  PARTICIPANT_ROLES
+};

package/bin/lib/compliance-packs.js

@@ -0,0 +1,213 @@
+/**
+ * compliance-packs.js — Prebuilt Compliance Control Mappings (Item 24)
+ *
+ * Prebuilt control mappings for SOC 2, ISO 27001, HIPAA, PCI,
+ * FedRAMP, GDPR, EU AI Act, NIST AI RMF.
+ *
+ * Usage:
+ *   node bin/lib/compliance-packs.js list|apply|check|report [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'compliance.json');
+
+const COMPLIANCE_FRAMEWORKS = {
+  'soc2': {
+    name: 'SOC 2 Type II',
+    controls: [
+      { id: 'CC1.1', category: 'organization', description: 'Integrity and ethical values', checks: ['code-of-conduct', 'policy-engine'] },
+      { id: 'CC6.1', category: 'security', description: 'Logical and physical access controls', checks: ['secret-scan', 'auth-review'] },
+      { id: 'CC7.1', category: 'operations', description: 'System monitoring', checks: ['logging-review', 'alert-config'] },
+      { id: 'CC8.1', category: 'change-management', description: 'Change management controls', checks: ['approval-workflow', 'spec-drift'] }
+    ]
+  },
+  'iso27001': {
+    name: 'ISO 27001:2022',
+    controls: [
+      { id: 'A.5.1', category: 'policies', description: 'Information security policies', checks: ['policy-engine'] },
+      { id: 'A.8.1', category: 'asset-management', description: 'Asset inventory', checks: ['data-classification'] },
+      { id: 'A.8.9', category: 'configuration', description: 'Configuration management', checks: ['spec-drift', 'version-control'] },
+      { id: 'A.8.25', category: 'sdlc', description: 'Secure development lifecycle', checks: ['secret-scan', 'security-review'] }
+    ]
+  },
+  'hipaa': {
+    name: 'HIPAA',
+    controls: [
+      { id: '164.312(a)', category: 'access', description: 'Access control', checks: ['auth-review', 'role-approval'] },
+      { id: '164.312(c)', category: 'integrity', description: 'Data integrity', checks: ['data-classification', 'audit-trail'] },
+      { id: '164.312(e)', category: 'transmission', description: 'Transmission security', checks: ['encryption-review'] },
+      { id: '164.308(a)(1)', category: 'risk', description: 'Risk analysis', checks: ['risk-register'] }
+    ]
+  },
+  'pci': {
+    name: 'PCI DSS 4.0',
+    controls: [
+      { id: '6.2', category: 'software', description: 'Secure software development', checks: ['secret-scan', 'code-review'] },
+      { id: '6.3', category: 'vulnerabilities', description: 'Vulnerability management', checks: ['dependency-scan', 'security-review'] },
+      { id: '10.1', category: 'logging', description: 'Audit logging', checks: ['logging-review', 'audit-trail'] },
+      { id: '12.1', category: 'policy', description: 'Security policy', checks: ['policy-engine'] }
+    ]
+  },
+  'fedramp': {
+    name: 'FedRAMP',
+    controls: [
+      { id: 'AC-1', category: 'access', description: 'Access control policy', checks: ['auth-review', 'role-approval'] },
+      { id: 'CM-1', category: 'configuration', description: 'Configuration management policy', checks: ['spec-drift', 'version-control'] },
+      { id: 'RA-5', category: 'risk', description: 'Vulnerability scanning', checks: ['dependency-scan', 'secret-scan'] },
+      { id: 'SA-11', category: 'development', description: 'Developer security testing', checks: ['security-review', 'code-review'] }
+    ]
+  },
+  'gdpr': {
+    name: 'GDPR',
+    controls: [
+      { id: 'Art.25', category: 'design', description: 'Data protection by design', checks: ['data-classification', 'privacy-review'] },
+      { id: 'Art.30', category: 'records', description: 'Records of processing', checks: ['data-classification', 'audit-trail'] },
+      { id: 'Art.32', category: 'security', description: 'Security of processing', checks: ['encryption-review', 'secret-scan'] },
+      { id: 'Art.35', category: 'impact', description: 'Data protection impact assessment', checks: ['risk-register', 'privacy-review'] }
+    ]
+  },
+  'eu-ai-act': {
+    name: 'EU AI Act',
+    controls: [
+      { id: 'Art.9', category: 'risk-management', description: 'Risk management system', checks: ['risk-register', 'model-governance'] },
+      { id: 'Art.10', category: 'data-governance', description: 'Data and data governance', checks: ['data-classification', 'bias-review'] },
+      { id: 'Art.13', category: 'transparency', description: 'Transparency and information', checks: ['model-documentation'] },
+      { id: 'Art.15', category: 'accuracy', description: 'Accuracy, robustness, cybersecurity', checks: ['model-eval', 'security-review'] }
+    ]
+  },
+  'nist-ai-rmf': {
+    name: 'NIST AI RMF 1.0',
+    controls: [
+      { id: 'GOVERN-1', category: 'governance', description: 'AI risk governance', checks: ['model-governance', 'risk-register'] },
+      { id: 'MAP-1', category: 'context', description: 'Context and usage mapping', checks: ['ai-intake', 'requirements-baseline'] },
+      { id: 'MEASURE-1', category: 'measurement', description: 'AI risks measured', checks: ['model-eval', 'bias-review'] },
+      { id: 'MANAGE-1', category: 'management', description: 'AI risks managed', checks: ['risk-register', 'model-governance'] }
+    ]
+  }
+};
+
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    applied_frameworks: [],
+    check_results: []
+  };
+}
+
+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');
+}
+
+/**
+ * List available compliance frameworks.
+ * @returns {object}
+ */
+function listFrameworks() {
+  return {
+    success: true,
+    frameworks: Object.entries(COMPLIANCE_FRAMEWORKS).map(([id, fw]) => ({
+      id,
+      name: fw.name,
+      controls: fw.controls.length
+    })),
+    total: Object.keys(COMPLIANCE_FRAMEWORKS).length
+  };
+}
+
+/**
+ * Apply a compliance framework to the project.
+ *
+ * @param {string} frameworkId
+ * @param {object} [options]
+ * @returns {object}
+ */
+function applyFramework(frameworkId, options = {}) {
+  const fw = COMPLIANCE_FRAMEWORKS[frameworkId];
+  if (!fw) {
+    return { success: false, error: `Unknown framework: ${frameworkId}. Available: ${Object.keys(COMPLIANCE_FRAMEWORKS).join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  if (!state.applied_frameworks.includes(frameworkId)) {
+    state.applied_frameworks.push(frameworkId);
+  }
+
+  saveState(state, stateFile);
+
+  return {
+    success: true,
+    framework: frameworkId,
+    name: fw.name,
+    controls_added: fw.controls.length,
+    total_applied: state.applied_frameworks.length
+  };
+}
+
+/**
+ * Check compliance against applied frameworks.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function checkCompliance(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  if (state.applied_frameworks.length === 0) {
+    return { success: true, message: 'No compliance frameworks applied', compliant: true, findings: [] };
+  }
+
+  const findings = [];
+  for (const fwId of state.applied_frameworks) {
+    const fw = COMPLIANCE_FRAMEWORKS[fwId];
+    if (!fw) continue;
+    for (const control of fw.controls) {
+      findings.push({
+        framework: fwId,
+        control_id: control.id,
+        description: control.description,
+        category: control.category,
+        required_checks: control.checks,
+        status: 'needs-review'
+      });
+    }
+  }
+
+  return {
+    success: true,
+    applied_frameworks: state.applied_frameworks,
+    total_controls: findings.length,
+    findings,
+    compliant: false,
+    summary: `${findings.length} controls require review across ${state.applied_frameworks.length} framework(s)`
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  listFrameworks,
+  applyFramework,
+  checkCompliance,
+  COMPLIANCE_FRAMEWORKS
+};

package/bin/lib/context-chunker.js

@@ -0,0 +1,128 @@
+/**
+ * context-chunker.js — Implementation Chunking by Context Window (Item 53)
+ *
+ * Split large work into optimized execution packets for different models.
+ *
+ * Usage:
+ *   node bin/lib/context-chunker.js chunk|estimate|report [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MODEL_CONTEXT_LIMITS = {
+  'gpt-4': { tokens: 8192, chars: 32768 },
+  'gpt-4-turbo': { tokens: 128000, chars: 512000 },
+  'gpt-4o': { tokens: 128000, chars: 512000 },
+  'claude-3-sonnet': { tokens: 200000, chars: 800000 },
+  'claude-3-opus': { tokens: 200000, chars: 800000 },
+  'claude-3-haiku': { tokens: 200000, chars: 800000 },
+  'default': { tokens: 32000, chars: 128000 }
+};
+
+/**
+ * Estimate token count from text (rough: ~4 chars per token).
+ *
+ * @param {string} text
+ * @returns {number}
+ */
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+/**
+ * Chunk a large text into context-window-sized pieces.
+ *
+ * @param {string} content - Content to chunk.
+ * @param {object} [options] - { model?, max_tokens?, overlap? }
+ * @returns {object}
+ */
+function chunkContent(content, options = {}) {
+  const model = options.model || 'default';
+  const limits = MODEL_CONTEXT_LIMITS[model] || MODEL_CONTEXT_LIMITS.default;
+  const maxTokens = options.max_tokens || Math.floor(limits.tokens * 0.8); // 80% of limit for safety
+  const overlapTokens = options.overlap || Math.floor(maxTokens * 0.05); // 5% overlap
+
+  const maxChars = maxTokens * 4;
+  const overlapChars = overlapTokens * 4;
+
+  const chunks = [];
+  let start = 0;
+
+  while (start < content.length) {
+    let end = Math.min(start + maxChars, content.length);
+
+    // Try to break at a natural boundary
+    if (end < content.length) {
+      const lastNewline = content.lastIndexOf('\n', end);
+      if (lastNewline > start + maxChars * 0.5) end = lastNewline + 1;
+    }
+
+    chunks.push({
+      index: chunks.length,
+      start,
+      end,
+      length: end - start,
+      estimated_tokens: estimateTokens(content.substring(start, end))
+    });
+
+    start = end - overlapChars;
+    if (start >= content.length) break;
+  }
+
+  return {
+    success: true,
+    total_chars: content.length,
+    total_tokens: estimateTokens(content),
+    model,
+    max_tokens: maxTokens,
+    chunks: chunks.length,
+    chunk_details: chunks
+  };
+}
+
+/**
+ * Chunk implementation plan tasks into execution packets.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function chunkImplementationPlan(root, options = {}) {
+  const planFile = path.join(root, 'specs', 'implementation-plan.md');
+  if (!fs.existsSync(planFile)) {
+    return { success: false, error: 'Implementation plan not found at specs/implementation-plan.md' };
+  }
+
+  const content = fs.readFileSync(planFile, 'utf8');
+
+  // Split by milestone/task sections
+  const sections = content.split(/^##\s+/m).filter(Boolean);
+  const packets = sections.map((section, i) => ({
+    index: i,
+    title: section.split('\n')[0].trim(),
+    estimated_tokens: estimateTokens(section),
+    lines: section.split('\n').length
+  }));
+
+  return {
+    success: true,
+    total_sections: packets.length,
+    total_tokens: estimateTokens(content),
+    packets,
+    model_recommendations: Object.entries(MODEL_CONTEXT_LIMITS).map(([model, limits]) => ({
+      model,
+      fits_in_single_call: estimateTokens(content) <= limits.tokens * 0.8,
+      chunks_needed: Math.ceil(estimateTokens(content) / (limits.tokens * 0.8))
+    })).filter(r => r.model !== 'default')
+  };
+}
+
+module.exports = {
+  estimateTokens,
+  chunkContent,
+  chunkImplementationPlan,
+  MODEL_CONTEXT_LIMITS
+};

package/bin/lib/context-onboarding.js

@@ -0,0 +1,122 @@
+/**
+ * context-onboarding.js — Context-Aware Onboarding (Item 76)
+ *
+ * New team member enters a project and gets a curated summary,
+ * key decisions, and current risks.
+ *
+ * Usage:
+ *   node bin/lib/context-onboarding.js generate|customize [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ONBOARDING_SECTIONS = ['overview', 'architecture', 'decisions', 'risks', 'team', 'getting_started'];
+
+/**
+ * Generate onboarding package for a new team member.
+ */
+function generateOnboarding(root, options = {}) {
+  const pkg = {
+    generated_at: new Date().toISOString(),
+    role: options.role || 'engineer',
+    sections: {}
+  };
+
+  // Project overview
+  const configFile = path.join(root, '.jumpstart', 'config.yaml');
+  if (fs.existsSync(configFile)) {
+    pkg.sections.overview = { config_exists: true };
+  } else {
+    pkg.sections.overview = { config_exists: false };
+  }
+
+  // Architecture decisions
+  const decisionsDir = path.join(root, 'specs', 'decisions');
+  const decisions = [];
+  if (fs.existsSync(decisionsDir)) {
+    for (const f of fs.readdirSync(decisionsDir).filter(f => f.endsWith('.md'))) {
+      decisions.push({ file: f, name: f.replace('.md', '') });
+    }
+  }
+  pkg.sections.decisions = { total: decisions.length, files: decisions };
+
+  // Current risks
+  const riskFile = path.join(root, '.jumpstart', 'state', 'risk-register.json');
+  if (fs.existsSync(riskFile)) {
+    try {
+      const risks = JSON.parse(fs.readFileSync(riskFile, 'utf8'));
+      pkg.sections.risks = {
+        total: (risks.risks || []).length,
+        high: (risks.risks || []).filter(r => r.score >= 15).length
+      };
+    } catch { pkg.sections.risks = { total: 0, high: 0 }; }
+  } else {
+    pkg.sections.risks = { total: 0, high: 0 };
+  }
+
+  // Phase status
+  const stateFile = path.join(root, '.jumpstart', 'state', 'state.json');
+  if (fs.existsSync(stateFile)) {
+    try {
+      const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+      pkg.sections.project_status = {
+        current_phase: state.current_phase || 0,
+        current_agent: state.current_agent || null
+      };
+    } catch { pkg.sections.project_status = { current_phase: 0 }; }
+  } else {
+    pkg.sections.project_status = { current_phase: 0 };
+  }
+
+  // Available specs
+  const specsDir = path.join(root, 'specs');
+  const specs = [];
+  if (fs.existsSync(specsDir)) {
+    for (const f of fs.readdirSync(specsDir).filter(f => f.endsWith('.md'))) {
+      specs.push(f);
+    }
+  }
+  pkg.sections.specs = { total: specs.length, files: specs };
+
+  // Getting started
+  const readmeFile = path.join(root, 'README.md');
+  pkg.sections.getting_started = {
+    has_readme: fs.existsSync(readmeFile),
+    has_package_json: fs.existsSync(path.join(root, 'package.json'))
+  };
+
+  return { success: true, onboarding: pkg };
+}
+
+/**
+ * Customize onboarding for a specific role.
+ */
+function customizeForRole(onboarding, role) {
+  if (!onboarding) return { success: false, error: 'Onboarding data is required' };
+
+  const roleFocus = {
+    engineer: ['architecture', 'getting_started', 'decisions'],
+    product: ['overview', 'specs', 'risks'],
+    executive: ['overview', 'risks', 'project_status'],
+    qa: ['specs', 'getting_started', 'risks']
+  };
+
+  const focus = roleFocus[role] || roleFocus.engineer;
+  
+  return {
+    success: true,
+    role,
+    focus_areas: focus,
+    relevant_sections: Object.fromEntries(
+      Object.entries(onboarding.sections || {}).filter(([k]) => focus.includes(k))
+    )
+  };
+}
+
+module.exports = {
+  generateOnboarding, customizeForRole,
+  ONBOARDING_SECTIONS
+};