gsd-opencode 1.20.2 → 1.20.4

package/commands/gsd/gsd-check-profile.md

@@ -0,0 +1,30 @@
+---
+name: gsd-check-profile
+description: Validate gsd-opencode profile configuration
+allowed-tools:
+  - read
+  - bash
+---
+<objective>
+Validate gsd-opencode profile configuration across both `opencode.json` and `.planning/oc_config.json`, then report results.
+
+Routes to the oc-check-profile workflow which handles:
+- Validating all agent model IDs exist in the opencode models catalog
+- Validating gsd-opencode profile structure and current profile exists
+- Reporting results with severity classification (OK/WARNING/ERROR)
+- Recommending /gsd-set-profile when issues are found
+</objective>
+
+<execution_context>
+@~/.config/opencode/get-shit-done/workflows/oc-check-profile.md
+</execution_context>
+
+<process>
+**Follow the oc-check-profile workflow** from `@~/.config/opencode/get-shit-done/workflows/oc-check-profile.md`.
+
+The workflow handles all logic including:
+1. Running both validations (check-opencode-json and check-config-json)
+2. Classifying results by severity (OK/WARNING/ERROR)
+3. Reporting results with structured diagnostic output
+4. Recommending /gsd-set-profile when errors are found
+</process>

package/get-shit-done/bin/gsd-oc-commands/allow-read-config.cjs

