jumpstart-mode 1.1.11 → 1.1.13

package/bin/lib/pr-package.js

@@ -0,0 +1,197 @@
+/**
+ * pr-package.js — PR-Native Execution Mode
+ *
+ * Creates PR-ready work packages with summary, risk notes, test evidence,
+ * and rollback guidance — ready to attach to a pull request.
+ *
+ * Usage:
+ *   node bin/lib/pr-package.js create|export [options]
+ *
+ * Output file: .jumpstart/pr-packages/<id>.md
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_OUTPUT_DIR = path.join('.jumpstart', 'pr-packages');
+
+/**
+ * Gather test evidence by scanning test results files.
+ *
+ * @param {string} root
+ * @returns {string[]} Evidence snippets.
+ */
+function gatherTestEvidence(root) {
+  const evidence = [];
+  const candidatePaths = [
+    path.join(root, 'test-results.json'),
+    path.join(root, 'coverage', 'summary.json'),
+    path.join(root, '.vitest', 'results.json')
+  ];
+
+  for (const p of candidatePaths) {
+    if (fs.existsSync(p)) {
+      try {
+        const data = JSON.parse(fs.readFileSync(p, 'utf8'));
+        evidence.push(`Test results from ${path.relative(root, p)}: ${JSON.stringify(data).slice(0, 200)}`);
+      } catch {
+        evidence.push(`Test results found at: ${path.relative(root, p)}`);
+      }
+    }
+  }
+
+  return evidence;
+}
+
+/**
+ * Create a PR work package.
+ *
+ * @param {object} pkg - Work package definition.
+ *   pkg.title         - PR title.
+ *   pkg.summary       - Plain-English summary of changes.
+ *   pkg.changes       - Array of changed files or descriptions.
+ *   pkg.risk_notes    - Risk notes (string or array).
+ *   pkg.test_evidence - Optional test evidence (string or array).
+ *   pkg.rollback      - Rollback guidance string.
+ *   pkg.linked_stories - Array of story/task IDs.
+ * @param {string} root
+ * @param {object} [options]
+ * @returns {object}
+ */
+function createPRPackage(pkg, root, options = {}) {
+  if (!pkg || !pkg.title || !pkg.summary) {
+    return { success: false, error: 'pkg.title and pkg.summary are required' };
+  }
+
+  const id = `pr-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+  const outputDir = options.outputDir || path.join(root, DEFAULT_OUTPUT_DIR);
+  const outputFile = path.join(outputDir, `${id}.md`);
+
+  // Gather auto-detected test evidence if none provided
+  let testEvidence = pkg.test_evidence || [];
+  if (typeof testEvidence === 'string') testEvidence = [testEvidence];
+  if (testEvidence.length === 0) {
+    testEvidence = gatherTestEvidence(root);
+  }
+
+  const changes = Array.isArray(pkg.changes) ? pkg.changes : [pkg.changes || ''].filter(Boolean);
+  const riskNotes = Array.isArray(pkg.risk_notes) ? pkg.risk_notes : [pkg.risk_notes || 'None identified'].filter(Boolean);
+  const linkedStories = Array.isArray(pkg.linked_stories) ? pkg.linked_stories : [];
+
+  const now = new Date().toISOString();
+
+  const lines = [
+    `# PR Work Package: ${pkg.title}`,
+    '',
+    `**ID:** ${id}`,
+    `**Created:** ${now}`,
+    '',
+    '## Summary',
+    '',
+    pkg.summary,
+    '',
+    '## Changes',
+    '',
+    ...changes.map(c => `- ${c}`),
+    '',
+    '## Linked Stories / Tasks',
+    '',
+    linkedStories.length > 0 ? linkedStories.map(s => `- ${s}`).join('\n') : '- None specified',
+    '',
+    '## Risk Notes',
+    '',
+    ...riskNotes.map(r => `- ${r}`),
+    '',
+    '## Test Evidence',
+    '',
+    testEvidence.length > 0
+      ? testEvidence.map(e => `- ${e}`).join('\n')
+      : '- No automated test results found. Run tests before merging.',
+    '',
+    '## Rollback Guidance',
+    '',
+    pkg.rollback || 'No specific rollback steps documented. Revert the PR commits.',
+    '',
+    '---',
+    '',
+    `*Generated by JumpStart PR-Native Execution Mode*`
+  ];
+
+  const content = lines.join('\n');
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(outputFile, content, 'utf8');
+
+  return {
+    success: true,
+    id,
+    output_file: outputFile,
+    title: pkg.title,
+    changes_count: changes.length,
+    risk_count: riskNotes.length,
+    has_test_evidence: testEvidence.length > 0
+  };
+}
+
+/**
+ * List all existing PR packages.
+ *
+ * @param {string} root
+ * @param {object} [options]
+ * @returns {object}
+ */
+function listPRPackages(root, options = {}) {
+  const outputDir = options.outputDir || path.join(root, DEFAULT_OUTPUT_DIR);
+
+  if (!fs.existsSync(outputDir)) {
+    return { success: true, packages: [], total: 0 };
+  }
+
+  const files = fs.readdirSync(outputDir)
+    .filter(f => f.endsWith('.md'))
+    .map(f => {
+      const filePath = path.join(outputDir, f);
+      const stat = fs.statSync(filePath);
+      return {
+        id: path.basename(f, '.md'),
+        file: path.relative(root, filePath).replace(/\\/g, '/'),
+        created_at: stat.birthtime.toISOString(),
+        size_bytes: stat.size
+      };
+    })
+    .sort((a, b) => b.created_at.localeCompare(a.created_at));
+
+  return { success: true, packages: files, total: files.length };
+}
+
+/**
+ * Export a PR package as a string (for copying into PR description).
+ *
+ * @param {string} packageId
+ * @param {string} root
+ * @param {object} [options]
+ * @returns {object}
+ */
+function exportPRPackage(packageId, root, options = {}) {
+  const outputDir = options.outputDir || path.join(root, DEFAULT_OUTPUT_DIR);
+  const filePath = path.join(outputDir, `${packageId}.md`);
+
+  if (!fs.existsSync(filePath)) {
+    return { success: false, error: `PR package not found: ${packageId}` };
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  return { success: true, id: packageId, content };
+}
+
+module.exports = {
+  createPRPackage,
+  listPRPackages,
+  exportPRPackage,
+  gatherTestEvidence
+};

package/bin/lib/project-memory.js

@@ -0,0 +1,235 @@
+/**
+ * project-memory.js — Persistent Long-Term Project Memory
+ *
+ * Captures team decisions, rejected options, recurring pitfalls, and
+ * tribal knowledge beyond artifact files. Acts as an ever-growing
+ * organizational knowledge base for the project.
+ *
+ * Usage:
+ *   node bin/lib/project-memory.js add|list|search|recall [options]
+ *
+ * State file: .jumpstart/state/project-memory.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_MEMORY_FILE = path.join('.jumpstart', 'state', 'project-memory.json');
+
+const MEMORY_TYPES = ['decision', 'rejection', 'pitfall', 'tribal', 'insight', 'other'];
+
+/**
+ * Default memory store structure.
+ * @returns {object}
+ */
+function defaultMemoryStore() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    entries: []
+  };
+}
+
+/**
+ * Load the memory store from disk.
+ * @param {string} [memoryFile]
+ * @returns {object}
+ */
+function loadMemoryStore(memoryFile) {
+  const filePath = memoryFile || DEFAULT_MEMORY_FILE;
+  if (!fs.existsSync(filePath)) {
+    return defaultMemoryStore();
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return defaultMemoryStore();
+  }
+}
+
+/**
+ * Save the memory store to disk.
+ * @param {object} store
+ * @param {string} [memoryFile]
+ */
+function saveMemoryStore(store, memoryFile) {
+  const filePath = memoryFile || DEFAULT_MEMORY_FILE;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  store.last_updated = new Date().toISOString();
+  fs.writeFileSync(filePath, JSON.stringify(store, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Add a new memory entry to the store.
+ *
+ * @param {object} entry - { type, title, content, tags?, author?, phase? }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function addMemory(entry, options = {}) {
+  if (!entry || !entry.title || !entry.content) {
+    return { success: false, error: 'entry.title and entry.content are required' };
+  }
+
+  const type = (entry.type || 'other').toLowerCase();
+  if (!MEMORY_TYPES.includes(type)) {
+    return { success: false, error: `type must be one of: ${MEMORY_TYPES.join(', ')}` };
+  }
+
+  const memoryFile = options.memoryFile || DEFAULT_MEMORY_FILE;
+  const store = loadMemoryStore(memoryFile);
+
+  const id = `mem-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+  const newEntry = {
+    id,
+    type,
+    title: entry.title.trim(),
+    content: entry.content.trim(),
+    tags: Array.isArray(entry.tags) ? entry.tags : [],
+    author: entry.author || null,
+    phase: entry.phase !== undefined ? entry.phase : null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString()
+  };
+
+  store.entries.push(newEntry);
+  saveMemoryStore(store, memoryFile);
+
+  return { success: true, entry: newEntry, total: store.entries.length };
+}
+
+/**
+ * List memory entries, optionally filtered.
+ *
+ * @param {object} [filter] - { type?, tag?, phase? }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function listMemories(filter = {}, options = {}) {
+  const memoryFile = options.memoryFile || DEFAULT_MEMORY_FILE;
+  const store = loadMemoryStore(memoryFile);
+
+  let entries = store.entries;
+
+  if (filter.type) {
+    entries = entries.filter(e => e.type === filter.type);
+  }
+
+  if (filter.tag) {
+    entries = entries.filter(e => e.tags && e.tags.includes(filter.tag));
+  }
+
+  if (filter.phase !== undefined && filter.phase !== null) {
+    entries = entries.filter(e => e.phase === filter.phase);
+  }
+
+  return { success: true, entries, total: entries.length };
+}
+
+/**
+ * Search memory entries by keyword in title or content.
+ *
+ * @param {string} keyword
+ * @param {object} [options]
+ * @returns {object}
+ */
+function searchMemories(keyword, options = {}) {
+  if (!keyword || typeof keyword !== 'string') {
+    return { success: false, error: 'keyword is required' };
+  }
+
+  const memoryFile = options.memoryFile || DEFAULT_MEMORY_FILE;
+  const store = loadMemoryStore(memoryFile);
+
+  const lower = keyword.toLowerCase();
+  const entries = store.entries.filter(
+    e =>
+      e.title.toLowerCase().includes(lower) ||
+      e.content.toLowerCase().includes(lower) ||
+      (e.tags && e.tags.some(t => t.toLowerCase().includes(lower)))
+  );
+
+  return { success: true, keyword, entries, total: entries.length };
+}
+
+/**
+ * Recall (get) a specific memory entry by ID.
+ *
+ * @param {string} id
+ * @param {object} [options]
+ * @returns {object}
+ */
+function recallMemory(id, options = {}) {
+  const memoryFile = options.memoryFile || DEFAULT_MEMORY_FILE;
+  const store = loadMemoryStore(memoryFile);
+
+  const entry = store.entries.find(e => e.id === id);
+  if (!entry) {
+    return { success: false, error: `Memory entry not found: ${id}` };
+  }
+
+  return { success: true, entry };
+}
+
+/**
+ * Delete a memory entry by ID.
+ *
+ * @param {string} id
+ * @param {object} [options]
+ * @returns {object}
+ */
+function deleteMemory(id, options = {}) {
+  const memoryFile = options.memoryFile || DEFAULT_MEMORY_FILE;
+  const store = loadMemoryStore(memoryFile);
+
+  const idx = store.entries.findIndex(e => e.id === id);
+  if (idx === -1) {
+    return { success: false, error: `Memory entry not found: ${id}` };
+  }
+
+  const [removed] = store.entries.splice(idx, 1);
+  saveMemoryStore(store, memoryFile);
+
+  return { success: true, removed, total: store.entries.length };
+}
+
+/**
+ * Get memory statistics grouped by type.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function getMemoryStats(options = {}) {
+  const memoryFile = options.memoryFile || DEFAULT_MEMORY_FILE;
+  const store = loadMemoryStore(memoryFile);
+
+  const byType = {};
+  for (const type of MEMORY_TYPES) {
+    byType[type] = store.entries.filter(e => e.type === type).length;
+  }
+
+  return {
+    total: store.entries.length,
+    by_type: byType,
+    last_updated: store.last_updated
+  };
+}
+
+module.exports = {
+  loadMemoryStore,
+  saveMemoryStore,
+  defaultMemoryStore,
+  addMemory,
+  listMemories,
+  searchMemories,
+  recallMemory,
+  deleteMemory,
+  getMemoryStats,
+  MEMORY_TYPES
+};

package/bin/lib/prompt-governance.js

@@ -0,0 +1,130 @@
+/**
+ * prompt-governance.js — Prompt and Agent Version Governance (Item 91)
+ *
+ * Version, diff, test, and approve prompts, personas, tools, and workflows.
+ *
+ * Usage:
+ *   node bin/lib/prompt-governance.js register|version|diff|approve|list [options]
+ *
+ * State file: .jumpstart/state/prompt-governance.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'prompt-governance.json');
+
+const ASSET_TYPES = ['prompt', 'persona', 'tool', 'workflow'];
+
+function defaultState() {
+  return { version: '1.0.0', assets: [], 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 registerAsset(name, type, content, options = {}) {
+  if (!name || !type || !content) return { success: false, error: 'name, type, and content are required' };
+  if (!ASSET_TYPES.includes(type)) {
+    return { success: false, error: `Unknown type: ${type}. Valid: ${ASSET_TYPES.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const asset = {
+    id: `PGOV-${Date.now()}`,
+    name,
+    type,
+    versions: [{
+      version: '1.0.0',
+      content,
+      approved: false,
+      created_at: new Date().toISOString()
+    }],
+    current_version: '1.0.0',
+    created_at: new Date().toISOString()
+  };
+
+  state.assets.push(asset);
+  saveState(state, stateFile);
+
+  return { success: true, asset: { id: asset.id, name: asset.name, type: asset.type, version: asset.current_version } };
+}
+
+function addVersion(assetId, content, version, options = {}) {
+  if (!assetId || !content || !version) return { success: false, error: 'assetId, content, and version are required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const asset = state.assets.find(a => a.id === assetId);
+  if (!asset) return { success: false, error: `Asset ${assetId} not found` };
+
+  asset.versions.push({ version, content, approved: false, created_at: new Date().toISOString() });
+  asset.current_version = version;
+
+  saveState(state, stateFile);
+
+  return { success: true, asset_id: assetId, version };
+}
+
+function approveVersion(assetId, version, options = {}) {
+  if (!assetId || !version) return { success: false, error: 'assetId and version are required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const asset = state.assets.find(a => a.id === assetId);
+  if (!asset) return { success: false, error: `Asset ${assetId} not found` };
+
+  const ver = asset.versions.find(v => v.version === version);
+  if (!ver) return { success: false, error: `Version ${version} not found` };
+
+  ver.approved = true;
+  ver.approved_at = new Date().toISOString();
+  ver.approved_by = options.approver || 'system';
+
+  saveState(state, stateFile);
+
+  return { success: true, asset_id: assetId, version, approved: true };
+}
+
+function listAssets(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  let assets = state.assets;
+  if (options.type) assets = assets.filter(a => a.type === options.type);
+
+  return {
+    success: true,
+    total: assets.length,
+    assets: assets.map(a => ({
+      id: a.id, name: a.name, type: a.type,
+      current_version: a.current_version,
+      versions_count: a.versions.length,
+      latest_approved: (a.versions.filter(v => v.approved).pop() || {}).version || null
+    }))
+  };
+}
+
+module.exports = {
+  registerAsset, addVersion, approveVersion, listAssets,
+  loadState, saveState, defaultState,
+  ASSET_TYPES
+};

package/bin/lib/promptless-mode.js

@@ -0,0 +1,128 @@
+/**
+ * promptless-mode.js — Promptless Mode for Less Technical Users (Item 77)
+ *
+ * Wizard-driven workflows that still produce rigorous outputs.
+ *
+ * Usage:
+ *   node bin/lib/promptless-mode.js start|step|status [options]
+ *
+ * State file: .jumpstart/state/promptless.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'promptless.json');
+
+const WIZARDS = ['new-project', 'add-feature', 'review-spec', 'estimate', 'handoff'];
+
+const WIZARD_STEPS = {
+  'new-project': [
+    { id: 'name', prompt: 'What is your project name?', type: 'text' },
+    { id: 'domain', prompt: 'What industry is this for?', type: 'select', options: ['healthcare', 'fintech', 'retail', 'manufacturing', 'public-sector', 'general'] },
+    { id: 'type', prompt: 'Is this a new or existing project?', type: 'select', options: ['greenfield', 'brownfield'] },
+    { id: 'team_size', prompt: 'How large is your team?', type: 'select', options: ['1-3', '4-10', '10+'] }
+  ],
+  'add-feature': [
+    { id: 'feature_name', prompt: 'What feature do you want to add?', type: 'text' },
+    { id: 'priority', prompt: 'How urgent is this?', type: 'select', options: ['must-have', 'should-have', 'nice-to-have'] },
+    { id: 'complexity', prompt: 'How complex do you think it is?', type: 'select', options: ['simple', 'moderate', 'complex'] }
+  ],
+  'review-spec': [
+    { id: 'spec_file', prompt: 'Which specification file?', type: 'text' },
+    { id: 'review_type', prompt: 'What kind of review?', type: 'select', options: ['completeness', 'quality', 'ambiguity'] }
+  ]
+};
+
+function defaultState() {
+  return { version: '1.0.0', sessions: [], 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 startWizard(wizardType, options = {}) {
+  if (!WIZARDS.includes(wizardType)) {
+    return { success: false, error: `Unknown wizard: ${wizardType}. Valid: ${WIZARDS.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const session = {
+    id: `WIZ-${Date.now()}`,
+    wizard: wizardType,
+    status: 'active',
+    current_step: 0,
+    steps: (WIZARD_STEPS[wizardType] || []).map(s => ({ ...s, answer: null })),
+    created_at: new Date().toISOString()
+  };
+
+  state.sessions.push(session);
+  saveState(state, stateFile);
+
+  return { success: true, session, next_step: session.steps[0] || null };
+}
+
+function answerStep(sessionId, answer, options = {}) {
+  if (!sessionId) return { success: false, error: 'sessionId is 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.current_step >= session.steps.length) {
+    return { success: false, error: 'Wizard is already complete' };
+  }
+
+  session.steps[session.current_step].answer = answer;
+  session.current_step++;
+
+  const complete = session.current_step >= session.steps.length;
+  if (complete) session.status = 'complete';
+
+  saveState(state, stateFile);
+
+  return {
+    success: true,
+    complete,
+    next_step: complete ? null : session.steps[session.current_step],
+    answers: Object.fromEntries(session.steps.filter(s => s.answer !== null).map(s => [s.id, s.answer]))
+  };
+}
+
+function getWizardStatus(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    available_wizards: WIZARDS,
+    sessions: state.sessions.map(s => ({
+      id: s.id, wizard: s.wizard, status: s.status,
+      progress: `${s.current_step}/${s.steps.length}`
+    }))
+  };
+}
+
+module.exports = {
+  startWizard, answerStep, getWizardStatus,
+  loadState, saveState, defaultState,
+  WIZARDS, WIZARD_STEPS
+};