jumpstart-mode 1.1.12 → 1.1.13

package/bin/lib/parallel-agents.js

@@ -0,0 +1,257 @@
+/**
+ * parallel-agents.js — Multi-Agent Concurrent Execution
+ *
+ * Orchestrates architect, security, QA, docs, and performance sidecars
+ * running in parallel against the same spec set, then reconciles conflicts.
+ *
+ * Usage:
+ *   node bin/lib/parallel-agents.js run|status|reconcile [options]
+ *
+ * State file: .jumpstart/state/parallel-agents.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'parallel-agents.json');
+
+const SIDECAR_AGENTS = ['architect', 'security', 'qa', 'docs', 'performance'];
+
+/**
+ * Default parallel agents run state.
+ * @returns {object}
+ */
+function defaultParallelState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    runs: []
+  };
+}
+
+/**
+ * Load parallel agents state from disk.
+ * @param {string} [stateFile]
+ * @returns {object}
+ */
+function loadParallelState(stateFile) {
+  const filePath = stateFile || DEFAULT_STATE_FILE;
+  if (!fs.existsSync(filePath)) {
+    return defaultParallelState();
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return defaultParallelState();
+  }
+}
+
+/**
+ * Save parallel agents state to disk.
+ * @param {object} state
+ * @param {string} [stateFile]
+ */
+function saveParallelState(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');
+}
+
+/**
+ * Schedule a new parallel agent run.
+ *
+ * @param {string[]} agents - Subset of SIDECAR_AGENTS to run. Defaults to all.
+ * @param {object} context - Shared context (phase, specFiles, root).
+ * @param {object} [options]
+ * @returns {object}
+ */
+function scheduleRun(agents, context, options = {}) {
+  const agentList = (agents && agents.length > 0)
+    ? agents.filter(a => SIDECAR_AGENTS.includes(a))
+    : [...SIDECAR_AGENTS];
+
+  if (agentList.length === 0) {
+    return { success: false, error: `No valid agents specified. Valid: ${SIDECAR_AGENTS.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadParallelState(stateFile);
+
+  const runId = `run-${Date.now()}`;
+  const run = {
+    id: runId,
+    scheduled_at: new Date().toISOString(),
+    context: context || {},
+    agents: agentList.map(name => ({
+      name,
+      status: 'pending',    // pending | running | completed | failed
+      started_at: null,
+      completed_at: null,
+      findings: [],
+      errors: []
+    })),
+    reconciliation: null,
+    status: 'pending'
+  };
+
+  state.runs.push(run);
+  saveParallelState(state, stateFile);
+
+  return { success: true, run_id: runId, agents: agentList };
+}
+
+/**
+ * Record findings from a sidecar agent.
+ *
+ * @param {string} runId
+ * @param {string} agentName
+ * @param {object[]} findings - Array of { type, message, severity, file? }.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function recordAgentFindings(runId, agentName, findings, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadParallelState(stateFile);
+
+  const run = state.runs.find(r => r.id === runId);
+  if (!run) {
+    return { success: false, error: `Run not found: ${runId}` };
+  }
+
+  const agent = run.agents.find(a => a.name === agentName);
+  if (!agent) {
+    return { success: false, error: `Agent not found: ${agentName}` };
+  }
+
+  agent.findings = findings || [];
+  agent.status = 'completed';
+  agent.completed_at = new Date().toISOString();
+
+  // Update overall run status
+  const allDone = run.agents.every(a => a.status === 'completed' || a.status === 'failed');
+  if (allDone) {
+    run.status = 'completed';
+  }
+
+  saveParallelState(state, stateFile);
+
+  return { success: true, run_id: runId, agent: agentName, findings_count: findings.length };
+}
+
+/**
+ * Reconcile findings from all agents in a run — merge and de-duplicate conflicts.
+ *
+ * @param {string} runId
+ * @param {object} [options]
+ * @returns {object} Reconciliation result with merged findings and conflicts.
+ */
+function reconcileRun(runId, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadParallelState(stateFile);
+
+  const run = state.runs.find(r => r.id === runId);
+  if (!run) {
+    return { success: false, error: `Run not found: ${runId}` };
+  }
+
+  const allFindings = [];
+  for (const agent of run.agents) {
+    for (const finding of agent.findings || []) {
+      allFindings.push({ ...finding, agent: agent.name });
+    }
+  }
+
+  // Detect conflicts: same file+type from different agents with different severities
+  const conflicts = [];
+  const seen = {};
+  for (const f of allFindings) {
+    const key = `${f.file || ''}:${f.type || ''}`;
+    if (seen[key] && seen[key].severity !== f.severity) {
+      conflicts.push({
+        key,
+        agents: [seen[key].agent, f.agent],
+        severities: [seen[key].severity, f.severity],
+        message: `Conflict: ${f.type} severity disagrees between ${seen[key].agent} and ${f.agent}`
+      });
+    } else {
+      seen[key] = f;
+    }
+  }
+
+  const reconciliation = {
+    reconciled_at: new Date().toISOString(),
+    total_findings: allFindings.length,
+    conflicts: conflicts.length,
+    conflict_list: conflicts,
+    merged_findings: allFindings
+  };
+
+  run.reconciliation = reconciliation;
+  saveParallelState(state, stateFile);
+
+  return { success: true, run_id: runId, reconciliation };
+}
+
+/**
+ * Get the status of a run.
+ *
+ * @param {string} runId
+ * @param {object} [options]
+ * @returns {object}
+ */
+function getRunStatus(runId, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadParallelState(stateFile);
+
+  const run = state.runs.find(r => r.id === runId);
+  if (!run) {
+    return { success: false, error: `Run not found: ${runId}` };
+  }
+
+  return {
+    success: true,
+    run_id: runId,
+    status: run.status,
+    agents: run.agents.map(a => ({ name: a.name, status: a.status, findings: a.findings.length })),
+    reconciliation: run.reconciliation
+  };
+}
+
+/**
+ * List all runs.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function listRuns(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadParallelState(stateFile);
+
+  const runs = state.runs.map(r => ({
+    id: r.id,
+    status: r.status,
+    scheduled_at: r.scheduled_at,
+    agent_count: r.agents.length
+  }));
+
+  return { success: true, runs, total: runs.length };
+}
+
+module.exports = {
+  SIDECAR_AGENTS,
+  loadParallelState,
+  saveParallelState,
+  defaultParallelState,
+  scheduleRun,
+  recordAgentFindings,
+  reconcileRun,
+  getRunStatus,
+  listRuns
+};

package/bin/lib/pattern-library.js

@@ -0,0 +1,115 @@
+/**
+ * pattern-library.js — Inner-Source Pattern Library (Item 82)
+ *
+ * Approved implementation examples that agents can clone, adapt, and cite.
+ *
+ * Usage:
+ *   node bin/lib/pattern-library.js register|search|get|list [options]
+ *
+ * State file: .jumpstart/state/pattern-library.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'pattern-library.json');
+
+const PATTERN_CATEGORIES = ['api', 'data-access', 'auth', 'messaging', 'testing', 'deployment', 'error-handling', 'logging'];
+
+function defaultState() {
+  return { version: '1.0.0', patterns: [], 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 registerPattern(name, category, options = {}) {
+  if (!name || !category) return { success: false, error: 'name and category are required' };
+  if (!PATTERN_CATEGORIES.includes(category)) {
+    return { success: false, error: `Unknown category: ${category}. Valid: ${PATTERN_CATEGORIES.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const pattern = {
+    id: `PAT-${Date.now()}`,
+    name,
+    category,
+    description: options.description || '',
+    language: options.language || 'javascript',
+    code: options.code || '',
+    tags: options.tags || [],
+    approved: options.approved || false,
+    created_at: new Date().toISOString()
+  };
+
+  state.patterns.push(pattern);
+  saveState(state, stateFile);
+
+  return { success: true, pattern };
+}
+
+function searchPatterns(query, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const q = (query || '').toLowerCase();
+  let results = state.patterns;
+
+  if (q) {
+    results = results.filter(p =>
+      p.name.toLowerCase().includes(q) ||
+      p.description.toLowerCase().includes(q) ||
+      p.tags.some(t => t.toLowerCase().includes(q))
+    );
+  }
+
+  if (options.category) {
+    results = results.filter(p => p.category === options.category);
+  }
+
+  return { success: true, total: results.length, patterns: results };
+}
+
+function getPattern(patternId, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const pattern = state.patterns.find(p => p.id === patternId);
+  if (!pattern) return { success: false, error: `Pattern ${patternId} not found` };
+
+  return { success: true, pattern };
+}
+
+function listPatterns(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    total: state.patterns.length,
+    categories: PATTERN_CATEGORIES,
+    patterns: state.patterns.map(p => ({ id: p.id, name: p.name, category: p.category, approved: p.approved }))
+  };
+}
+
+module.exports = {
+  registerPattern, searchPatterns, getPattern, listPatterns,
+  loadState, saveState, defaultState,
+  PATTERN_CATEGORIES
+};

package/bin/lib/persona-packs.js

@@ -0,0 +1,99 @@
+/**
+ * persona-packs.js — Persona Packs for Enterprise Roles (Item 80)
+ *
+ * Business analyst, product owner, architect, security lead,
+ * platform engineer, SRE, data steward persona definitions.
+ *
+ * Usage:
+ *   node bin/lib/persona-packs.js list|get|apply [options]
+ */
+
+'use strict';
+
+const PERSONA_CATALOG = {
+  'business-analyst': {
+    label: 'Business Analyst',
+    focus: ['requirements', 'process-modeling', 'stakeholder-management', 'data-analysis'],
+    artifacts: ['product-brief', 'prd', 'process-maps'],
+    tools: ['elicitation', 'estimation', 'ambiguity-heatmap']
+  },
+  'product-owner': {
+    label: 'Product Owner',
+    focus: ['backlog', 'prioritization', 'user-stories', 'acceptance-criteria'],
+    artifacts: ['prd', 'product-brief', 'backlog'],
+    tools: ['estimation', 'playback-summaries', 'handoff']
+  },
+  'architect': {
+    label: 'Architect',
+    focus: ['system-design', 'tech-stack', 'nfrs', 'data-modeling'],
+    artifacts: ['architecture', 'decisions', 'diagrams'],
+    tools: ['diagram-studio', 'reference-arch', 'fitness-functions']
+  },
+  'security-lead': {
+    label: 'Security Lead',
+    focus: ['threat-modeling', 'compliance', 'access-control', 'data-protection'],
+    artifacts: ['security-review', 'compliance-report', 'threat-model'],
+    tools: ['credential-boundary', 'data-classification', 'compliance-packs']
+  },
+  'platform-engineer': {
+    label: 'Platform Engineer',
+    focus: ['infrastructure', 'ci-cd', 'golden-paths', 'developer-experience'],
+    artifacts: ['deployment-guide', 'platform-config', 'runbooks'],
+    tools: ['ci-cd-integration', 'env-promotion', 'platform-engineering']
+  },
+  'sre': {
+    label: 'Site Reliability Engineer',
+    focus: ['monitoring', 'incident-response', 'sla-slo', 'capacity-planning'],
+    artifacts: ['runbooks', 'sla-report', 'incident-log'],
+    tools: ['sla-slo', 'incident-feedback', 'ops-ownership']
+  },
+  'data-steward': {
+    label: 'Data Steward',
+    focus: ['data-governance', 'data-quality', 'lineage', 'classification'],
+    artifacts: ['data-catalog', 'classification-report', 'lineage-map'],
+    tools: ['data-classification', 'data-contracts', 'domain-ontology']
+  }
+};
+
+const PERSONAS = Object.keys(PERSONA_CATALOG);
+
+function listPersonas() {
+  return {
+    success: true,
+    personas: PERSONAS.map(p => ({
+      id: p,
+      label: PERSONA_CATALOG[p].label,
+      focus_count: PERSONA_CATALOG[p].focus.length,
+      tools_count: PERSONA_CATALOG[p].tools.length
+    }))
+  };
+}
+
+function getPersona(personaId) {
+  if (!PERSONA_CATALOG[personaId]) {
+    return { success: false, error: `Unknown persona: ${personaId}. Valid: ${PERSONAS.join(', ')}` };
+  }
+  return { success: true, persona: { id: personaId, ...PERSONA_CATALOG[personaId] } };
+}
+
+function applyPersona(personaId, options = {}) {
+  if (!PERSONA_CATALOG[personaId]) {
+    return { success: false, error: `Unknown persona: ${personaId}` };
+  }
+
+  const persona = PERSONA_CATALOG[personaId];
+  return {
+    success: true,
+    persona_id: personaId,
+    label: persona.label,
+    recommended_tools: persona.tools,
+    relevant_artifacts: persona.artifacts,
+    focus_areas: persona.focus,
+    applied_at: new Date().toISOString()
+  };
+}
+
+module.exports = {
+  listPersonas, getPersona, applyPersona,
+  PERSONAS, PERSONA_CATALOG
+};