gsd-opencode 1.9.1 → 1.10.1

package/commands/gsd/set-model.md

@@ -0,0 +1,77 @@
+---
+name: gsd-set-model
+description: Configure models for a specific profile's stages (planning/execution/verification)
+arguments:
+  - name: profile
+    description: "Profile name: quality, balanced, or budget (optional - will prompt if not provided)"
+    required: false
+agent: gsd-set-model
+tools:
+  - read
+  - write
+  - bash
+  - question
+---
+
+<objective>
+Configure the models assigned to each stage (planning, execution, verification) for a specific profile.
+
+Unlike `/gsd-set-profile` which switches between profiles, this command lets you define *what models* a profile uses. Implementation lives in the `gsd-set-model` agent.
+</objective>
+
+<process>
+
+Run the model configuration flow using the `gsd-set-model` agent.
+
+</process>
+
+<examples>
+
+**Configure the balanced profile:**
+
+```text
+/gsd-set-model balanced
+
+Configuring models for: balanced
+
+Select model for Planning stage:
+> anthropic/claude-sonnet-4-20250514
+
+Select model for Execution stage:
+> anthropic/claude-sonnet-4-20250514
+
+Select model for Verification stage:
+> openai/gpt-4o-mini
+
+✓ Updated balanced profile:
+| Stage | Model |
+|-------|-------|
+| planning | anthropic/claude-sonnet-4-20250514 |
+| execution | anthropic/claude-sonnet-4-20250514 |
+| verification | openai/gpt-4o-mini |
+```
+
+**Interactive mode (no argument):**
+
+```text
+/gsd-set-model
+
+Which profile do you want to configure?
+> Balanced
+
+Configuring models for: balanced
+...
+```
+
+</examples>
+
+<success_criteria>
+
+- [ ] `.planning/config.json` exists (or clear error shown)
+- [ ] User selects a profile (or provides via argument)
+- [ ] User selects models for all three stages from available models
+- [ ] Profile preset is updated in `.planning/config.json`
+- [ ] `opencode.json` is regenerated if the modified profile is active
+- [ ] Clear confirmation shown with updated model assignments
+
+</success_criteria>

package/commands/gsd/set-profile.md

@@ -0,0 +1,46 @@
+---
+name: gsd-set-profile
+description: Switch model profile for GSD agents (quality/balanced/budget)
+arguments:
+  - name: profile
+    description: "Profile name: quality, balanced, or budget"
+    required: true
+agent: gsd-set-profile
+tools:
+  - read
+  - write
+  - bash
+  - question
+---
+
+<objective>
+Switch the project’s active model profile (quality/balanced/budget).
+
+Implementation lives in the `gsd-set-profile` agent so we don’t duplicate the full switching/migration logic in multiple places.
+</objective>
+
+<process>
+
+Run the profile switch using the `gsd-set-profile` agent.
+
+</process>
+
+<examples>
+
+**Switch to budget profile:**
+
+```text
+/gsd-set-profile budget
+
+✓ Active profile set to: budget
+```
+
+**Switch to quality profile:**
+
+```text
+/gsd-set-profile quality
+
+✓ Active profile set to: quality
+```
+
+</examples>

package/commands/gsd/settings.md

@@ -0,0 +1,33 @@
+---
+name: gsd-settings
+description: Configure GSD model profiles and workflow settings
+agent: gsd-settings
+tools:
+  - read
+  - write
+  - bash
+  - question
+---
+
+<objective>
+Open an interactive settings menu.
+
+This delegates the implementation to the `gsd-settings` agent, which manages `.planning/config.json` and regenerates `opencode.json` when needed.
+</objective>
+
+<process>
+
+Run the interactive settings flow using the `gsd-settings` agent.
+
+</process>
+
+<success_criteria>
+
+- [ ] `.planning/` is validated as an existing GSD project (or a clear error is shown)
+- [ ] Current settings are displayed (active profile, effective models, workflow toggles)
+- [ ] User can update profile and workflow toggles via interactive UI
+- [ ] Updates are persisted to `.planning/config.json`
+- [ ] `opencode.json` is regenerated/updated to reflect effective models
+- [ ] A clear confirmation is shown ("GSD ► SETTINGS UPDATED")
+
+</success_criteria>

