gsd-opencode 1.20.1 → 1.20.3

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/commands/gsd/gsd-research-phase.md

@@ -136,7 +136,7 @@ write to: .planning/phases/${PHASE}-{slug}/${PHASE}-RESEARCH.md
 ```
 task(
   prompt="First, read ~/.config/opencode/agents/gsd-phase-researcher.md for your role and instructions.\n\n" + filled_prompt,
-  subagent_type="task",
+  subagent_type="general",
   model="{researcher_model}",
   description="Research Phase {phase}"
 )
@@ -172,7 +172,7 @@ Continue research for Phase {phase_number}: {phase_name}
 ```
 task(
   prompt="First, read ~/.config/opencode/agents/gsd-phase-researcher.md for your role and instructions.\n\n" + continuation_prompt,
-  subagent_type="task",
+  subagent_type="general",
   model="{researcher_model}",
   description="Continue research Phase {phase}"
 )

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;