gsd-opencode 1.20.1 → 1.20.3

package/get-shit-done/bin/gsd-oc-lib/oc-config.cjs

@@ -0,0 +1,205 @@
+/**
+ * oc-config.cjs — Profile configuration operations for gsd-oc-tools CLI
+ *
+ * Provides functions for loading profile config and applying model assignments to opencode.json.
+ * Follows gsd-tools.cjs architecture pattern.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Valid profile types whitelist
+ */
+const VALID_PROFILES = ['simple', 'smart', 'genius'];
+
+/**
+ * Profile to agent mapping
+ * Maps profile keys to opencode.json agent names
+ */
+const PROFILE_AGENT_MAPPING = {
+  // Planning agents
+  planning: [
+    'gsd-planner',
+    'gsd-plan-checker',
+    'gsd-phase-researcher',
+    'gsd-roadmapper',
+    'gsd-project-researcher',
+    'gsd-research-synthesizer',
+    'gsd-codebase-mapper'
+  ],
+  // Execution agents
+  execution: [
+    'gsd-executor',
+    'gsd-debugger'
+  ],
+  // Verification agents
+  verification: [
+    'gsd-verifier',
+    'gsd-integration-checker'
+  ]
+};
+
+/**
+ * Load profile configuration from .planning/config.json
+ *
+ * @param {string} cwd - Current working directory
+ * @returns {Object|null} Parsed config object or null on error
+ */
+function loadProfileConfig(cwd) {
+  try {
+    const configPath = path.join(cwd, '.planning', 'config.json');
+    
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    
+    const content = fs.readFileSync(configPath, 'utf8');
+    let config = JSON.parse(content);
+    
+    // Auto-migrate old key name: current_os_profile → current_oc_profile
+    if (config.current_os_profile && !config.current_oc_profile) {
+      config.current_oc_profile = config.current_os_profile;
+      delete config.current_os_profile;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+    }
+    
+    return config;
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Apply profile configuration to opencode.json
+ * Updates agent model assignments based on profile
+ *
+ * @param {string} opencodePath - Path to opencode.json
+ * @param {string} configPath - Path to .planning/config.json
+ * @param {string} [profileName] - Optional profile name to use (overrides current_oc_profile)
+ * @returns {Object} {success: true, updated: [agentNames]} or {success: false, error: {code, message}}
+ */
+function applyProfileToOpencode(opencodePath, configPath, profileName = null) {
+  try {
+    // Load profile config
+    let config;
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, 'utf8');
+      config = JSON.parse(content);
+    } else {
+      return {
+        success: false,
+        error: {
+          code: 'CONFIG_NOT_FOUND',
+          message: `.planning/config.json not found at ${configPath}`
+        }
+      };
+    }
+    
+    // Determine which profile to use
+    const targetProfile = profileName || config.current_oc_profile;
+    
+    if (!targetProfile) {
+      return {
+        success: false,
+        error: {
+          code: 'PROFILE_NOT_FOUND',
+          message: 'current_oc_profile not found in config.json. Run set-profile with a profile name first.'
+        }
+      };
+    }
+    
+    // Validate profile exists in profiles.presets
+    const presets = config.profiles?.presets;
+    if (!presets || !presets[targetProfile]) {
+      const availableProfiles = presets ? Object.keys(presets).join(', ') : 'none';
+      return {
+        success: false,
+        error: {
+          code: 'PROFILE_NOT_FOUND',
+          message: `Profile "${targetProfile}" not found in profiles.presets. Available profiles: ${availableProfiles}`
+        }
+      };
+    }
+    
+    // Load or create opencode.json
+    let opencodeData;
+    if (!fs.existsSync(opencodePath)) {
+      // Create initial opencode.json structure
+      opencodeData = {
+        "$schema": "https://opencode.ai/config.json",
+        "agent": {}
+      };
+    } else {
+      // Load existing opencode.json
+      const opencodeContent = fs.readFileSync(opencodePath, 'utf8');
+      opencodeData = JSON.parse(opencodeContent);
+      
+      // Ensure agent object exists
+      if (!opencodeData.agent) {
+        opencodeData.agent = {};
+      }
+    }
+    
+    // Get model assignments from profiles.presets.{profile_name}.models
+    const profileModels = presets[targetProfile];
+    
+    if (!profileModels.planning && !profileModels.execution && !profileModels.verification) {
+      return {
+        success: false,
+        error: {
+          code: 'PROFILE_NOT_FOUND',
+          message: `No model assignments found for profile "${targetProfile}"`
+        }
+      };
+    }
+    
+    // Apply model assignments to agents (MERGE - preserve non-gsd agents)
+    const updatedAgents = [];
+    
+    // Initialize agent object if it doesn't exist
+    if (!opencodeData.agent) {
+      opencodeData.agent = {};
+    }
+    
+    // Apply each profile category - ONLY update gsd-* agents
+    for (const [category, agentNames] of Object.entries(PROFILE_AGENT_MAPPING)) {
+      const modelId = profileModels[category];
+      
+      if (modelId) {
+        for (const agentName of agentNames) {
+          // Only update gsd-* agents, preserve all others
+          if (typeof opencodeData.agent[agentName] === 'object' && opencodeData.agent[agentName] !== null) {
+            opencodeData.agent[agentName].model = modelId;
+          } else {
+            opencodeData.agent[agentName] = { model: modelId };
+          }
+          updatedAgents.push({ agent: agentName, model: modelId });
+        }
+      }
+    }
+    
+    // write updated opencode.json
+    fs.writeFileSync(opencodePath, JSON.stringify(opencodeData, null, 2) + '\n', 'utf8');
+    
+    return {
+      success: true,
+      updated: updatedAgents
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: {
+        code: 'UPDATE_FAILED',
+        message: `Failed to apply profile: ${err.message}`
+      }
+    };
+  }
+}
+
+module.exports = {
+  loadProfileConfig,
+  applyProfileToOpencode,
+  VALID_PROFILES,
+  PROFILE_AGENT_MAPPING
+};