@@ -0,0 +1,235 @@
+/**
+ * allow-read-config.cjs — Add external_directory permission to read GSD config folder
+ *
+ * Creates or updates local opencode.json with permission to access:
+ * ~/.config/opencode/get-shit-done/
+ *
+ * This allows gsd-opencode commands to read workflow files, templates, and
+ * configuration from the global GSD installation directory.
+ *
+ * Usage:
+ *   node allow-read-config.cjs                    # Add read permission
+ *   node allow-read-config.cjs --dry-run          # Preview changes
+ *   node allow-read-config.cjs --verbose          # Verbose output
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { output, error, createBackup } = require('../gsd-oc-lib/oc-core.cjs');
+
+/**
+ * Error codes for allow-read-config operations
+ */
+const ERROR_CODES = {
+  WRITE_FAILED: 'WRITE_FAILED',
+  APPLY_FAILED: 'APPLY_FAILED',
+  ROLLBACK_FAILED: 'ROLLBACK_FAILED',
+  INVALID_ARGS: 'INVALID_ARGS'
+};
+
+/**
+ * Get the GSD config directory path
+ * Uses environment variable if set, otherwise defaults to ~/.config/opencode/get-shit-done
+ *
+ * @returns {string} GSD config directory path
+ */
+function getGsdConfigDir() {
+  const envDir = process.env.OPENCODE_CONFIG_DIR;
+  if (envDir) {
+    return envDir;
+  }
+  
+  const homeDir = os.homedir();
+  return path.join(homeDir, '.config', 'opencode', 'get-shit-done');
+}
+
+/**
+ * Build the external_directory permission pattern
+ *
+ * @param {string} gsdDir - GSD config directory
+ * @returns {string} Permission pattern with wildcard
+ */
+function buildPermissionPattern(gsdDir) {
+  // Use ** for recursive matching (all subdirectories and files)
+  return `${gsdDir}/**`;
+}
+
+/**
+ * Check if permission already exists in opencode.json
+ *
+ * @param {Object} opencodeData - Parsed opencode.json content
+ * @param {string} pattern - Permission pattern to check
+ * @returns {boolean} True if permission exists
+ */
+function permissionExists(opencodeData, pattern) {
+  const permissions = opencodeData.permission;
+  
+  if (!permissions) {
+    return false;
+  }
+  
+  const externalDirPerms = permissions.external_directory;
+  if (!externalDirPerms || typeof externalDirPerms !== 'object') {
+    return false;
+  }
+  
+  // Check if the pattern exists and is set to "allow"
+  return externalDirPerms[pattern] === 'allow';
+}
+
+/**
+ * Main command function
+ *
+ * @param {string} cwd - Current working directory
+ * @param {string[]} args - Command line arguments
+ */
+function allowReadConfig(cwd, args) {
+  const verbose = args.includes('--verbose');
+  const dryRun = args.includes('--dry-run');
+  const raw = args.includes('--raw');
+  
+  const log = verbose ? (...args) => console.error('[allow-read-config]', ...args) : () => {};
+  
+  const opencodePath = path.join(cwd, 'opencode.json');
+  const backupsDir = path.join(cwd, '.planning', 'backups');
+  const gsdConfigDir = getGsdConfigDir();
+  const permissionPattern = buildPermissionPattern(gsdConfigDir);
+  
+  log('Starting allow-read-config command');
+  log(`GSD config directory: ${gsdConfigDir}`);
+  log(`Permission pattern: ${permissionPattern}`);
+  
+  // Check for invalid arguments
+  const validFlags = ['--verbose', '--dry-run', '--raw'];
+  const invalidArgs = args.filter(arg => 
+    arg.startsWith('--') && !validFlags.includes(arg)
+  );
+  
+  if (invalidArgs.length > 0) {
+    error(`Unknown arguments: ${invalidArgs.join(', ')}`, 'INVALID_ARGS');
+  }
+  
+  // Load or create opencode.json
+  let opencodeData;
+  let fileExisted = false;
+  
+  if (fs.existsSync(opencodePath)) {
+    try {
+      const content = fs.readFileSync(opencodePath, 'utf8');
+      opencodeData = JSON.parse(content);
+      fileExisted = true;
+      log('Loaded existing opencode.json');
+    } catch (err) {
+      error(`Failed to parse opencode.json: ${err.message}`, 'INVALID_JSON');
+    }
+  } else {
+    // Create initial opencode.json structure
+    opencodeData = {
+      "$schema": "https://opencode.ai/config.json"
+    };
+    log('Creating new opencode.json');
+  }
+  
+  // Check if permission already exists
+  const exists = permissionExists(opencodeData, permissionPattern);
+  
+  if (exists) {
+    log('Permission already exists');
+    output({
+      success: true,
+      data: {
+        dryRun: dryRun,
+        action: 'permission_exists',
+        pattern: permissionPattern,
+        message: 'Permission already configured'
+      }
+    });
+    process.exit(0);
+  }
+  
+  // Dry-run mode - preview changes
+  if (dryRun) {
+    log('Dry-run mode - no changes will be made');
+    
+    const changes = [];
+    if (!fileExisted) {
+      changes.push('Create opencode.json');
+    }
+    changes.push(`Add external_directory permission: ${permissionPattern}`);
+    
+    output({
+      success: true,
+      data: {
+        dryRun: true,
+        action: 'add_permission',
+        pattern: permissionPattern,
+        gsdConfigDir: gsdConfigDir,
+        changes: changes,
+        message: fileExisted ? 'Would update opencode.json' : 'Would create opencode.json'
+      }
+    });
+    process.exit(0);
+  }
+  
+  // Create backup if file exists
+  let backupPath = null;
+  if (fileExisted) {
+    // Ensure backup directory exists
+    if (!fs.existsSync(backupsDir)) {
+      fs.mkdirSync(backupsDir, { recursive: true });
+    }
+    
+    backupPath = createBackup(opencodePath, backupsDir);
+    log(`Backup created: ${backupPath}`);
+  }
+  
+  // Initialize permission structure if needed
+  if (!opencodeData.permission) {
+    opencodeData.permission = {};
+  }
+  
+  if (!opencodeData.permission.external_directory) {
+    opencodeData.permission.external_directory = {};
+  }
+  
+  // Add the permission
+  opencodeData.permission.external_directory[permissionPattern] = 'allow';
+  
+  log('Permission added to opencode.json');
+  
+  // Write updated opencode.json
+  try {
+    fs.writeFileSync(opencodePath, JSON.stringify(opencodeData, null, 2) + '\n', 'utf8');
+    log('Updated opencode.json');
+  } catch (err) {
+    // Rollback if backup exists
+    if (backupPath) {
+      try {
+        fs.copyFileSync(backupPath, opencodePath);
+      } catch (rollbackErr) {
+        error(
+          `Failed to write opencode.json AND failed to rollback: ${rollbackErr.message}`,
+          'ROLLBACK_FAILED'
+        );
+      }
+    }
+    error(`Failed to write opencode.json: ${err.message}`, 'WRITE_FAILED');
+  }
+  
+  output({
+    success: true,
+    data: {
+      action: 'add_permission',
+      pattern: permissionPattern,
+      gsdConfigDir: gsdConfigDir,
+      opencodePath: opencodePath,
+      backup: backupPath,
+      created: !fileExisted,
+      message: fileExisted ? 'opencode.json updated' : 'opencode.json created'
+    }
+  });
+  process.exit(0);
+}
+
+module.exports = allowReadConfig;

