gsd-opencode 1.20.2 → 1.20.3

package/get-shit-done/bin/gsd-oc-commands/set-profile.cjs

@@ -0,0 +1,357 @@
+/**
+ * set-profile.cjs — Switch profile in oc_config.json with three operation modes
+ *
+ * Command module for managing OpenCode profiles using .planning/oc_config.json:
+ * 1. Mode 1 (no profile name): Validate and apply current profile
+ * 2. Mode 2 (profile name): Switch to specified profile
+ * 3. Mode 3 (inline JSON): Create new profile from definition
+ *
+ * Features:
+ * - Pre-flight validation BEFORE any file modifications
+ * - Atomic transaction with rollback on failure
+ * - Dry-run mode for previewing changes
+ * - Structured JSON output
+ *
+ * Usage:
+ *   node set-profile.cjs                      # Mode 1: validate current
+ *   node set-profile.cjs genius               # Mode 2: switch to profile
+ *   node set-profile.cjs 'custom:{...}'       # Mode 3: create profile
+ *   node set-profile.cjs --dry-run genius     # Preview changes
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { output, error, createBackup } = require('../gsd-oc-lib/oc-core.cjs');
+const { applyProfileWithValidation } = require('../gsd-oc-lib/oc-profile-config.cjs');
+const { getModelCatalog } = require('../gsd-oc-lib/oc-models.cjs');
+const { applyProfileToOpencode } = require('../gsd-oc-lib/oc-config.cjs');
+
+/**
+ * Error codes for set-profile operations
+ */
+const ERROR_CODES = {
+  CONFIG_NOT_FOUND: 'CONFIG_NOT_FOUND',
+  INVALID_JSON: 'INVALID_JSON',
+  INVALID_SYNTAX: 'INVALID_SYNTAX',
+  PROFILE_NOT_FOUND: 'PROFILE_NOT_FOUND',
+  PROFILE_EXISTS: 'PROFILE_EXISTS',
+  INVALID_MODELS: 'INVALID_MODELS',
+  INCOMPLETE_PROFILE: 'INCOMPLETE_PROFILE',
+  WRITE_FAILED: 'WRITE_FAILED',
+  APPLY_FAILED: 'APPLY_FAILED',
+  ROLLBACK_FAILED: 'ROLLBACK_FAILED',
+  MISSING_CURRENT_PROFILE: 'MISSING_CURRENT_PROFILE',
+  INVALID_ARGS: 'INVALID_ARGS'
+};
+
+/**
+ * Parse inline profile definition from argument
+ * Expected format: profileName:{"planning":"...", "execution":"...", "verification":"..."}
+ *
+ * @param {string} arg - Argument string
+ * @returns {Object|null} {name, profile} or null if invalid
+ */
+function parseInlineProfile(arg) {
+  const match = arg.match(/^([^:]+):(.+)$/);
+  if (!match) {
+    return null;
+  }
+
+  const [, profileName, profileJson] = match;
+
+  try {
+    const profile = JSON.parse(profileJson);
+    return { name: profileName, profile };
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Validate inline profile definition has all required keys
+ *
+ * @param {Object} profile - Profile object to validate
+ * @returns {Object} {valid: boolean, missingKeys: string[]}
+ */
+function validateInlineProfile(profile) {
+  const requiredKeys = ['planning', 'execution', 'verification'];
+  const missingKeys = requiredKeys.filter(key => !profile[key]);
+
+  return {
+    valid: missingKeys.length === 0,
+    missingKeys
+  };
+}
+
+/**
+ * Validate models against whitelist
+ *
+ * @param {Object} profile - Profile with planning/execution/verification
+ * @param {string[]} validModels - Array of valid model IDs
+ * @returns {Object} {valid: boolean, invalidModels: string[]}
+ */
+function validateProfileModels(profile, validModels) {
+  const modelsToCheck = [profile.planning, profile.execution, profile.verification].filter(Boolean);
+  const invalidModels = modelsToCheck.filter(model => !validModels.includes(model));
+
+  return {
+    valid: invalidModels.length === 0,
+    invalidModels
+  };
+}
+
+/**
+ * Main command function
+ *
+ * @param {string} cwd - Current working directory
+ * @param {string[]} args - Command line arguments
+ */
+function setProfilePhase16(cwd, args) {
+  const verbose = args.includes('--verbose');
+  const dryRun = args.includes('--dry-run');
+  const raw = args.includes('--raw');
+
+  const log = verbose ? (...args) => console.error('[set-profile]', ...args) : () => {};
+  const configPath = path.join(cwd, '.planning', 'oc_config.json');
+  const opencodePath = path.join(cwd, 'opencode.json');
+  const backupsDir = path.join(cwd, '.planning', 'backups');
+
+  log('Starting set-profile command');
+
+  // Filter flags to get profile argument
+  const profileArgs = args.filter(arg => !arg.startsWith('--'));
+
+  // Check for too many arguments
+  if (profileArgs.length > 1) {
+    error('Too many arguments. Usage: set-profile [profile-name | profileName:JSON] [--dry-run]', 'INVALID_ARGS');
+  }
+
+  const profileArg = profileArgs.length > 0 ? profileArgs[0] : null;
+
+  // ========== MODE 3: Inline profile definition ==========
+  if (profileArg && profileArg.includes(':')) {
+    const parsed = parseInlineProfile(profileArg);
+
+    if (!parsed) {
+      error(
+        'Invalid profile syntax. Use: profileName:{"planning":"...", "execution":"...", "verification":"..."}',
+        'INVALID_SYNTAX'
+      );
+    }
+
+    const { name: profileName, profile } = parsed;
+    log(`Mode 3: Creating inline profile "${profileName}"`);
+
+    // Validate complete profile definition
+    const validation = validateInlineProfile(profile);
+    if (!validation.valid) {
+      error(
+        `Profile definition missing required keys: ${validation.missingKeys.join(', ')}`,
+        'INCOMPLETE_PROFILE'
+      );
+    }
+
+    // Get model catalog for validation
+    const catalogResult = getModelCatalog();
+    if (!catalogResult.success) {
+      error(catalogResult.error.message, catalogResult.error.code);
+    }
+
+    // Validate models against whitelist
+    const modelValidation = validateProfileModels(profile, catalogResult.models);
+    if (!modelValidation.valid) {
+      error(
+        `Invalid models: ${modelValidation.invalidModels.join(', ')}`,
+        'INVALID_MODELS'
+      );
+    }
+
+    log('Inline profile validation passed');
+
+    // Dry-run mode
+    if (dryRun) {
+      output({
+        success: true,
+        data: {
+          dryRun: true,
+          action: 'create_profile',
+          profile: profileName,
+          models: profile
+        }
+      });
+      process.exit(0);
+    }
+
+    // Load or create oc_config.json
+    let config = {};
+    if (fs.existsSync(configPath)) {
+      try {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      } catch (err) {
+        error(`Failed to parse oc_config.json: ${err.message}`, 'INVALID_JSON');
+      }
+    }
+
+    // Create backup
+    if (!fs.existsSync(backupsDir)) {
+      fs.mkdirSync(backupsDir, { recursive: true });
+    }
+
+    const backupPath = createBackup(configPath, backupsDir);
+
+    // Initialize structure if needed
+    if (!config.profiles) config.profiles = {};
+    if (!config.profiles.presets) config.profiles.presets = {};
+
+    // Add profile and set as current
+    config.profiles.presets[profileName] = profile;
+    config.current_oc_profile = profileName;
+
+    // write oc_config.json
+    try {
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+      log('Updated oc_config.json');
+    } catch (err) {
+      error(`Failed to write oc_config.json: ${err.message}`, 'WRITE_FAILED');
+    }
+
+    // Apply to opencode.json
+    const applyResult = applyProfileToOpencode(opencodePath, configPath, profileName);
+    if (!applyResult.success) {
+      // Rollback
+      try {
+        if (backupPath) {
+          fs.copyFileSync(backupPath, configPath);
+        }
+      } catch (rollbackErr) {
+        error(
+          `Failed to apply profile AND failed to rollback: ${rollbackErr.message}`,
+          'ROLLBACK_FAILED'
+        );
+      }
+      error(`Failed to apply profile to opencode.json: ${applyResult.error.message}`, 'APPLY_FAILED');
+    }
+
+    output({
+      success: true,
+      data: {
+        profile: profileName,
+        models: profile,
+        backup: backupPath,
+        configPath
+      }
+    });
+    process.exit(0);
+  }
+
+  // ========== MODE 1 & 2: Use applyProfileWithValidation ==========
+  // Load oc_config.json first to determine mode
+  let config;
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch (err) {
+      error(`Failed to parse oc_config.json: ${err.message}`, 'INVALID_JSON');
+    }
+  } else {
+    error('.planning/oc_config.json not found. Create it with an inline profile definition first.', 'CONFIG_NOT_FOUND');
+  }
+
+  const presets = config.profiles?.presets || {};
+  const currentProfile = config.current_oc_profile;
+
+  // ========== MODE 2: Profile name provided ==========
+  if (profileArg) {
+    log(`Mode 2: Switching to profile "${profileArg}"`);
+
+    // Check profile exists
+    if (!presets[profileArg]) {
+      const available = Object.keys(presets).join(', ') || 'none';
+      error(`Profile "${profileArg}" not found. Available profiles: ${available}`, 'PROFILE_NOT_FOUND');
+    }
+
+    // Use applyProfileWithValidation for Mode 2
+    const result = applyProfileWithValidation(cwd, profileArg, { dryRun, verbose });
+
+    if (!result.success) {
+      error(result.error.message, result.error.code || 'UNKNOWN_ERROR');
+    }
+
+    if (result.dryRun) {
+      output({
+        success: true,
+        data: {
+          dryRun: true,
+          action: 'switch_profile',
+          profile: profileArg,
+          models: result.preview.models,
+          changes: result.preview.changes
+        }
+      });
+    } else {
+      output({
+        success: true,
+        data: {
+          profile: profileArg,
+          models: result.data.models,
+          backup: result.data.backup,
+          updated: result.data.updated,
+          configPath: result.data.configPath
+        }
+      });
+    }
+    process.exit(0);
+  }
+
+  // ========== MODE 1: No profile name - validate current profile ==========
+  log('Mode 1: Validating current profile');
+
+  if (!currentProfile) {
+    const available = Object.keys(presets).join(', ') || 'none';
+    error(
+      `current_oc_profile not set. Available profiles: ${available}`,
+      'MISSING_CURRENT_PROFILE'
+    );
+  }
+
+  if (!presets[currentProfile]) {
+    error(
+      `Current profile "${currentProfile}" not found in profiles.presets`,
+      'PROFILE_NOT_FOUND'
+    );
+  }
+
+  // Use applyProfileWithValidation for Mode 1
+  const result = applyProfileWithValidation(cwd, currentProfile, { dryRun, verbose });
+
+  if (!result.success) {
+    error(result.error.message, result.error.code || 'UNKNOWN_ERROR');
+  }
+
+  if (result.dryRun) {
+    output({
+      success: true,
+      data: {
+        dryRun: true,
+        action: 'validate_current',
+        profile: currentProfile,
+        models: result.preview.models,
+        changes: result.preview.changes
+      }
+    });
+  } else {
+    output({
+      success: true,
+      data: {
+        profile: currentProfile,
+        models: result.data.models,
+        backup: result.data.backup,
+        updated: result.data.updated,
+        configPath: result.data.configPath
+      }
+    });
+  }
+  process.exit(0);
+}
+
+module.exports = setProfilePhase16;

package/get-shit-done/bin/gsd-oc-commands/update-opencode-json.cjs

@@ -0,0 +1,199 @@
+/**
+ * update-opencode-json.cjs — Update opencode.json agent models from profile config
+ *
+ * Command module that updates opencode.json model assignments based on oc_config.json structure.
+ * Creates timestamped backup before modifications.
+ * Outputs JSON envelope format with update results.
+ *
+ * Usage: node update-opencode-json.cjs [cwd] [--dry-run] [--verbose]
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { output, error, createBackup } = require('../gsd-oc-lib/oc-core.cjs');
+const { applyProfileToOpencode } = require('../gsd-oc-lib/oc-config.cjs');
+
+/**
+ * Main command function
+ *
+ * @param {string} cwd - Current working directory
+ * @param {string[]} args - Command line arguments
+ */
+function updateOpencodeJson(cwd, args) {
+  const verbose = args.includes('--verbose');
+  const dryRun = args.includes('--dry-run');
+  
+  const opencodePath = path.join(cwd, 'opencode.json');
+  const configPath = path.join(cwd, '.planning', 'oc_config.json');
+  
+  // Check if opencode.json exists
+  if (!fs.existsSync(opencodePath)) {
+    error('opencode.json not found in current directory', 'CONFIG_NOT_FOUND');
+  }
+  
+  // Check if .planning/oc_config.json exists
+  if (!fs.existsSync(configPath)) {
+    error('.planning/oc_config.json not found', 'CONFIG_NOT_FOUND');
+  }
+  
+  if (verbose) {
+    console.error(`[verbose] opencode.json: ${opencodePath}`);
+    console.error(`[verbose] oc_config.json: ${configPath}`);
+    console.error(`[verbose] dry-run: ${dryRun}`);
+  }
+  
+  // Load and validate profile config
+  let config;
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    config = JSON.parse(content);
+  } catch (err) {
+    error('Failed to parse .planning/oc_config.json', 'INVALID_JSON');
+  }
+  
+  // Validate current_oc_profile
+  const profileName = config.current_oc_profile;
+  if (!profileName) {
+    error('current_oc_profile not found in oc_config.json', 'PROFILE_NOT_FOUND');
+  }
+  
+  // Validate profile exists in profiles.presets
+  const presets = config.profiles?.presets;
+  if (!presets || !presets[profileName]) {
+    const availableProfiles = presets ? Object.keys(presets).join(', ') : 'none';
+    error(`Profile "${profileName}" not found in profiles.presets. Available profiles: ${availableProfiles}`, 'PROFILE_NOT_FOUND');
+  }
+  
+  if (verbose) {
+    console.error(`[verbose] Profile name: ${profileName}`);
+  }
+  
+  // Dry-run mode: preview changes without modifying
+  if (dryRun) {
+    if (verbose) {
+      console.error('[verbose] Dry-run mode - no changes will be made');
+    }
+    
+    // Simulate what would be updated
+    try {
+      const opencodeContent = fs.readFileSync(opencodePath, 'utf8');
+      const opencodeData = JSON.parse(opencodeContent);
+      
+      const profileModels = presets[profileName];
+      
+      if (!profileModels.planning && !profileModels.execution && !profileModels.verification) {
+        error(`No model assignments found for profile "${profileName}"`, 'PROFILE_NOT_FOUND');
+      }
+      
+      // Determine which agents would be updated
+      const wouldUpdate = [];
+      
+      const PROFILE_AGENT_MAPPING = {
+        planning: [
+          'gsd-planner', 'gsd-plan-checker', 'gsd-phase-researcher',
+          'gsd-roadmapper', 'gsd-project-researcher', 'gsd-research-synthesizer',
+          'gsd-codebase-mapper'
+        ],
+        execution: ['gsd-executor', 'gsd-debugger'],
+        verification: ['gsd-verifier', 'gsd-integration-checker']
+      };
+      
+      for (const [category, agentNames] of Object.entries(PROFILE_AGENT_MAPPING)) {
+        const modelId = profileModels[category];
+        if (modelId) {
+          for (const agentName of agentNames) {
+            const currentModel = typeof opencodeData.agent[agentName] === 'string'
+              ? opencodeData.agent[agentName]
+              : opencodeData.agent[agentName]?.model;
+            
+            if (currentModel !== modelId) {
+              wouldUpdate.push({
+                agent: agentName,
+                from: currentModel || '(not set)',
+                to: modelId,
+                modelId: modelId
+              });
+            }
+          }
+        }
+      }
+      
+      const result = {
+        success: true,
+        data: {
+          backup: null,
+          updated: wouldUpdate.map(u => u.agent),
+          dryRun: true,
+          changes: wouldUpdate
+        }
+      };
+      
+      if (verbose) {
+        console.error(`[verbose] Would update ${wouldUpdate.length} agent(s)`);
+      }
+      
+      output(result);
+      process.exit(0);
+    } catch (err) {
+      error(`Failed to preview changes: ${err.message}`, 'PREVIEW_FAILED');
+    }
+  }
+  
+  // Actual update mode
+  if (verbose) {
+    console.error('[verbose] Creating backup...');
+  }
+  
+  // Create timestamped backup
+  const backupPath = createBackup(opencodePath);
+  if (!backupPath) {
+    error('Failed to create backup of opencode.json', 'BACKUP_FAILED');
+  }
+  
+  if (verbose) {
+    console.error(`[verbose] Backup created: ${backupPath}`);
+  }
+  
+  // Apply profile to opencode.json using the existing function which already supports oc_config.json
+  if (verbose) {
+    console.error('[verbose] Applying profile to opencode.json...');
+  }
+  
+  const result = applyProfileToOpencode(opencodePath, configPath, profileName);
+  
+  if (!result.success) {
+    // Restore backup on failure
+    if (verbose) {
+      console.error('[verbose] Update failed, restoring backup...');
+    }
+    try {
+      fs.copyFileSync(backupPath, opencodePath);
+    } catch (err) {
+      // Best effort restore
+    }
+    error(result.error.message, result.error.code);
+  }
+  
+  if (verbose) {
+    console.error(`[verbose] Updated ${result.updated.length} agent(s)`);
+    for (const { agent } of result.updated) {
+      console.error(`[verbose]   - ${agent}`);
+    }
+  }
+  
+  const outputResult = {
+    success: true,
+    data: {
+      backup: backupPath,
+      updated: result.updated.map(u => u.agent),
+      dryRun: false,
+      details: result.updated
+    }
+  };
+  
+  output(outputResult);
+  process.exit(0);
+}
+
+// Export for use by main router
+module.exports = updateOpencodeJson;

