jumpstart-mode 1.1.12 → 1.1.13

package/bin/lib/multi-repo.js

@@ -0,0 +1,272 @@
+/**
+ * multi-repo.js — Multi-Repo Program Orchestration
+ *
+ * Lets one initiative span frontend, backend, infra, data, and docs
+ * repos with shared specs, dependencies, and release plans.
+ *
+ * Usage:
+ *   node bin/lib/multi-repo.js init|status|link|plan [options]
+ *
+ * State file: .jumpstart/state/multi-repo.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'multi-repo.json');
+
+/**
+ * Load the multi-repo state from disk.
+ * @param {string} [stateFile]
+ * @returns {object}
+ */
+function loadMultiRepoState(stateFile) {
+  const filePath = stateFile || DEFAULT_STATE_FILE;
+  if (!fs.existsSync(filePath)) {
+    return defaultMultiRepoState();
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return defaultMultiRepoState();
+  }
+}
+
+/**
+ * Default multi-repo state structure.
+ * @returns {object}
+ */
+function defaultMultiRepoState() {
+  return {
+    version: '1.0.0',
+    program_name: null,
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    repos: [],
+    shared_specs: [],
+    dependencies: [],
+    release_plan: {
+      milestones: [],
+      current_milestone: null
+    }
+  };
+}
+
+/**
+ * Save the multi-repo state to disk.
+ * @param {object} state
+ * @param {string} [stateFile]
+ */
+function saveMultiRepoState(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');
+}
+
+/**
+ * Initialize a multi-repo program.
+ * @param {string} programName
+ * @param {object} [options]
+ * @returns {object}
+ */
+function initProgram(programName, options = {}) {
+  if (!programName || typeof programName !== 'string' || !programName.trim()) {
+    return { success: false, error: 'Program name is required' };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = defaultMultiRepoState();
+  state.program_name = programName.trim();
+
+  saveMultiRepoState(state, stateFile);
+
+  return {
+    success: true,
+    program_name: state.program_name,
+    state_file: stateFile,
+    message: `Program "${state.program_name}" initialized`
+  };
+}
+
+/**
+ * Link a repo to the current program.
+ * @param {string} repoUrl - Git URL or local path of the repo.
+ * @param {string} role - Role of this repo: frontend|backend|infra|data|docs|other.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function linkRepo(repoUrl, role, options = {}) {
+  if (!repoUrl) return { success: false, error: 'repoUrl is required' };
+
+  const validRoles = ['frontend', 'backend', 'infra', 'data', 'docs', 'other'];
+  const normalizedRole = (role || 'other').toLowerCase();
+  if (!validRoles.includes(normalizedRole)) {
+    return { success: false, error: `role must be one of: ${validRoles.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadMultiRepoState(stateFile);
+
+  const existing = state.repos.find(r => r.url === repoUrl);
+  if (existing) {
+    return { success: false, error: `Repo already linked: ${repoUrl}` };
+  }
+
+  const entry = {
+    id: `repo-${Date.now()}`,
+    url: repoUrl,
+    role: normalizedRole,
+    linked_at: new Date().toISOString(),
+    specs: [],
+    status: 'active'
+  };
+
+  state.repos.push(entry);
+  saveMultiRepoState(state, stateFile);
+
+  return {
+    success: true,
+    repo: entry,
+    total_repos: state.repos.length
+  };
+}
+
+/**
+ * Add a shared spec reference across repos.
+ * @param {string} specPath - Relative path to shared spec file.
+ * @param {string[]} repoIds - IDs of repos this spec applies to.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function addSharedSpec(specPath, repoIds, options = {}) {
+  if (!specPath) return { success: false, error: 'specPath is required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadMultiRepoState(stateFile);
+
+  const entry = {
+    id: `spec-${Date.now()}`,
+    path: specPath,
+    repos: Array.isArray(repoIds) ? repoIds : [],
+    added_at: new Date().toISOString()
+  };
+
+  state.shared_specs.push(entry);
+  saveMultiRepoState(state, stateFile);
+
+  return {
+    success: true,
+    spec: entry,
+    total_shared_specs: state.shared_specs.length
+  };
+}
+
+/**
+ * Record a cross-repo dependency.
+ * @param {string} fromRepoId - Source repo ID.
+ * @param {string} toRepoId - Target repo ID.
+ * @param {string} dependencyType - Type: api|data|event|deploy|other.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function addDependency(fromRepoId, toRepoId, dependencyType, options = {}) {
+  if (!fromRepoId || !toRepoId) {
+    return { success: false, error: 'fromRepoId and toRepoId are required' };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadMultiRepoState(stateFile);
+
+  const dep = {
+    id: `dep-${Date.now()}`,
+    from: fromRepoId,
+    to: toRepoId,
+    type: dependencyType || 'other',
+    created_at: new Date().toISOString()
+  };
+
+  state.dependencies.push(dep);
+  saveMultiRepoState(state, stateFile);
+
+  return { success: true, dependency: dep };
+}
+
+/**
+ * Get the current status of the multi-repo program.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function getProgramStatus(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadMultiRepoState(stateFile);
+
+  const roleBreakdown = {};
+  for (const repo of state.repos) {
+    roleBreakdown[repo.role] = (roleBreakdown[repo.role] || 0) + 1;
+  }
+
+  return {
+    program_name: state.program_name,
+    initialized: !!state.program_name,
+    repo_count: state.repos.length,
+    shared_spec_count: state.shared_specs.length,
+    dependency_count: state.dependencies.length,
+    role_breakdown: roleBreakdown,
+    repos: state.repos,
+    release_plan: state.release_plan,
+    last_updated: state.last_updated
+  };
+}
+
+/**
+ * Generate a release plan across all linked repos.
+ * @param {object[]} milestones - Array of { name, target_date, repos[] }.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function setReleasePlan(milestones, options = {}) {
+  if (!Array.isArray(milestones)) {
+    return { success: false, error: 'milestones must be an array' };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadMultiRepoState(stateFile);
+
+  state.release_plan.milestones = milestones.map((m, i) => ({
+    id: `milestone-${i + 1}`,
+    name: m.name || `Milestone ${i + 1}`,
+    target_date: m.target_date || null,
+    repos: m.repos || [],
+    status: m.status || 'planned'
+  }));
+
+  if (state.release_plan.milestones.length > 0) {
+    state.release_plan.current_milestone = state.release_plan.milestones[0].id;
+  }
+
+  saveMultiRepoState(state, stateFile);
+
+  return {
+    success: true,
+    milestone_count: state.release_plan.milestones.length,
+    release_plan: state.release_plan
+  };
+}
+
+module.exports = {
+  loadMultiRepoState,
+  saveMultiRepoState,
+  defaultMultiRepoState,
+  initProgram,
+  linkRepo,
+  addSharedSpec,
+  addDependency,
+  getProgramStatus,
+  setReleasePlan
+};

package/bin/lib/next-phase.js

@@ -31,6 +31,7 @@ const { join, resolve } = require('path');
 import { loadState } from './state-store.js';
 import { getHandoff, isArtifactApproved } from './handoff.js';
 import { parseSimpleYaml } from './config-loader.js';
+import { readFocusFromConfig, isPhaseInFocus } from './focus.js';
 
 /**
  * Phase-to-slash-command map.
@@ -121,6 +122,9 @@ export function determineNextAction(options = {}) {
   const projectType = config?.project?.type || 'greenfield';
   const requireApproval = config?.workflow?.require_gate_approval !== false;
 
+  // Load focus mode config (if active)
+  const focusConfig = readFocusFromConfig(configPath);
+
   // Load current state
   const state = loadState(statePath);
   const currentPhase = state.current_phase;
@@ -142,7 +146,8 @@ export function determineNextAction(options = {}) {
           next_agent: 'analyst',
           command: AGENT_COMMANDS.analyst,
           message: 'Phase 0 (Challenger) is already approved. Next: Phase 1 — ' + PHASE_DESCRIPTIONS['1'],
-          context_files: getHandoff(0).context_files || []
+          context_files: getHandoff(0).context_files || [],
+          focus: focusConfig && focusConfig.enabled ? { active: true, start_phase: focusConfig.start_phase, end_phase: focusConfig.end_phase } : undefined
         };
       }
       return {
@@ -153,7 +158,26 @@ export function determineNextAction(options = {}) {
         command: '/jumpstart.review',
         artifact: 'specs/challenger-brief.md',
         message: 'Phase 0 (Challenger) artifact exists but is not yet approved. Review and approve it to proceed.',
-        context_files: []
+        context_files: [],
+        focus: focusConfig && focusConfig.enabled ? { active: true, start_phase: focusConfig.start_phase, end_phase: focusConfig.end_phase } : undefined
+      };
+    }
+
+    // If focus mode is active, skip to the focus start phase
+    if (focusConfig && focusConfig.enabled) {
+      const focusStart = focusConfig.start_phase;
+      const agentNames = { '-1': 'scout', '0': 'challenger', '1': 'analyst', '2': 'pm', '3': 'architect', '4': 'developer' };
+      const agent = agentNames[String(focusStart)];
+      const command = AGENT_COMMANDS[agent];
+      return {
+        action: 'start',
+        current_phase: null,
+        next_phase: focusStart,
+        next_agent: agent,
+        command: command,
+        message: `Focus mode active (${focusConfig.preset || 'custom'}). Start with Phase ${focusStart} — ${PHASE_DESCRIPTIONS[String(focusStart)]}`,
+        context_files: [],
+        focus: { active: true, start_phase: focusConfig.start_phase, end_phase: focusConfig.end_phase }
       };
     }
 
@@ -206,17 +230,23 @@ export function determineNextAction(options = {}) {
     };
   }
 
-  // ─── Case 2: Final phase (4) — check completion ───────────────────────────
-  if (currentPhase === 4) {
+  // ─── Case 2: Final phase or focus end reached — check completion ─────────
+  if (currentPhase === 4 || (focusConfig && focusConfig.enabled && currentPhase > focusConfig.end_phase)) {
+    const focusNote = focusConfig && focusConfig.enabled
+      ? ` Focus mode (${focusConfig.preset || 'custom'}) workflow complete.`
+      : '';
     return {
       action: 'complete',
-      current_phase: 4,
+      current_phase: currentPhase,
       next_phase: null,
       next_agent: null,
       command: '/jumpstart.status',
-      message: 'Phase 4 (Developer) is the final phase. All specification phases are complete. Run `/jumpstart.status` for a full project overview, or `/jumpstart.deploy` for deployment planning.',
+      message: currentPhase === 4
+        ? 'Phase 4 (Developer) is the final phase. All specification phases are complete. Run `/jumpstart.status` for a full project overview, or `/jumpstart.deploy` for deployment planning.'
+        : `Phase ${currentPhase} (${PHASE_NAMES[String(currentPhase)]}) reached the end of focus range.${focusNote} Run \`/jumpstart.status\` for a project overview.`,
       suggestions: ['/jumpstart.status', '/jumpstart.deploy', '/jumpstart.resume'],
-      context_files: []
+      context_files: [],
+      focus: focusConfig && focusConfig.enabled ? { active: true, start_phase: focusConfig.start_phase, end_phase: focusConfig.end_phase } : undefined
     };
   }
 
@@ -278,6 +308,20 @@ export function determineNextAction(options = {}) {
     const nextPhase = handoff.next_phase;
     const command = AGENT_COMMANDS[nextAgent];
 
+    // Check if next phase is beyond focus range
+    if (focusConfig && focusConfig.enabled && !isPhaseInFocus(nextPhase, focusConfig)) {
+      return {
+        action: 'complete',
+        current_phase: currentPhase,
+        next_phase: null,
+        next_agent: null,
+        command: '/jumpstart.status',
+        message: `Phase ${currentPhase} (${PHASE_NAMES[String(currentPhase)]}) is approved! Focus mode (${focusConfig.preset || 'custom'}) workflow complete — Phase ${nextPhase} is outside the focus range. Run \`/jumpstart.status\` for a project overview.`,
+        context_files: [],
+        focus: { active: true, start_phase: focusConfig.start_phase, end_phase: focusConfig.end_phase }
+      };
+    }
+
     return {
       action: 'proceed',
       current_phase: currentPhase,
@@ -285,7 +329,8 @@ export function determineNextAction(options = {}) {
       next_agent: nextAgent,
       command: command,
       message: `Phase ${currentPhase} (${PHASE_NAMES[String(currentPhase)]}) is approved! Next: Phase ${nextPhase} — ${PHASE_DESCRIPTIONS[String(nextPhase)]}`,
-      context_files: handoff.context_files || []
+      context_files: handoff.context_files || [],
+      focus: focusConfig && focusConfig.enabled ? { active: true, start_phase: focusConfig.start_phase, end_phase: focusConfig.end_phase } : undefined
     };
   }
 

package/bin/lib/ops-ownership.js

@@ -0,0 +1,152 @@
+/**
+ * ops-ownership.js — Operational Ownership Modeling (Item 39)
+ *
+ * Require clear service owner, escalation path, on-call model,
+ * and support plan.
+ *
+ * Usage:
+ *   node bin/lib/ops-ownership.js define|check|report [options]
+ *
+ * State file: .jumpstart/state/ops-ownership.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'ops-ownership.json');
+
+const OWNERSHIP_FIELDS = ['service_owner', 'team', 'escalation_path', 'oncall_model', 'support_hours', 'runbook_url', 'sla_tier'];
+
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    services: []
+  };
+}
+
+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');
+}
+
+/**
+ * Define operational ownership for a service.
+ *
+ * @param {object} service - { name, service_owner, team, escalation_path[], oncall_model, support_hours, runbook_url?, sla_tier? }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function defineOwnership(service, options = {}) {
+  if (!service || !service.name || !service.service_owner) {
+    return { success: false, error: 'name and service_owner are required' };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const svc = {
+    id: `OPS-${(state.services.length + 1).toString().padStart(3, '0')}`,
+    name: service.name,
+    service_owner: service.service_owner,
+    team: service.team || null,
+    escalation_path: service.escalation_path || [],
+    oncall_model: service.oncall_model || 'business-hours',
+    support_hours: service.support_hours || '9x5',
+    runbook_url: service.runbook_url || null,
+    sla_tier: service.sla_tier || 'silver',
+    defined_at: new Date().toISOString()
+  };
+
+  // Replace if already exists
+  const idx = state.services.findIndex(s => s.name === service.name);
+  if (idx >= 0) state.services[idx] = svc;
+  else state.services.push(svc);
+
+  saveState(state, stateFile);
+
+  return { success: true, service: svc };
+}
+
+/**
+ * Check ownership completeness.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function checkCompleteness(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const incomplete = [];
+  for (const svc of state.services) {
+    const missing = [];
+    if (!svc.service_owner) missing.push('service_owner');
+    if (!svc.team) missing.push('team');
+    if (!svc.escalation_path || svc.escalation_path.length === 0) missing.push('escalation_path');
+    if (!svc.runbook_url) missing.push('runbook_url');
+
+    if (missing.length > 0) {
+      incomplete.push({ service: svc.name, missing });
+    }
+  }
+
+  return {
+    success: true,
+    total_services: state.services.length,
+    complete: state.services.length - incomplete.length,
+    incomplete: incomplete.length,
+    findings: incomplete,
+    all_complete: incomplete.length === 0
+  };
+}
+
+/**
+ * Generate ops ownership report.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const byTeam = {};
+  const byTier = {};
+  for (const svc of state.services) {
+    const team = svc.team || 'unassigned';
+    byTeam[team] = (byTeam[team] || 0) + 1;
+    byTier[svc.sla_tier] = (byTier[svc.sla_tier] || 0) + 1;
+  }
+
+  return {
+    success: true,
+    total_services: state.services.length,
+    by_team: byTeam,
+    by_tier: byTier,
+    services: state.services
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  defineOwnership,
+  checkCompleteness,
+  generateReport,
+  OWNERSHIP_FIELDS
+};