package/{command → commands}/gsd/verify-work.md

@@ -26,7 +26,7 @@ Output: {phase}-UAT.md tracking all test results. If issues found: diagnosed gap
 </execution_context>
 
 <context>
-Phase: $ARGUMENTS (optional)
+Phase: `$ARGUMENTS` (optional)
 - If provided: Test specific phase (e.g., "4")
 - If not provided: Check for active sessions or prompt for phase
 

package/get-shit-done/references/model-profiles.md

@@ -2,72 +2,103 @@
 
 Model profiles control which OpenCode model each GSD agent uses. This allows balancing quality vs token spend.
 
-## Profile Definitions
-
-| Agent | `quality` | `balanced` | `budget` |
-|-------|-----------|------------|----------|
-| gsd-planner | opus | opus | sonnet |
-| gsd-roadmapper | opus | sonnet | sonnet |
-| gsd-executor | opus | sonnet | sonnet |
-| gsd-phase-researcher | opus | sonnet | haiku |
-| gsd-project-researcher | opus | sonnet | haiku |
-| gsd-research-synthesizer | sonnet | sonnet | haiku |
-| gsd-debugger | opus | sonnet | sonnet |
-| gsd-codebase-mapper | sonnet | haiku | haiku |
-| gsd-verifier | sonnet | sonnet | haiku |
-| gsd-plan-checker | sonnet | sonnet | haiku |
-| gsd-integration-checker | sonnet | sonnet | haiku |
+## Stage-to-Agent Mapping
+
+Agents are grouped by stage. Each profile assigns a model to each stage:
+
+| Stage | Agents |
+|-------|--------|
+| 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, gsd-set-profile, gsd-settings |
+
+## Profile Configuration
+
+Models are **user-configured**, not hardcoded. OpenCode supports multiple providers (Anthropic, OpenAI, local models, etc.), so available models vary per installation.
+
+On first run, `/gsd-settings` runs the **Preset Setup Wizard**:
+
+1. Queries `opencode models` to discover available models
+2. Prompts user to select models for each profile/stage combination
+3. Saves to `.planning/config.json`
+
+Configuration structure:
+
+```json
+{
+  "profiles": {
+    "active_profile": "balanced",
+    "presets": {
+      "quality": { "planning": "...", "execution": "...", "verification": "..." },
+      "balanced": { "planning": "...", "execution": "...", "verification": "..." },
+      "budget": { "planning": "...", "execution": "...", "verification": "..." }
+    }
+  }
+}
+```
 
 ## Profile Philosophy
 
+When configuring presets, consider these guidelines:
+
 **quality** - Maximum reasoning power
-- Opus for all decision-making agents
-- Sonnet for read-only verification
+
+- Use your most capable model for all stages
 - Use when: quota available, critical architecture work
 
 **balanced** (default) - Smart allocation
-- Opus only for planning (where architecture decisions happen)
-- Sonnet for execution and research (follows explicit instructions)
-- Sonnet for verification (needs reasoning, not just pattern matching)
+
+- Strong model for planning (where architecture decisions happen)
+- Mid-tier model for execution (follows explicit instructions)
+- Mid-tier model for verification (needs reasoning, not just pattern matching)
 - Use when: normal development, good balance of quality and cost
 
-**budget** - Minimal Opus usage
-- Sonnet for anything that writes code
-- Haiku for research and verification
+**budget** - Minimal token spend
+
+- Mid-tier model for anything that writes code
+- Lightweight model for research and verification
 - Use when: conserving quota, high-volume work, less critical phases
 
 ## Resolution Logic
 
 Orchestrators resolve model before spawning:
 
+```text
+1. Read .planning/config.json
+2. Get active_profile (default: "balanced")
+3. Look up preset[profile][stage] for the agent's stage
+4. Apply any custom_overrides[profile][stage] if set
+5. Pass model parameter to Task call
 ```