package/get-shit-done/bin/gsd-oc-lib/oc-core.cjs

@@ -0,0 +1,113 @@
+/**
+ * oc-core.cjs — Shared utilities for gsd-oc-tools CLI
+ *
+ * Provides common functions for output formatting, error handling, file operations.
+ * Follows gsd-tools.cjs architecture pattern.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Output result in JSON envelope format
+ * Large payloads (>50KB) are written to temp file with @file: prefix
+ *
+ * @param {Object} result - The result data to output
+ * @param {boolean} raw - If true, output raw value instead of envelope
+ * @param {*} rawValue - The raw value to output if raw=true
+ */
+function output(result, raw = false, rawValue = null) {
+  let outputStr;
+
+  if (raw && rawValue !== null) {
+    // rawValue is already stringified, use it directly
+    outputStr = rawValue;
+  } else {
+    outputStr = JSON.stringify(result, null, 2);
+  }
+
+  // Large payload handling (>50KB)
+  if (outputStr.length > 50 * 1024) {
+    const tempFile = path.join(require('os').tmpdir(), `gsd-oc-${Date.now()}.json`);
+    fs.writeFileSync(tempFile, outputStr, 'utf8');
+    console.log(`@file:${tempFile}`);
+  } else {
+    console.log(outputStr);
+  }
+}
+
+/**
+ * Output error in standardized envelope format to stderr
+ *
+ * @param {string} message - Error message
+ * @param {string} code - Error code (e.g., 'CONFIG_NOT_FOUND', 'INVALID_JSON')
+ */
+function error(message, code = 'UNKNOWN_ERROR') {
+  const errorEnvelope = {
+    success: false,
+    error: {
+      code,
+      message
+    }
+  };
+  console.error(JSON.stringify(errorEnvelope, null, 2));
+  process.exit(1);
+}
+
+/**
+ * Safely read a file, returning null on failure
+ *
+ * @param {string} filePath - Path to file
+ * @returns {string|null} File contents or null
+ */
+function safeReadFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Create timestamped backup of a file
+ *
+ * @param {string} filePath - Path to file to backup
+ * @param {string} backupDir - Directory for backups (.opencode-backups/)
+ * @returns {string|null} Backup file path or null on failure
+ */
+function createBackup(filePath, backupDir = '.opencode-backups') {
+  try {
+    // Ensure backup directory exists
+    if (!fs.existsSync(backupDir)) {
+      fs.mkdirSync(backupDir, { recursive: true });
+    }
+
+    // read original file
+    const content = fs.readFileSync(filePath, 'utf8');
+
+    // Create timestamped filename (YYYYMMDD-HHmmss-SSS format)
+    const now = new Date();
+    const timestamp = now.toISOString()
+      .replace(/[-:T]/g, '')
+      .replace(/\.\d{3}Z$/, '')
+      .replace(/(\d{8})(\d{6})(\d{3})/, '$1-$2-$3');
+
+    const fileName = path.basename(filePath);
+    const backupFileName = `${timestamp}-${fileName}`;
+    const backupPath = path.join(backupDir, backupFileName);
+
+    // write backup
+    fs.writeFileSync(backupPath, content, 'utf8');
+
+    return backupPath;
+  } catch (err) {
+    return null;
+  }
+}
+
+module.exports = {
+  output,
+  error,
+  safeReadFile,
+  createBackup
+};

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