package/get-shit-done/bin/gsd-oc-commands/check-oc-config-json.cjs

@@ -0,0 +1,169 @@
+/**
+ * check-oc-config-json.cjs — Validate profile configuration in .planning/oc_config.json
+ *
+ * Command module that validates .planning/oc_config.json profile configuration.
+ * Validates:
+ * - current_oc_profile field exists and refers to a profile in profiles.presets
+ * - profiles.presets.{current_oc_profile} contains required keys: planning, execution, verification
+ * - All model IDs exist in opencode models catalog
+ * Outputs JSON envelope format with validation results.
+ *
+ * Usage: node check-oc-config-json.cjs [cwd]
+ */
+
+const fs = require('fs');
+const path = require('path');
+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
+ */
+function checkOcConfigJson(cwd, args) {
+  const verbose = args.includes('--verbose');
+  const configPath = path.join(cwd, '.planning', 'oc_config.json');
+
+  // Check if oc_config.json exists
+  if (!fs.existsSync(configPath)) {
+    error('.planning/oc_config.json not found', 'CONFIG_NOT_FOUND');
+  }
+
+  // read and parse config
+  let config;
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    config = JSON.parse(content);
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      error('.planning/oc_config.json is not valid JSON', 'INVALID_JSON');
+    }
+    error(`Failed to read config: ${err.message}`, 'READ_FAILED');
+  }
+
+  const issues = [];
+
+  // Extract profile information
+  const currentOcProfile = config.current_oc_profile;
+  const presets = config.profiles?.presets;
+
+  // Validate current_oc_profile field (required)
+  if (currentOcProfile === undefined) {
+    issues.push({
+      field: 'current_oc_profile',
+      value: '(missing)',
+      reason: 'current_oc_profile field is required'
+    });
+  } else if (presets && typeof presets === 'object' && !presets[currentOcProfile]) {
+    const availableProfiles = presets ? Object.keys(presets).join(', ') : 'none';
+    issues.push({
+      field: 'current_oc_profile',
+      value: currentOcProfile,
+      reason: `Profile "${currentOcProfile}" not found in profiles.presets. Available: ${availableProfiles}`
+    });
+  }
+
+  // Validate profiles.presets section exists
+  if (!presets || typeof presets !== 'object') {
+    issues.push({
+      field: 'profiles.presets',
+      value: '(missing or invalid)',
+      reason: 'profiles.presets section is required'
+    });
+    const result = {
+      success: false,
+      data: {
+        passed: false,
+        current_oc_profile: currentOcProfile || null,
+        profile_data: null,
+        issues
+      },
+      error: {
+        code: 'INVALID_PROFILE',
+        message: `${issues.length} invalid profile configuration(s) found`
+      }
+    };
+    output(result);
+    process.exit(1);
+  }
+
+  // Validate profile structure if current profile exists
+  if (currentOcProfile && presets[currentOcProfile]) {
+    const profile = presets[currentOcProfile];
+
+    // Validate that profile has required keys: planning, execution, verification
+    const requiredKeys = ['planning', 'execution', 'verification'];
+    for (const key of requiredKeys) {
+      if (profile[key] === undefined) {
+        issues.push({
+          field: `profiles.presets.${currentOcProfile}.${key}`,
+          value: '(missing)',
+          reason: `${key} model is required for ${currentOcProfile} profile`
+        });
+      } else if (typeof profile[key] !== 'string') {
+        issues.push({
+          field: `profiles.presets.${currentOcProfile}.${key}`,
+          value: profile[key],
+          reason: `${key} must be a string model ID`
+        });
+      }
+    }
+
+    // Validate model IDs against catalog
+    if (verbose) {
+      console.error('[verbose] Fetching model catalog...');
+    }
+
+    const catalogResult = getModelCatalog();
+    if (!catalogResult.success) {
+      error(catalogResult.error.message, catalogResult.error.code);
+    }
+
+    const validModels = catalogResult.models;
+
+    if (verbose) {
+      console.error(`[verbose] Found ${validModels.length} models in catalog`);
+      console.error('[verbose] Validating profile model IDs...');
+    }
+
+    for (const key of requiredKeys) {
+      if (profile[key] && typeof profile[key] === 'string') {
+        if (!validModels.includes(profile[key])) {
+          issues.push({
+            field: `profiles.presets.${currentOcProfile}.${key}`,
+            value: profile[key],
+            reason: `Model ID not found in opencode models catalog`
+          });
+        } else if (verbose) {
+          console.error(`[verbose] ✓ profiles.presets.${currentOcProfile}.${key}: ${profile[key]} (valid)`);
+        }
+      }
+    }
+  }
+
+  const passed = issues.length === 0;
+
+  const result = {
+    success: passed,
+    data: {
+      passed,
+      current_oc_profile: currentOcProfile || null,
+      profile_data: currentOcProfile && presets ? presets[currentOcProfile] : null,
+      issues
+    }
+  };
+
+  if (!passed) {
+    result.error = {
+      code: 'INVALID_PROFILE',
+      message: `${issues.length} invalid profile configuration(s) found`
+    };
+  }
+
+  output(result);
+  process.exit(passed ? 0 : 1);
+}
+
+module.exports = checkOcConfigJson;

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