-1. read .planning/config.json
-2. Get model_profile (default: "balanced")
-3. Look up agent in table above
-4. Pass model parameter to Task call
-```
+
+Agent-to-model mappings are written to `opencode.json` by `/gsd-set-profile` and `/gsd-settings`.
 
 ## Switching Profiles
 
 Runtime: `/gsd-set-profile <profile>`
 
-Per-project default: Set in `.planning/config.json`:
+Interactive settings: `/gsd-settings`
+
+Per-project default stored in `.planning/config.json`:
+
 ```json
 {
-  "model_profile": "balanced"
+  "profiles": {
+    "active_profile": "balanced"
+  }
 }
 ```
 
 ## Design Rationale
 
-**Why Opus for gsd-planner?**
+**Why use your strongest model for planning?**
 Planning involves architecture decisions, goal decomposition, and task design. This is where model quality has the highest impact.
 
-**Why Sonnet for gsd-executor?**
+**Why mid-tier for execution?**
 Executors follow explicit PLAN.md instructions. The plan already contains the reasoning; execution is implementation.
 
-**Why Sonnet (not Haiku) for verifiers in balanced?**
-Verification requires goal-backward reasoning - checking if code *delivers* what the phase promised, not just pattern matching. Sonnet handles this well; Haiku may miss subtle gaps.
+**Why mid-tier (not lightweight) for verification?**
+Verification requires goal-backward reasoning - checking if code *delivers* what the phase promised, not just pattern matching. Mid-tier models handle this well; lightweight models may miss subtle gaps.
 
-**Why Haiku for gsd-codebase-mapper?**
-read-only exploration and pattern extraction. No reasoning required, just structured output from file contents.
+**Why lightweight for codebase mapping?**
+Read-only exploration and pattern extraction. No complex reasoning required, just structured output from file contents.

package/get-shit-done/workflows/list-phase-assumptions.md

@@ -7,7 +7,7 @@ Key difference from discuss-phase: This is ANALYSIS of what OpenCode thinks, not
 <process>
 
 <step name="validate_phase" priority="first">
-Phase number: $ARGUMENTS (required)
+Phase number: `$ARGUMENTS` (required)
 
 **If argument missing:**
 

package/get-shit-done/workflows/verify-work.md

@@ -46,7 +46,7 @@ Store resolved models for use in Task calls below.
 find .planning/phases -name "*-UAT.md" -type f 2>/dev/null | head -5
 ```
 
-**If active sessions exist AND no $ARGUMENTS provided:**
+**If active sessions exist AND no `$ARGUMENTS` provided:**
 
 read each file's frontmatter (status, phase) and Current Test section.
 
@@ -68,12 +68,12 @@ Wait for user response.
 - If user replies with number (1, 2) → Load that file, go to `resume_from_file`
 - If user replies with phase number → Treat as new session, go to `create_uat_file`
 
-**If active sessions exist AND $ARGUMENTS provided:**
+**If active sessions exist AND `$ARGUMENTS` provided:**
 
 Check if session exists for that phase. If yes, offer to resume or restart.
 If no, continue to `create_uat_file`.
 
-**If no active sessions AND no $ARGUMENTS:**
+**If no active sessions AND no `$ARGUMENTS`:**
 
 ```
 No active UAT sessions.
@@ -81,7 +81,7 @@ No active UAT sessions.
 Provide a phase number to start testing (e.g., /gsd-verify-work 4)
 ```
 
-**If no active sessions AND $ARGUMENTS provided:**
+**If no active sessions AND `$ARGUMENTS` provided:**
 
 Continue to `create_uat_file`.
 </step>
@@ -89,7 +89,7 @@ Continue to `create_uat_file`.
 <step name="find_summaries">
 **Find what to test:**
 
