gsd-opencode 1.20.2 → 1.20.4

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

@@ -0,0 +1,200 @@
+/**
+ * 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');
+    const config = JSON.parse(content);
+    
+    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
+ * @returns {Object} {success: true, updated: [agentNames]} or {success: false, error: {code, message}}
+ */
+function applyProfileToOpencode(opencodePath, configPath) {
+  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}`
+        }
+      };
+    }
+    
+    // Validate profile_type
+    const profileType = config.profile_type || config.profiles?.profile_type;
+    if (!profileType) {
+      return {
+        success: false,
+        error: {
+          code: 'PROFILE_NOT_FOUND',
+          message: 'profile_type not found in config.json'
+        }
+      };
+    }
+    
+    if (!VALID_PROFILES.includes(profileType)) {
+      return {
+        success: false,
+        error: {
+          code: 'INVALID_PROFILE',
+          message: `Invalid profile_type: "${profileType}". Valid profiles: ${VALID_PROFILES.join(', ')}`
+        }
+      };
+    }
+    
+    // Load opencode.json
+    if (!fs.existsSync(opencodePath)) {
+      return {
+        success: false,
+        error: {
+          code: 'CONFIG_NOT_FOUND',
+          message: `opencode.json not found at ${opencodePath}`
+        }
+      };
+    }
+    
+    const opencodeContent = fs.readFileSync(opencodePath, 'utf8');
+    const opencodeData = JSON.parse(opencodeContent);
+    
+    // Get model assignments from profile
+    // Support both structures: profiles.planning or profiles.models.planning
+    const profiles = config.profiles || {};
+    let profileModels;
+    
+    // Try new structure first: profiles.models.{planning|execution|verification}
+    if (profiles.models && typeof profiles.models === 'object') {
+      profileModels = profiles.models;
+    } else {
+      // Fallback to old structure: profiles.{planning|execution|verification}
+      profileModels = profiles[profileType] || {};
+    }
+    
+    if (!profileModels.planning && !profileModels.execution && !profileModels.verification) {
+      return {
+        success: false,
+        error: {
+          code: 'PROFILE_NOT_FOUND',
+          message: `No model assignments found for profile "${profileType}"`
+        }
+      };
+    }
+    
+    // Apply model assignments to agents
+    const updatedAgents = [];
+    
+    // Initialize agent object if it doesn't exist
+    if (!opencodeData.agent) {
+      opencodeData.agent = {};
+    }
+    
+    // Apply each profile category
+    for (const [category, agentNames] of Object.entries(PROFILE_AGENT_MAPPING)) {
+      const modelId = profileModels[category];
+      
+      if (modelId) {
+        for (const agentName of agentNames) {
+          // Handle both string and object agent configurations
+          if (typeof opencodeData.agent[agentName] === 'string') {
+            opencodeData.agent[agentName] = modelId;
+          } else if (typeof opencodeData.agent[agentName] === 'object' && opencodeData.agent[agentName] !== null) {
+            opencodeData.agent[agentName].model = modelId;
+          } else {
+            opencodeData.agent[agentName] = modelId;
+          }
+          updatedAgents.push(agentName);
+        }
+      }
+    }
+    
+    // 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/lib/oc-core.cjs

@@ -0,0 +1,114 @@
+/**
+ * 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 outputData;
+
+  if (raw && rawValue !== null) {
+    outputData = rawValue;
+  } else {
+    outputData = result;
+  }
+
+  const outputStr = JSON.stringify(outputData, 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/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
+};

package/get-shit-done/bin/test/allow-read-config.test.cjs

@@ -0,0 +1,262 @@
+/**
+ * allow-read-config.test.cjs — Tests for allow-read-config command
+ *
+ * Tests the allow-read-config command functionality:
+ * - Permission creation
+ * - Idempotency (detecting existing permission)
+ * - Dry-run mode
+ * - Backup creation
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const CLI_PATH = path.join(__dirname, '../gsd-oc-commands/allow-read-config.cjs');
+const TOOLS_PATH = path.join(__dirname, '../gsd-oc-tools.cjs');
+
+/**
+ * Create a temporary test directory
+ */
+function createTestDir() {
+  const testDir = path.join(os.tmpdir(), `gsd-oc-test-${Date.now()}`);
+  fs.mkdirSync(testDir, { recursive: true });
+  return testDir;
+}
+
+/**
+ * Clean up test directory
+ */
+function cleanupTestDir(testDir) {
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Run CLI command and parse JSON output
+ */
+function runCLI(testDir, args) {
+  const cmd = `node ${TOOLS_PATH} allow-read-config ${args.join(' ')}`;
+  const output = execSync(cmd, { cwd: testDir, encoding: 'utf8' });
+  return JSON.parse(output);
+}
+
+/**
+ * Test: Create new opencode.json with permission
+ */
+function testCreatePermission() {
+  console.log('Test: Create new opencode.json with permission...');
+  
+  const testDir = createTestDir();
+  
+  try {
+    const result = runCLI(testDir, []);
+    
+    if (!result.success) {
+      throw new Error(`Expected success, got: ${JSON.stringify(result)}`);
+    }
+    
+    if (result.data.action !== 'add_permission') {
+      throw new Error(`Expected action 'add_permission', got: ${result.data.action}`);
+    }
+    
+    if (result.data.created !== true) {
+      throw new Error(`Expected created=true, got: ${result.data.created}`);
+    }
+    
+    // Verify opencode.json was created
+    const opencodePath = path.join(testDir, 'opencode.json');
+    if (!fs.existsSync(opencodePath)) {
+      throw new Error('opencode.json was not created');
+    }
+    
+    const content = JSON.parse(fs.readFileSync(opencodePath, 'utf8'));
+    if (!content.permission?.external_directory) {
+      throw new Error('Permission not added to opencode.json');
+    }
+    
+    console.log('✓ PASS: Create permission\n');
+    return true;
+  } catch (err) {
+    console.error('✗ FAIL:', err.message, '\n');
+    return false;
+  } finally {
+    cleanupTestDir(testDir);
+  }
+}
+
+/**
+ * Test: Idempotency - detect existing permission
+ */
+function testIdempotency() {
+  console.log('Test: Idempotency (detect existing permission)...');
+  
+  const testDir = createTestDir();
+  
+  try {
+    // First call - create permission
+    runCLI(testDir, []);
+    
+    // Second call - should detect existing
+    const result = runCLI(testDir, []);
+    
+    if (!result.success) {
+      throw new Error(`Expected success, got: ${JSON.stringify(result)}`);
+    }
+    
+    if (result.data.action !== 'permission_exists') {
+      throw new Error(`Expected action 'permission_exists', got: ${result.data.action}`);
+    }
+    
+    console.log('✓ PASS: Idempotency\n');
+    return true;
+  } catch (err) {
+    console.error('✗ FAIL:', err.message, '\n');
+    return false;
+  } finally {
+    cleanupTestDir(testDir);
+  }
+}
+
+/**
+ * Test: Dry-run mode
+ */
+function testDryRun() {
+  console.log('Test: Dry-run mode...');
+  
+  const testDir = createTestDir();
+  
+  try {
+    const result = runCLI(testDir, ['--dry-run']);
+    
+    if (!result.success) {
+      throw new Error(`Expected success, got: ${JSON.stringify(result)}`);
+    }
+    
+    if (result.data.dryRun !== true) {
+      throw new Error(`Expected dryRun=true, got: ${result.data.dryRun}`);
+    }
+    
+    // Verify opencode.json was NOT created
+    const opencodePath = path.join(testDir, 'opencode.json');
+    if (fs.existsSync(opencodePath)) {
+      throw new Error('opencode.json should not be created in dry-run mode');
+    }
+    
+    console.log('✓ PASS: Dry-run mode\n');
+    return true;
+  } catch (err) {
+    console.error('✗ FAIL:', err.message, '\n');
+    return false;
+  } finally {
+    cleanupTestDir(testDir);
+  }
+}
+
+/**
+ * Test: Backup creation on update
+ */
+function testBackupCreation() {
+  console.log('Test: Backup creation on update...');
+  
+  const testDir = createTestDir();
+  
+  try {
+    // Create initial opencode.json
+    const opencodePath = path.join(testDir, 'opencode.json');
+    const initialContent = {
+      "$schema": "https://opencode.ai/config.json",
+      "model": "test/model"
+    };
+    fs.writeFileSync(opencodePath, JSON.stringify(initialContent, null, 2) + '\n');
+    
+    // Run allow-read-config
+    const result = runCLI(testDir, []);
+    
+    if (!result.success) {
+      throw new Error(`Expected success, got: ${JSON.stringify(result)}`);
+    }
+    
+    if (!result.data.backup) {
+      throw new Error('Expected backup path, got none');
+    }
+    
+    if (!fs.existsSync(result.data.backup)) {
+      throw new Error(`Backup file does not exist: ${result.data.backup}`);
+    }
+    
+    // Verify backup content matches original
+    const backupContent = JSON.parse(fs.readFileSync(result.data.backup, 'utf8'));
+    if (JSON.stringify(backupContent) !== JSON.stringify(initialContent)) {
+      throw new Error('Backup content does not match original');
+    }
+    
+    console.log('✓ PASS: Backup creation\n');
+    return true;
+  } catch (err) {
+    console.error('✗ FAIL:', err.message, '\n');
+    return false;
+  } finally {
+    cleanupTestDir(testDir);
+  }
+}
+
+/**
+ * Test: Verbose output
+ */
+function testVerbose() {
+  console.log('Test: Verbose output...');
+  
+  const testDir = createTestDir();
+  
+  try {
+    const cmd = `node ${TOOLS_PATH} allow-read-config --verbose`;
+    const output = execSync(cmd, { cwd: testDir, encoding: 'utf8', stdio: 'pipe' });
+    
+    // Verbose output should contain log messages to stderr
+    // We just verify it doesn't crash
+    console.log('✓ PASS: Verbose output\n');
+    return true;
+  } catch (err) {
+    console.error('✗ FAIL:', err.message, '\n');
+    return false;
+  } finally {
+    cleanupTestDir(testDir);
+  }
+}
+
+/**
+ * Run all tests
+ */
+function runTests() {
+  console.log('Running allow-read-config tests...\n');
+  console.log('=' .repeat(50));
+  console.log();
+  
+  const results = [
+    testCreatePermission(),
+    testIdempotency(),
+    testDryRun(),
+    testBackupCreation(),
+    testVerbose()
+  ];
+  
+  const passed = results.filter(r => r).length;
+  const total = results.length;
+  
+  console.log('=' .repeat(50));
+  console.log(`Results: ${passed}/${total} tests passed`);
+  
+  if (passed === total) {
+    console.log('✓ All tests passed!\n');
+    process.exit(0);
+  } else {
+    console.error(`✗ ${total - passed} test(s) failed\n`);
+    process.exit(1);
+  }
+}
+
+// Run tests
+runTests();