jumpstart-mode 1.1.11 → 1.1.13

package/bin/lib/legacy-modernizer.js

@@ -0,0 +1,160 @@
+/**
+ * legacy-modernizer.js — Legacy Code Modernization Mode (Item 48)
+ *
+ * COBOL, .NET Framework, Java monolith, SSIS, old Angular,
+ * old React, etc.
+ *
+ * Usage:
+ *   node bin/lib/legacy-modernizer.js assess|plan|report [options]
+ *
+ * State file: .jumpstart/state/legacy-modernization.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'legacy-modernization.json');
+
+const LEGACY_PLATFORMS = {
+  'cobol': { risk: 'high', strategy: 'strangler-fig', estimated_effort: 'very-high' },
+  'dotnet-framework': { risk: 'medium', strategy: 'phased-cutover', estimated_effort: 'high' },
+  'java-monolith': { risk: 'medium', strategy: 'strangler-fig', estimated_effort: 'high' },
+  'ssis': { risk: 'medium', strategy: 'phased-cutover', estimated_effort: 'medium' },
+  'angular-legacy': { risk: 'low', strategy: 'phased-cutover', estimated_effort: 'medium' },
+  'react-legacy': { risk: 'low', strategy: 'in-place', estimated_effort: 'low' },
+  'jquery': { risk: 'low', strategy: 'phased-cutover', estimated_effort: 'medium' },
+  'php-legacy': { risk: 'medium', strategy: 'strangler-fig', estimated_effort: 'high' }
+};
+
+const MODERNIZATION_PATTERNS = ['strangler-fig', 'phased-cutover', 'big-bang', 'in-place', 'rewrite'];
+
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    assessments: [],
+    modernization_plans: []
+  };
+}
+
+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');
+}
+
+/**
+ * Assess a legacy system for modernization.
+ *
+ * @param {object} system - { name, platform, age_years?, loc?, dependencies? }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function assessSystem(system, options = {}) {
+  if (!system || !system.name || !system.platform) {
+    return { success: false, error: 'name and platform are required' };
+  }
+
+  const platform = system.platform.toLowerCase();
+  const platformInfo = LEGACY_PLATFORMS[platform] || { risk: 'medium', strategy: 'phased-cutover', estimated_effort: 'medium' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const assessment = {
+    id: `LEG-${(state.assessments.length + 1).toString().padStart(3, '0')}`,
+    name: system.name,
+    platform,
+    age_years: system.age_years || null,
+    loc: system.loc || null,
+    risk_level: platformInfo.risk,
+    recommended_strategy: platformInfo.strategy,
+    estimated_effort: platformInfo.estimated_effort,
+    modernization_targets: system.modernization_targets || [],
+    assessed_at: new Date().toISOString()
+  };
+
+  state.assessments.push(assessment);
+  saveState(state, stateFile);
+
+  return { success: true, assessment };
+}
+
+/**
+ * Create a modernization plan.
+ *
+ * @param {string} assessmentId
+ * @param {object} plan - { target_platform, phases[], timeline? }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function createPlan(assessmentId, plan, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const assessment = state.assessments.find(a => a.id === assessmentId);
+  if (!assessment) return { success: false, error: `Assessment not found: ${assessmentId}` };
+
+  const modPlan = {
+    id: `MOD-${(state.modernization_plans.length + 1).toString().padStart(3, '0')}`,
+    assessment_id: assessmentId,
+    source_platform: assessment.platform,
+    target_platform: plan.target_platform || 'modern-stack',
+    strategy: assessment.recommended_strategy,
+    phases: (plan.phases || ['assess', 'plan', 'implement', 'validate', 'cutover']).map((p, i) => ({
+      order: i + 1,
+      name: typeof p === 'string' ? p : p.name,
+      status: 'pending'
+    })),
+    timeline: plan.timeline || null,
+    created_at: new Date().toISOString()
+  };
+
+  state.modernization_plans.push(modPlan);
+  saveState(state, stateFile);
+
+  return { success: true, plan: modPlan };
+}
+
+/**
+ * Generate modernization report.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    total_assessments: state.assessments.length,
+    total_plans: state.modernization_plans.length,
+    by_platform: state.assessments.reduce((acc, a) => { acc[a.platform] = (acc[a.platform] || 0) + 1; return acc; }, {}),
+    by_risk: state.assessments.reduce((acc, a) => { acc[a.risk_level] = (acc[a.risk_level] || 0) + 1; return acc; }, {}),
+    assessments: state.assessments
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  assessSystem,
+  createPlan,
+  generateReport,
+  LEGACY_PLATFORMS,
+  MODERNIZATION_PATTERNS
+};

package/bin/lib/migration-planner.js

@@ -0,0 +1,144 @@
+/**
+ * migration-planner.js — Brownfield Migration Planner (Item 47)
+ *
+ * Special workflows for strangler patterns, phased cutovers,
+ * compatibility layers, and rollback.
+ *
+ * Usage:
+ *   node bin/lib/migration-planner.js plan|status|report [options]
+ *
+ * State file: .jumpstart/state/migration-plan.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'migration-plan.json');
+
+const MIGRATION_STRATEGIES = ['strangler-fig', 'big-bang', 'phased-cutover', 'parallel-run', 'feature-flag'];
+
+const MIGRATION_PHASES = ['discovery', 'planning', 'compatibility-layer', 'migration', 'validation', 'cutover', 'cleanup'];
+
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    migrations: []
+  };
+}
+
+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');
+}
+
+/**
+ * Create a migration plan.
+ *
+ * @param {object} migration - { name, strategy, source_system, target_system, components[] }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function createMigration(migration, options = {}) {
+  if (!migration || !migration.name || !migration.strategy) {
+    return { success: false, error: 'name and strategy are required' };
+  }
+
+  if (!MIGRATION_STRATEGIES.includes(migration.strategy)) {
+    return { success: false, error: `Invalid strategy. Must be one of: ${MIGRATION_STRATEGIES.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const plan = {
+    id: `MIG-${(state.migrations.length + 1).toString().padStart(3, '0')}`,
+    name: migration.name,
+    strategy: migration.strategy,
+    source_system: migration.source_system || null,
+    target_system: migration.target_system || null,
+    current_phase: 'discovery',
+    components: (migration.components || []).map(c => ({
+      name: c.name || c,
+      status: 'pending',
+      migrated_at: null
+    })),
+    rollback_plan: migration.rollback_plan || null,
+    compatibility_requirements: migration.compatibility_requirements || [],
+    created_at: new Date().toISOString()
+  };
+
+  state.migrations.push(plan);
+  saveState(state, stateFile);
+
+  return { success: true, migration: plan };
+}
+
+/**
+ * Advance migration phase.
+ *
+ * @param {string} migrationId
+ * @param {string} phase
+ * @param {object} [options]
+ * @returns {object}
+ */
+function advancePhase(migrationId, phase, options = {}) {
+  if (!MIGRATION_PHASES.includes(phase)) {
+    return { success: false, error: `Invalid phase. Must be one of: ${MIGRATION_PHASES.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const migration = state.migrations.find(m => m.id === migrationId);
+  if (!migration) return { success: false, error: `Migration not found: ${migrationId}` };
+
+  migration.current_phase = phase;
+  migration.phase_updated_at = new Date().toISOString();
+  saveState(state, stateFile);
+
+  return { success: true, migration_id: migrationId, phase, previous_phase: migration.current_phase };
+}
+
+/**
+ * Generate migration report.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  return {
+    success: true,
+    total_migrations: state.migrations.length,
+    by_strategy: state.migrations.reduce((acc, m) => { acc[m.strategy] = (acc[m.strategy] || 0) + 1; return acc; }, {}),
+    by_phase: state.migrations.reduce((acc, m) => { acc[m.current_phase] = (acc[m.current_phase] || 0) + 1; return acc; }, {}),
+    migrations: state.migrations
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  createMigration,
+  advancePhase,
+  generateReport,
+  MIGRATION_STRATEGIES,
+  MIGRATION_PHASES
+};

package/bin/lib/model-governance.js

@@ -0,0 +1,185 @@
+/**
+ * model-governance.js — Model Governance Workflows (Item 33)
+ *
+ * Track model choice, prompting strategy, evals, risks,
+ * safety controls, and fallback models.
+ *
+ * Usage:
+ *   node bin/lib/model-governance.js register|evaluate|report [options]
+ *
+ * State file: .jumpstart/state/model-governance.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'model-governance.json');
+
+const MODEL_RISK_LEVELS = ['low', 'medium', 'high', 'critical'];
+const MODEL_STATUSES = ['proposed', 'approved', 'deployed', 'deprecated', 'retired'];
+
+function defaultState() {
+  return {
+    version: '1.0.0',
+    created_at: new Date().toISOString(),
+    last_updated: null,
+    models: [],
+    evaluations: [],
+    safety_controls: []
+  };
+}
+
+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');
+}
+
+/**
+ * Register a model for governance tracking.
+ *
+ * @param {object} model - { name, provider, version, use_case, risk_level?, fallback? }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function registerModel(model, options = {}) {
+  if (!model || !model.name || !model.provider) {
+    return { success: false, error: 'name and provider are required' };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const riskLevel = (model.risk_level || 'medium').toLowerCase();
+  if (!MODEL_RISK_LEVELS.includes(riskLevel)) {
+    return { success: false, error: `Invalid risk level. Must be one of: ${MODEL_RISK_LEVELS.join(', ')}` };
+  }
+
+  const newModel = {
+    id: `MDL-${(state.models.length + 1).toString().padStart(3, '0')}`,
+    name: model.name,
+    provider: model.provider,
+    version: model.version || 'latest',
+    use_case: model.use_case || '',
+    risk_level: riskLevel,
+    status: 'proposed',
+    fallback: model.fallback || null,
+    prompting_strategy: model.prompting_strategy || null,
+    safety_controls: model.safety_controls || [],
+    data_handling: model.data_handling || null,
+    registered_at: new Date().toISOString()
+  };
+
+  state.models.push(newModel);
+  saveState(state, stateFile);
+
+  return { success: true, model: newModel };
+}
+
+/**
+ * Record a model evaluation.
+ *
+ * @param {string} modelId
+ * @param {object} evaluation - { metrics, notes?, evaluator? }
+ * @param {object} [options]
+ * @returns {object}
+ */
+function recordEvaluation(modelId, evaluation, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const model = state.models.find(m => m.id === modelId);
+  if (!model) return { success: false, error: `Model not found: ${modelId}` };
+
+  const eval_ = {
+    id: `EVAL-${Date.now().toString(36).toUpperCase()}`,
+    model_id: modelId,
+    metrics: evaluation.metrics || {},
+    notes: evaluation.notes || '',
+    evaluator: evaluation.evaluator || null,
+    evaluated_at: new Date().toISOString()
+  };
+
+  state.evaluations.push(eval_);
+  saveState(state, stateFile);
+
+  return { success: true, evaluation: eval_ };
+}
+
+/**
+ * Update model status.
+ *
+ * @param {string} modelId
+ * @param {string} status
+ * @param {object} [options]
+ * @returns {object}
+ */
+function updateStatus(modelId, status, options = {}) {
+  if (!MODEL_STATUSES.includes(status)) {
+    return { success: false, error: `Invalid status. Must be one of: ${MODEL_STATUSES.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const model = state.models.find(m => m.id === modelId);
+  if (!model) return { success: false, error: `Model not found: ${modelId}` };
+
+  model.status = status;
+  model.status_updated_at = new Date().toISOString();
+  saveState(state, stateFile);
+
+  return { success: true, model };
+}
+
+/**
+ * Generate model governance report.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const byStatus = {};
+  const byRisk = {};
+  for (const m of state.models) {
+    byStatus[m.status] = (byStatus[m.status] || 0) + 1;
+    byRisk[m.risk_level] = (byRisk[m.risk_level] || 0) + 1;
+  }
+
+  return {
+    success: true,
+    total_models: state.models.length,
+    total_evaluations: state.evaluations.length,
+    by_status: byStatus,
+    by_risk: byRisk,
+    high_risk_models: state.models.filter(m => m.risk_level === 'high' || m.risk_level === 'critical'),
+    models_without_fallback: state.models.filter(m => !m.fallback),
+    models: state.models
+  };
+}
+
+module.exports = {
+  defaultState,
+  loadState,
+  saveState,
+  registerModel,
+  recordEvaluation,
+  updateStatus,
+  generateReport,
+  MODEL_RISK_LEVELS,
+  MODEL_STATUSES
+};

package/bin/lib/model-router.js

@@ -0,0 +1,144 @@
+/**
+ * model-router.js — Multi-Model Routing (Item 54)
+ *
+ * Use different models for planning, coding, review, diagramming,
+ * and summarization.
+ *
+ * Usage:
+ *   node bin/lib/model-router.js route|config|report [options]
+ *
+ * Config: .jumpstart/model-routing.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_CONFIG_FILE = path.join('.jumpstart', 'model-routing.json');
+
+const TASK_TYPES = ['planning', 'coding', 'review', 'diagramming', 'summarization', 'testing', 'documentation', 'analysis'];
+
+const DEFAULT_ROUTING = {
+  planning: { model: 'claude-3-opus', reason: 'Complex reasoning for architecture decisions' },
+  coding: { model: 'claude-3-sonnet', reason: 'Balanced quality and speed for code generation' },
+  review: { model: 'gpt-4o', reason: 'Thorough code review capabilities' },
+  diagramming: { model: 'claude-3-haiku', reason: 'Fast diagram generation' },
+  summarization: { model: 'claude-3-haiku', reason: 'Efficient summarization' },
+  testing: { model: 'claude-3-sonnet', reason: 'Good test generation quality' },
+  documentation: { model: 'claude-3-haiku', reason: 'Efficient doc generation' },
+  analysis: { model: 'claude-3-opus', reason: 'Deep analysis capabilities' }
+};
+
+/**
+ * Load routing configuration.
+ *
+ * @param {string} [configFile]
+ * @returns {object}
+ */
+function loadConfig(configFile) {
+  const filePath = configFile || DEFAULT_CONFIG_FILE;
+  if (!fs.existsSync(filePath)) return { routing: { ...DEFAULT_ROUTING } };
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); }
+  catch { return { routing: { ...DEFAULT_ROUTING } }; }
+}
+
+/**
+ * Save routing configuration.
+ *
+ * @param {object} config
+ * @param {string} [configFile]
+ */
+function saveConfig(config, configFile) {
+  const filePath = configFile || DEFAULT_CONFIG_FILE;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Route a task to the appropriate model.
+ *
+ * @param {string} taskType - Type of task to route.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function routeTask(taskType, options = {}) {
+  if (!TASK_TYPES.includes(taskType)) {
+    return { success: false, error: `Invalid task type. Must be one of: ${TASK_TYPES.join(', ')}` };
+  }
+
+  const configFile = options.configFile || DEFAULT_CONFIG_FILE;
+  const config = loadConfig(configFile);
+  const routing = config.routing || DEFAULT_ROUTING;
+  const route = routing[taskType] || DEFAULT_ROUTING[taskType];
+
+  return {
+    success: true,
+    task_type: taskType,
+    model: route.model,
+    reason: route.reason,
+    overridden: !!(config.routing && config.routing[taskType])
+  };
+}
+
+/**
+ * Configure routing for a task type.
+ *
+ * @param {string} taskType
+ * @param {string} model
+ * @param {object} [options]
+ * @returns {object}
+ */
+function configureRoute(taskType, model, options = {}) {
+  if (!TASK_TYPES.includes(taskType)) {
+    return { success: false, error: `Invalid task type. Must be one of: ${TASK_TYPES.join(', ')}` };
+  }
+
+  const configFile = options.configFile || DEFAULT_CONFIG_FILE;
+  const config = loadConfig(configFile);
+  if (!config.routing) config.routing = { ...DEFAULT_ROUTING };
+
+  config.routing[taskType] = {
+    model,
+    reason: options.reason || `Custom routing to ${model}`,
+    configured_at: new Date().toISOString()
+  };
+
+  saveConfig(config, configFile);
+
+  return { success: true, task_type: taskType, model, routing: config.routing };
+}
+
+/**
+ * Get routing report.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generateReport(options = {}) {
+  const configFile = options.configFile || DEFAULT_CONFIG_FILE;
+  const config = loadConfig(configFile);
+  const routing = config.routing || DEFAULT_ROUTING;
+
+  const models = [...new Set(Object.values(routing).map(r => r.model))];
+
+  return {
+    success: true,
+    task_types: TASK_TYPES.length,
+    configured_routes: Object.keys(routing).length,
+    unique_models: models.length,
+    models,
+    routing
+  };
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  routeTask,
+  configureRoute,
+  generateReport,
+  TASK_TYPES,
+  DEFAULT_ROUTING
+};