-Parse $ARGUMENTS as phase number (e.g., "4") or plan number (e.g., "04-02").
+Parse `$ARGUMENTS` as phase number (e.g., "4") or plan number (e.g., "04-02").
 
 ```bash
 # Find phase directory (match both zero-padded and unpadded)

package/lib/constants.js

@@ -0,0 +1,193 @@
+/**
+ * Shared constants for the GSD-OpenCode CLI.
+ * 
+ * This module centralizes all configuration values, file paths, and error codes
+ * used throughout the CLI to ensure consistency and maintainability.
+ * 
+ * All exports are immutable constants. Do not modify these values at runtime.
+ * 
+ * @module constants
+ */
+
+/**
+ * Default global configuration directory path.
+ * Resolved relative to user's home directory.
+ * @type {string}
+ * @example
+ * // On macOS/Linux: ~/.config/opencode
+ * // On Windows: ~\AppData\Roaming\opencode
+ */
+export const DEFAULT_CONFIG_DIR = '.config/opencode';
+
+/**
+ * Local configuration directory name.
+ * Created in the current working directory for project-specific configuration.
+ * @type {string}
+ * @example
+ * // Creates: ./.opencode/ in project root
+ */
+export const LOCAL_CONFIG_DIR = '.opencode';
+
+/**
+ * Name of the version tracking file.
+ * Used to store the installed version of GSD-OpenCode.
+ * Stored in get-shit-done/ directory since it's fully owned by gsd-opencode.
+ * @type {string}
+ */
+export const VERSION_FILE = 'get-shit-done/VERSION';
+
+/**
+ * Regex patterns for path replacement in markdown files.
+ * These patterns are used to update internal references during installation.
+ * @type {Object.<string, RegExp>}
+ */
+export const PATH_PATTERNS = {
+  /**
+   * Pattern to match @gsd-opencode/ references in markdown files.
+   * Used for replacing package references with actual paths.
+   */
+  gsdReference: /@gsd-opencode\//g
+};
+
+/**
+ * Source directories to copy during installation.
+ * These directories contain the core GSD-OpenCode assets.
+ * 
+ * All directories use the 'commands' (plural) structure consistently
+ * in both source and destination. The FileOperations service copies
+ * files directly from source to target without path transformation.
+ * 
+ * @type {string[]}
+ */
+export const DIRECTORIES_TO_COPY = ['agents', 'commands', 'get-shit-done'];
+
+/**
+ * Command directory mapping for source-to-destination path transformation.
+ * 
+ * Since the source package now uses 'commands/' (plural) and the destination
+ * also uses 'commands/' (plural), this mapping ensures consistency.
+ * This enables future transformations if needed.
+ * 
+ * @type {Object.<string, string>}
+ * @example
+ * // During install, files from sourceDir/commands/gsd/ are copied to targetDir/commands/gsd/
+ * const sourceDirName = COMMAND_DIR_MAPPING[destDirName]; // 'commands'
+ */
+export const COMMAND_DIR_MAPPING = {
+  'commands': 'commands'  // Both source and destination use 'commands/'
+};
+
+/**
+ * Name of the manifest file that tracks all installed files.
+ * Used for safe uninstallation with namespace protection.
+ * Stored in get-shit-done/ directory since it's fully owned by gsd-opencode.
+ * @type {string}
+ */
+export const MANIFEST_FILENAME = 'get-shit-done/INSTALLED_FILES.json';
+
+/**
+ * Directory name for uninstall backups.
+ * Created within the installation directory to store backups before removal.
+ * @type {string}
+ */
+export const UNINSTALL_BACKUP_DIR = '.backups';
+
+/**
+ * Legacy command directory name (singular).
+ * Used for detecting and migrating old installations.
+ * @type {string}
+ */
+export const OLD_COMMAND_DIR = 'command';
+
+/**
+ * New command directory name (plural).
+ * Used as the default for fresh installations.
+ * @type {string}
+ */
+export const NEW_COMMAND_DIR = 'commands';
+
+/**
+ * Structure type constants for directory structure detection.
+ * Used to identify which command directory structure is present.
+ * @type {Object.<string, string>}
+ */
+export const STRUCTURE_TYPES = {
+  /** Legacy structure: command/gsd/ (singular) */
+  OLD: 'old',
+  
+  /** New structure: commands/gsd/ (plural) */
+  NEW: 'new',
+  
+  /** Both structures exist (dual/migration state) */
+  DUAL: 'dual',
+  
+  /** Neither structure exists (fresh install) */
+  NONE: 'none'
+};
+
+/**
+ * Allowed namespace patterns for safe uninstallation.
+ * Files in these namespaces are safe to delete during uninstall.
+ * Files outside these namespaces are NEVER deleted, even if tracked.
+ *
+ * Patterns:
+ * - agents/gsd-* (gsd-opencode specific agents)
+ * - command/gsd/* (gsd-opencode specific commands - legacy)
+ * - commands/gsd/* (gsd-opencode specific commands - new)
+ * - skills/gsd-* (gsd-opencode specific skills)
+ * - get-shit-done/* (fully owned by gsd-opencode)
+ *
+ * @type {RegExp[]}
+ */
+export const ALLOWED_NAMESPACES = [
+  /^agents\/gsd-/,      // agents/gsd-* directories
+  /^command\/gsd\//,    // command/gsd/* files (legacy structure)
+  /^commands\/gsd\//,   // commands/gsd/* files (new structure)
+  /^skills\/gsd-/,      // skills/gsd-* directories
+  /^get-shit-done\//    // get-shit-done/ directory - fully owned
+];
+
+/**
+ * Exit codes for different failure modes.
+ * Follows Unix convention where 0 = success, non-zero = error.
+ * @type {Object.<string, number>}
+ */
+export const ERROR_CODES = {
+  /** Operation completed successfully. */
+  SUCCESS: 0,
+  
+  /** General error occurred (unspecified failure). */
+  GENERAL_ERROR: 1,
+  
+  /** Permission denied (insufficient file system permissions). */
+  PERMISSION_ERROR: 2,
+  
+  /** Path traversal detected (security violation). */
+  PATH_TRAVERSAL: 3,
+  
+  /** Process interrupted by user (SIGINT, Ctrl+C). */
+  INTERRUPTED: 130
+};
+
+/**
+ * Default export combining all constants.
+ * Useful for importing all constants at once.
+ * 
+ * @example
+ * import constants from './lib/constants.js';
+ * console.log(constants.DEFAULT_CONFIG_DIR);
+ */
+export default {
+  DEFAULT_CONFIG_DIR,
+  LOCAL_CONFIG_DIR,
+  VERSION_FILE,
+  PATH_PATTERNS,
+  DIRECTORIES_TO_COPY,
+  MANIFEST_FILENAME,
+  UNINSTALL_BACKUP_DIR,
+  OLD_COMMAND_DIR,
+  NEW_COMMAND_DIR,
+  STRUCTURE_TYPES,
+  ALLOWED_NAMESPACES,
+  ERROR_CODES
+};

package/package.json

@@ -1,14 +1,9 @@
 {
   "name": "gsd-opencode",
-  "version": "1.9.1",
-  "description": "A meta-prompting, context engineering and spec-driven development system for OpenCode by TÂCHES.",
-  "keywords": [
-    "opencode",
-    "ai",
-    "meta-prompting",
-    "context-engineering",
-    "spec-driven-development"
-  ],
+  "version": "1.10.1",
+  "description": "GSD-OpenCode distribution manager - install, verify, and maintain your GSD-OpenCode installation",
+  "type": "module",
+  "main": "bin/gsd.js",
   "homepage": "https://github.com/rokicool/gsd-opencode#readme",
   "bugs": {
     "url": "https://github.com/rokicool/gsd-opencode/issues"
@@ -17,23 +12,42 @@
     "type": "git",
     "url": "git+https://github.com/rokicool/gsd-opencode.git"
   },
-  "license": "MIT",
-  "author": "TÂCHES & rokicool",
-  "type": "commonjs",
-  "main": "index.js",
   "bin": {
-    "gsd-opencode": "bin/install.js"
+    "gsd-opencode": "bin/gsd.js",
+    "gsd-install": "bin/gsd-install.js"
   },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "opencode",
+    "ai",
+    "meta-prompting",
+    "context-engineering",
+    "spec-driven-development"
+  ],
+  "author": "TÂCHES & rokicool",
+  "license": "MIT",
   "files": [
     "agents",
     "bin",
-    "command",
-    "get-shit-done"
+    "commands",
+    "get-shit-done",
+    "src",
+    "lib"
   ],
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
   "engines": {
-    "node": ">=16.7.0"
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@inquirer/prompts": "^8.2.0",
+    "chalk": "^5.6.2",
+    "commander": "^12.1.0",
+    "ora": "^9.3.0"
+  },
+  "devDependencies": {
+    "vitest": "^3.0.0"
   }
 }