@@ -0,0 +1,86 @@
+/**
+ * check-opencode-json.cjs — Validate model IDs in opencode.json
+ *
+ * Command module that validates opencode.json model IDs against the opencode models catalog.
+ * Outputs JSON envelope format with validation results.
+ *
+ * Usage: node check-opencode-json.cjs [cwd] [--verbose]
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { output, error } = require('../gsd-oc-lib/oc-core.cjs');
+const { getModelCatalog, validateModelIds } = require('../gsd-oc-lib/oc-models.cjs');
+
+/**
+ * Main command function
+ *
+ * @param {string} cwd - Current working directory
+ * @param {string[]} args - Command line arguments
+ */
+function checkOpencodeJson(cwd, args) {
+  const verbose = args.includes('--verbose');
+  const opencodePath = path.join(cwd, 'opencode.json');
+
+  // Check if opencode.json exists
+  if (!fs.existsSync(opencodePath)) {
+    error('opencode.json not found in current directory', 'CONFIG_NOT_FOUND');
+  }
+
+  if (verbose) {
+    console.error(`[verbose] Validating: ${opencodePath}`);
+  }
+
+  // Fetch model catalog
+  if (verbose) {
+    console.error('[verbose] Fetching model catalog from opencode models...');
+  }
+
+  const catalogResult = getModelCatalog();
+  if (!catalogResult.success) {
+    error(catalogResult.error.message, catalogResult.error.code);
+  }
+
+  if (verbose) {
+    console.error(`[verbose] Found ${catalogResult.models.length} models in catalog`);
+  }
+
+  // Validate model IDs
+  if (verbose) {
+    console.error('[verbose] Validating model IDs...');
+  }
+
+  try {
+    const validationResult = validateModelIds(opencodePath, catalogResult.models);
+
+    const result = {
+      success: true,
+      data: validationResult
+    };
+
+    // Exit code based on validation result
+    if (validationResult.valid) {
+      output(result);
+      process.exit(0);
+    } else {
+      // Add error details for invalid models
+      result.error = {
+        code: 'INVALID_MODEL_ID',
+        message: `${validationResult.invalidCount} invalid model ID(s) found`
+      };
+      output(result);
+      process.exit(1);
+    }
+  } catch (err) {
+    if (err.message === 'CONFIG_NOT_FOUND') {
+      error('opencode.json not found', 'CONFIG_NOT_FOUND');
+    } else if (err.message === 'INVALID_JSON') {
+      error('opencode.json is not valid JSON', 'INVALID_JSON');
+    } else {
+      error(err.message, 'VALIDATION_FAILED');
+    }
+  }
+}
+
+// Export for use by main router
+module.exports = checkOpencodeJson;

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