@@ -0,0 +1,133 @@
+/**
+ * oc-models.cjs — Model catalog operations for gsd-oc-tools CLI
+ *
+ * Provides functions for fetching and validating model IDs against opencode models output.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Fetch model catalog from opencode models command
+ *
+ * @returns {Object} {success: boolean, models: string[]} or {success: false, error: {...}}
+ */
+function getModelCatalog() {
+  try {
+    const output = execSync('opencode models', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    // Parse output (one model per line)
+    const models = output
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line.length > 0);
+
+    return {
+      success: true,
+      models
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: {
+        code: 'FETCH_FAILED',
+        message: `Failed to fetch model catalog: ${err.message}`
+      }
+    };
+  }
+}
+
+/**
+ * Validate model IDs in opencode.json against valid models list
+ *
+ * @param {string} opencodePath - Path to opencode.json file
+ * @param {string[]} validModels - Array of valid model IDs
+ * @returns {Object} {valid, total, validCount, invalidCount, issues: [{agent, model, reason}]}
+ */
+function validateModelIds(opencodePath, validModels) {
+  const issues = [];
+  let total = 0;
+  let validCount = 0;
+  let invalidCount = 0;
+
+  try {
+    const content = fs.readFileSync(opencodePath, 'utf8');
+    const opencodeData = JSON.parse(content);
+
+    // Look for agent model assignments
+    // Common patterns: agent.model, profiles.*.model, models.*
+    const assignments = [];
+
+    // Check for agents at root level
+    if (opencodeData.agent && typeof opencodeData.agent === 'object') {
+      Object.entries(opencodeData.agent).forEach(([agentName, config]) => {
+        if (typeof config === 'string') {
+          assignments.push({ agent: `agent.${agentName}`, model: config });
+        } else if (config && typeof config === 'object' && config.model) {
+          assignments.push({ agent: `agent.${agentName}`, model: config.model });
+        }
+      });
+    }
+
+    // Check for profiles
+    if (opencodeData.profiles && typeof opencodeData.profiles === 'object') {
+      Object.entries(opencodeData.profiles).forEach(([profileName, config]) => {
+        if (config && typeof config === 'object') {
+          Object.entries(config).forEach(([key, value]) => {
+            if (key.includes('model') && typeof value === 'string') {
+              assignments.push({ agent: `profiles.${profileName}.${key}`, model: value });
+            }
+          });
+        }
+      });
+    }
+
+    // Check for models at root level
+    if (opencodeData.models && typeof opencodeData.models === 'object') {
+      Object.entries(opencodeData.models).forEach(([modelName, modelId]) => {
+        if (typeof modelId === 'string') {
+          assignments.push({ agent: `models.${modelName}`, model: modelId });
+        }
+      });
+    }
+
+    // Validate each assignment
+    total = assignments.length;
+    for (const { agent, model } of assignments) {
+      if (validModels.includes(model)) {
+        validCount++;
+      } else {
+        invalidCount++;
+        issues.push({
+          agent,
+          model,
+          reason: 'Model ID not found in opencode models catalog'
+        });
+      }
+    }
+
+    return {
+      valid: invalidCount === 0,
+      total,
+      validCount,
+      invalidCount,
+      issues
+    };
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error('CONFIG_NOT_FOUND');
+    } else if (err instanceof SyntaxError) {
+      throw new Error('INVALID_JSON');
+    }
+    throw err;
+  }
+}
+
+module.exports = {
+  getModelCatalog,
+  validateModelIds
+};