package/get-shit-done/bin/gsd-oc-commands/validate-models.cjs

@@ -0,0 +1,75 @@
+/**
+ * validate-models.cjs — Validate model IDs against opencode models catalog
+ *
+ * Command module that validates one or more model IDs exist in the opencode catalog.
+ * Outputs JSON envelope format with validation results.
+ *
+ * Usage: node validate-models.cjs <model1> [model2...] [--raw]
+ */
+
+const { output, error } = require('../gsd-oc-lib/oc-core.cjs');
+const { getModelCatalog } = require('../gsd-oc-lib/oc-models.cjs');
+
+/**
+ * Main command function
+ *
+ * @param {string} cwd - Current working directory
+ * @param {string[]} args - Command line arguments (model IDs)
+ */
+function validateModels(cwd, args) {
+  const raw = args.includes('--raw');
+  const modelIds = args.filter(arg => !arg.startsWith('--'));
+
+  if (modelIds.length === 0) {
+    error('No model IDs provided. Usage: validate-models <model1> [model2...]', 'INVALID_USAGE');
+  }
+
+  // Fetch model catalog
+  const catalogResult = getModelCatalog();
+  if (!catalogResult.success) {
+    error(catalogResult.error.message, catalogResult.error.code);
+  }
+
+  const validModels = catalogResult.models;
+  const results = [];
+
+  for (const modelId of modelIds) {
+    const isValid = validModels.includes(modelId);
+    results.push({
+      model: modelId,
+      valid: isValid,
+      reason: isValid ? 'Model found in catalog' : 'Model not found in catalog'
+    });
+  }
+
+  const allValid = results.every(r => r.valid);
+  const validCount = results.filter(r => r.valid).length;
+  const invalidCount = results.filter(r => !r.valid).length;
+
+  const result = {
+    success: allValid,
+    data: {
+      total: modelIds.length,
+      valid: validCount,
+      invalid: invalidCount,
+      models: results
+    }
+  };
+
+  if (!allValid) {
+    result.error = {
+      code: 'INVALID_MODELS',
+      message: `${invalidCount} model(s) not found in catalog`
+    };
+  }
+
+  if (raw) {
+    output(result, true, allValid ? 'valid' : 'invalid');
+  } else {
+    output(result);
+  }
+
+  process.exit(allValid ? 0 : 1);
+}
+
+module.exports = validateModels;