@@ -0,0 +1,117 @@
+/**
+ * get-profile.cjs — Retrieve profile definitions from oc_config.json
+ *
+ * Command module that exports getProfile(cwd, args) function with two operation modes:
+ * 1. No parameters: Returns current profile definition
+ * 2. Profile name parameter: Returns specified profile definition
+ *
+ * Output format: JSON envelope {success: true, data: {profileName: {planning, execution, verification}}}
+ * Flags: --raw (output raw JSON without envelope), --verbose (output diagnostics to stderr)
+ *
+ * Usage: node get-profile.cjs [profile-name] [--raw] [--verbose]
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { output, error } = require('../gsd-oc-lib/oc-core.cjs');
+const { loadOcProfileConfig } = require('../gsd-oc-lib/oc-profile-config.cjs');
+
+/**
+ * Main command function
+ *
+ * @param {string} cwd - Current working directory
+ * @param {string[]} args - Command line arguments
+ */
+function getProfile(cwd, args) {
+  const verbose = args.includes('--verbose');
+  const raw = args.includes('--raw');
+  const log = verbose ? (...args) => console.error('[get-profile]', ...args) : () => {};
+
+  // Filter out flags to get profile name argument
+  const profileArgs = args.filter(arg => !arg.startsWith('--'));
+  
+  // Check for too many arguments
+  if (profileArgs.length > 1) {
+    error('Too many arguments. Usage: get-profile [profile-name]', 'INVALID_ARGS');
+  }
+  
+  const profileName = profileArgs.length > 0 ? profileArgs[0] : null;
+
+  log('Loading oc_config.json');
+
+  // Load oc_config.json
+  const loadResult = loadOcProfileConfig(cwd);
+  if (!loadResult.success) {
+    error(loadResult.error.message, loadResult.error.code);
+  }
+
+  const { config, configPath } = loadResult;
+
+  log(`Config loaded from ${configPath}`);
+
+  // ========== MODE 1: No parameters (get current profile) ==========
+  if (!profileName) {
+    log('Mode 1: Getting current profile');
+
+    // Check current_oc_profile is set
+    if (!config.current_oc_profile) {
+      error(
+        'current_oc_profile not set in oc_config.json. Run set-profile first.',
+        'MISSING_CURRENT_PROFILE'
+      );
+    }
+
+    const currentProfileName = config.current_oc_profile;
+    log(`Current profile: ${currentProfileName}`);
+
+    // Check profile exists in profiles.presets
+    const presets = config.profiles?.presets;
+    if (!presets || !presets[currentProfileName]) {
+      const availableProfiles = presets ? Object.keys(presets).join(', ') : 'none';
+      error(
+        `Current profile "${currentProfileName}" not found in profiles.presets. Available profiles: ${availableProfiles}`,
+        'PROFILE_NOT_FOUND'
+      );
+    }
+
+    const profile = presets[currentProfileName];
+    const result = { [currentProfileName]: profile };
+
+    log(`Returning profile definition for "${currentProfileName}"`);
+
+    if (raw) {
+      output(result, true, JSON.stringify(result, null, 2));
+    } else {
+      output({ success: true, data: result });
+    }
+    process.exit(0);
+  }
+
+  // ========== MODE 2: Profile name parameter (get specific profile) ==========
+  log(`Mode 2: Getting profile "${profileName}"`);
+
+  // Check profile exists in profiles.presets
+  // Note: Does NOT require current_oc_profile to be set
+  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'
+    );
+  }
+
+  const profile = presets[profileName];
+  const result = { [profileName]: profile };
+
+  log(`Returning profile definition for "${profileName}"`);
+
+  if (raw) {
+    output(result, true, JSON.stringify(result, null, 2));
+  } else {
+    output({ success: true, data: result });
+  }
+  process.exit(0);
+}
+
+module.exports = getProfile;