get-shit-done-cc 1.9.6 → 1.9.11

package/README.md

@@ -8,8 +8,9 @@
 
 [![npm version](https://img.shields.io/npm/v/get-shit-done-cc?style=for-the-badge&logo=npm&logoColor=white&color=CB3837)](https://www.npmjs.com/package/get-shit-done-cc)
 [![npm downloads](https://img.shields.io/npm/dm/get-shit-done-cc?style=for-the-badge&logo=npm&logoColor=white&color=CB3837)](https://www.npmjs.com/package/get-shit-done-cc)
-[![License](https://img.shields.io/badge/license-MIT-blue?style=for-the-badge)](LICENSE)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Server-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/5JJgD5svVS)
 [![GitHub stars](https://img.shields.io/github/stars/glittercowboy/get-shit-done?style=for-the-badge&logo=github&color=181717)](https://github.com/glittercowboy/get-shit-done)
+[![License](https://img.shields.io/badge/license-MIT-blue?style=for-the-badge)](LICENSE)
 
 <br>
 
@@ -440,6 +441,7 @@ You're never locked in. The system adapts.
 | `/gsd:help` | Show all commands and usage guide |
 | `/gsd:whats-new` | See what changed since your installed version |
 | `/gsd:update` | Update GSD with changelog preview |
+| `/gsd:join-discord` | Join the GSD Discord community |
 
 ### Brownfield
 
@@ -553,6 +555,22 @@ CLAUDE_CONFIG_DIR=/home/youruser/.claude npx get-shit-done-cc --global
 ```
 This ensures absolute paths are used instead of `~` which may not expand correctly in containers.
 
+### Uninstalling
+
+To remove GSD completely:
+
+```bash
+# Global installs
+npx get-shit-done-cc --claude --global --uninstall
+npx get-shit-done-cc --opencode --global --uninstall
+
+# Local installs (current project)
+npx get-shit-done-cc --claude --local --uninstall
+npx get-shit-done-cc --opencode --local --uninstall
+```
+
+This removes all GSD commands, agents, hooks, and settings while preserving your other configurations.
+
 ---
 
 ## Community Ports

package/bin/install.js

@@ -22,6 +22,7 @@ const hasLocal = args.includes('--local') || args.includes('-l');
 const hasOpencode = args.includes('--opencode');
 const hasClaude = args.includes('--claude');
 const hasBoth = args.includes('--both');
+const hasUninstall = args.includes('--uninstall') || args.includes('-u');
 
 // Runtime selection - can be set by flags or interactive prompt
 let selectedRuntimes = [];
@@ -33,11 +34,60 @@ if (hasBoth) {
   selectedRuntimes = ['claude'];
 }
 
-// Helper to get directory name for a runtime
+// Helper to get directory name for a runtime (used for local/project installs)
 function getDirName(runtime) {
   return runtime === 'opencode' ? '.opencode' : '.claude';
 }
 
+/**
+ * Get the global config directory for OpenCode
+ * OpenCode follows XDG Base Directory spec and uses ~/.config/opencode/
+ * Priority: OPENCODE_CONFIG_DIR > dirname(OPENCODE_CONFIG) > XDG_CONFIG_HOME/opencode > ~/.config/opencode
+ */
+function getOpencodeGlobalDir() {
+  // 1. Explicit OPENCODE_CONFIG_DIR env var
+  if (process.env.OPENCODE_CONFIG_DIR) {
+    return expandTilde(process.env.OPENCODE_CONFIG_DIR);
+  }
+  
+  // 2. OPENCODE_CONFIG env var (use its directory)
+  if (process.env.OPENCODE_CONFIG) {
+    return path.dirname(expandTilde(process.env.OPENCODE_CONFIG));
+  }
+  
+  // 3. XDG_CONFIG_HOME/opencode
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(expandTilde(process.env.XDG_CONFIG_HOME), 'opencode');
+  }
+  
+  // 4. Default: ~/.config/opencode (XDG default)
+  return path.join(os.homedir(), '.config', 'opencode');
+}
+
+/**
+ * Get the global config directory for a runtime
+ * @param {string} runtime - 'claude' or 'opencode'
+ * @param {string|null} explicitDir - Explicit directory from --config-dir flag
+ */
+function getGlobalDir(runtime, explicitDir = null) {
+  if (runtime === 'opencode') {
+    // For OpenCode, --config-dir overrides env vars
+    if (explicitDir) {
+      return expandTilde(explicitDir);
+    }
+    return getOpencodeGlobalDir();
+  }
+  
+  // Claude Code: --config-dir > CLAUDE_CONFIG_DIR > ~/.claude
+  if (explicitDir) {
+    return expandTilde(explicitDir);
+  }
+  if (process.env.CLAUDE_CONFIG_DIR) {
+    return expandTilde(process.env.CLAUDE_CONFIG_DIR);
+  }
+  return path.join(os.homedir(), '.claude');
+}
+
 const banner = `
 ${cyan}   ██████╗ ███████╗██████╗
   ██╔════╝ ██╔════╝██╔══██╗
@@ -91,6 +141,7 @@ if (hasHelp) {
     ${cyan}--claude${reset}                  Install for Claude Code only
     ${cyan}--opencode${reset}                Install for OpenCode only
     ${cyan}--both${reset}                    Install for both Claude Code and OpenCode
+    ${cyan}-u, --uninstall${reset}           Uninstall GSD (remove all GSD files)
     ${cyan}-c, --config-dir <path>${reset}   Specify custom config directory
     ${cyan}-h, --help${reset}                Show this help message
     ${cyan}--force-statusline${reset}        Replace existing statusline config
@@ -114,6 +165,12 @@ if (hasHelp) {
     ${dim}# Install to current project only${reset}
     npx get-shit-done-cc --claude --local
 
+    ${dim}# Uninstall GSD from Claude Code globally${reset}
+    npx get-shit-done-cc --claude --global --uninstall
+
+    ${dim}# Uninstall GSD from current project${reset}
+    npx get-shit-done-cc --claude --local --uninstall
+
   ${yellow}Notes:${reset}
     The --config-dir option is useful when you have multiple Claude Code
     configurations (e.g., for different subscriptions). It takes priority
@@ -220,10 +277,10 @@ function convertClaudeToOpencodeFrontmatter(content) {
   convertedContent = convertedContent.replace(/\bAskUserQuestion\b/g, 'question');
   convertedContent = convertedContent.replace(/\bSlashCommand\b/g, 'skill');
   convertedContent = convertedContent.replace(/\bTodoWrite\b/g, 'todowrite');
-  // Replace /gsd:command with /gsd/command for opencode
-  convertedContent = convertedContent.replace(/\/gsd:/g, '/gsd/');
-  // Replace ~/.claude with ~/.opencode
-  convertedContent = convertedContent.replace(/~\/\.claude\b/g, '~/.opencode');
+  // Replace /gsd:command with /gsd-command for opencode (flat command structure)
+  convertedContent = convertedContent.replace(/\/gsd:/g, '/gsd-');
+  // Replace ~/.claude with ~/.config/opencode (OpenCode's correct config location)
+  convertedContent = convertedContent.replace(/~\/\.claude\b/g, '~/.config/opencode');
 
   // Check if content has frontmatter
   if (!convertedContent.startsWith('---')) {
@@ -314,6 +371,63 @@ function convertClaudeToOpencodeFrontmatter(content) {
   return `---\n${newFrontmatter}\n---${body}`;
 }
 
+/**
+ * Copy commands to a flat structure for OpenCode
+ * OpenCode expects: command/gsd-help.md (invoked as /gsd-help)
+ * Source structure: commands/gsd/help.md
+ * 
+ * @param {string} srcDir - Source directory (e.g., commands/gsd/)
+ * @param {string} destDir - Destination directory (e.g., command/)
+ * @param {string} prefix - Prefix for filenames (e.g., 'gsd')
+ * @param {string} pathPrefix - Path prefix for file references
+ * @param {string} runtime - Target runtime ('claude' or 'opencode')
+ */
+function copyFlattenedCommands(srcDir, destDir, prefix, pathPrefix, runtime) {
+  if (!fs.existsSync(srcDir)) {
+    return;
+  }
+  
+  // Remove old gsd-*.md files before copying new ones
+  if (fs.existsSync(destDir)) {
+    for (const file of fs.readdirSync(destDir)) {
+      if (file.startsWith(`${prefix}-`) && file.endsWith('.md')) {
+        fs.unlinkSync(path.join(destDir, file));
+      }
+    }
+  } else {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+  
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    
+    if (entry.isDirectory()) {
+      // Recurse into subdirectories, adding to prefix
+      // e.g., commands/gsd/debug/start.md -> command/gsd-debug-start.md
+      copyFlattenedCommands(srcPath, destDir, `${prefix}-${entry.name}`, pathPrefix, runtime);
+    } else if (entry.name.endsWith('.md')) {
+      // Flatten: help.md -> gsd-help.md
+      const baseName = entry.name.replace('.md', '');
+      const destName = `${prefix}-${baseName}.md`;
+      const destPath = path.join(destDir, destName);
+      
+      // Read, transform, and write
+      let content = fs.readFileSync(srcPath, 'utf8');
+      // Replace path references
+      const claudeDirRegex = /~\/\.claude\//g;
+      const opencodeDirRegex = /~\/\.opencode\//g;
+      content = content.replace(claudeDirRegex, pathPrefix);
+      content = content.replace(opencodeDirRegex, pathPrefix);
+      // Convert frontmatter for opencode compatibility
+      content = convertClaudeToOpencodeFrontmatter(content);
+      
+      fs.writeFileSync(destPath, content);
+    }
+  }
+}
+
 /**
  * Recursively copy directory, replacing paths in .md files
  * Deletes existing destDir first to remove orphaned files from previous versions
@@ -419,12 +533,214 @@ function cleanupOrphanedHooks(settings) {
   return settings;
 }
 
+/**
+ * Uninstall GSD from the specified directory for a specific runtime
+ * Removes only GSD-specific files/directories, preserves user content
+ * @param {boolean} isGlobal - Whether to uninstall from global or local
+ * @param {string} runtime - Target runtime ('claude' or 'opencode')
+ */
+function uninstall(isGlobal, runtime = 'claude') {
+  const isOpencode = runtime === 'opencode';
+  const dirName = getDirName(runtime);
+
+  // Get the target directory based on runtime and install type
+  const targetDir = isGlobal
+    ? getGlobalDir(runtime, explicitConfigDir)
+    : path.join(process.cwd(), dirName);
+
+  const locationLabel = isGlobal
+    ? targetDir.replace(os.homedir(), '~')
+    : targetDir.replace(process.cwd(), '.');
+
+  const runtimeLabel = isOpencode ? 'OpenCode' : 'Claude Code';
+  console.log(`  Uninstalling GSD from ${cyan}${runtimeLabel}${reset} at ${cyan}${locationLabel}${reset}\n`);
+
+  // Check if target directory exists
+  if (!fs.existsSync(targetDir)) {
+    console.log(`  ${yellow}⚠${reset} Directory does not exist: ${locationLabel}`);
+    console.log(`  Nothing to uninstall.\n`);
+    return;
+  }
+
+  let removedCount = 0;
+
+  // 1. Remove GSD commands directory
+  if (isOpencode) {
+    // OpenCode: remove command/gsd-*.md files
+    const commandDir = path.join(targetDir, 'command');
+    if (fs.existsSync(commandDir)) {
+      const files = fs.readdirSync(commandDir);
+      for (const file of files) {
+        if (file.startsWith('gsd-') && file.endsWith('.md')) {
+          fs.unlinkSync(path.join(commandDir, file));
+          removedCount++;
+        }
+      }
+      console.log(`  ${green}✓${reset} Removed GSD commands from command/`);
+    }
+  } else {
+    // Claude Code: remove commands/gsd/ directory
+    const gsdCommandsDir = path.join(targetDir, 'commands', 'gsd');
+    if (fs.existsSync(gsdCommandsDir)) {
+      fs.rmSync(gsdCommandsDir, { recursive: true });
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removed commands/gsd/`);
+    }
+  }
+
+  // 2. Remove get-shit-done directory
+  const gsdDir = path.join(targetDir, 'get-shit-done');
+  if (fs.existsSync(gsdDir)) {
+    fs.rmSync(gsdDir, { recursive: true });
+    removedCount++;
+    console.log(`  ${green}✓${reset} Removed get-shit-done/`);
+  }
+
+  // 3. Remove GSD agents (gsd-*.md files only)
+  const agentsDir = path.join(targetDir, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    const files = fs.readdirSync(agentsDir);
+    let agentCount = 0;
+    for (const file of files) {
+      if (file.startsWith('gsd-') && file.endsWith('.md')) {
+        fs.unlinkSync(path.join(agentsDir, file));
+        agentCount++;
+      }
+    }
+    if (agentCount > 0) {
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removed ${agentCount} GSD agents`);
+    }
+  }
+
+  // 4. Remove GSD hooks
+  const hooksDir = path.join(targetDir, 'hooks');
+  if (fs.existsSync(hooksDir)) {
+    const gsdHooks = ['gsd-statusline.js', 'gsd-check-update.js', 'gsd-check-update.sh'];
+    let hookCount = 0;
+    for (const hook of gsdHooks) {
+      const hookPath = path.join(hooksDir, hook);
+      if (fs.existsSync(hookPath)) {
+        fs.unlinkSync(hookPath);
+        hookCount++;
+      }
+    }
+    if (hookCount > 0) {
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removed ${hookCount} GSD hooks`);
+    }
+  }
+
+  // 5. Clean up settings.json (remove GSD hooks and statusline)
+  const settingsPath = path.join(targetDir, 'settings.json');
+  if (fs.existsSync(settingsPath)) {
+    let settings = readSettings(settingsPath);
+    let settingsModified = false;
+
+    // Remove GSD statusline if it references our hook
+    if (settings.statusLine && settings.statusLine.command &&
+        settings.statusLine.command.includes('gsd-statusline')) {
+      delete settings.statusLine;
+      settingsModified = true;
+      console.log(`  ${green}✓${reset} Removed GSD statusline from settings`);
+    }
+
+    // Remove GSD hooks from SessionStart
+    if (settings.hooks && settings.hooks.SessionStart) {
+      const before = settings.hooks.SessionStart.length;
+      settings.hooks.SessionStart = settings.hooks.SessionStart.filter(entry => {
+        if (entry.hooks && Array.isArray(entry.hooks)) {
+          // Filter out GSD hooks
+          const hasGsdHook = entry.hooks.some(h =>
+            h.command && (h.command.includes('gsd-check-update') || h.command.includes('gsd-statusline'))
+          );
+          return !hasGsdHook;
+        }
+        return true;
+      });
+      if (settings.hooks.SessionStart.length < before) {
+        settingsModified = true;
+        console.log(`  ${green}✓${reset} Removed GSD hooks from settings`);
+      }
+      // Clean up empty array
+      if (settings.hooks.SessionStart.length === 0) {
+        delete settings.hooks.SessionStart;
+      }
+      // Clean up empty hooks object
+      if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+      }
+    }
+
+    if (settingsModified) {
+      writeSettings(settingsPath, settings);
+      removedCount++;
+    }
+  }
+
+  // 6. For OpenCode, clean up permissions from opencode.json
+  if (isOpencode) {
+    const opencodeConfigDir = getOpencodeGlobalDir();
+    const configPath = path.join(opencodeConfigDir, 'opencode.json');
+    if (fs.existsSync(configPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        let modified = false;
+
+        // Remove GSD permission entries
+        if (config.permission) {
+          for (const permType of ['read', 'external_directory']) {
+            if (config.permission[permType]) {
+              const keys = Object.keys(config.permission[permType]);
+              for (const key of keys) {
+                if (key.includes('get-shit-done')) {
+                  delete config.permission[permType][key];
+                  modified = true;
+                }
+              }
+              // Clean up empty objects
+              if (Object.keys(config.permission[permType]).length === 0) {
+                delete config.permission[permType];
+              }
+            }
+          }
+          if (Object.keys(config.permission).length === 0) {
+            delete config.permission;
+          }
+        }
+
+        if (modified) {
+          fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+          removedCount++;
+          console.log(`  ${green}✓${reset} Removed GSD permissions from opencode.json`);
+        }
+      } catch (e) {
+        // Ignore JSON parse errors
+      }
+    }
+  }
+
+  if (removedCount === 0) {
+    console.log(`  ${yellow}⚠${reset} No GSD files found to remove.`);
+  }
+
+  console.log(`
+  ${green}Done!${reset} GSD has been uninstalled from ${runtimeLabel}.
+  Your other files and settings have been preserved.
+`);
+}
+
 /**
  * Configure OpenCode permissions to allow reading GSD reference docs
- * This prevents permission prompts when GSD accesses ~/.opencode/get-shit-done/
+ * This prevents permission prompts when GSD accesses the get-shit-done directory
  */
 function configureOpencodePermissions() {
-  const configPath = path.join(os.homedir(), '.opencode.json');
+  // OpenCode config file is at ~/.config/opencode/opencode.json
+  const opencodeConfigDir = getOpencodeGlobalDir();
+  const configPath = path.join(opencodeConfigDir, 'opencode.json');
+
+  // Ensure config directory exists
+  fs.mkdirSync(opencodeConfigDir, { recursive: true });
 
   // Read existing config or create empty object
   let config = {};
@@ -433,7 +749,7 @@ function configureOpencodePermissions() {
       config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
     } catch (e) {
       // Invalid JSON - start fresh but warn user
-      console.log(`  ${yellow}⚠${reset} ~/.opencode.json had invalid JSON, recreating`);
+      console.log(`  ${yellow}⚠${reset} opencode.json had invalid JSON, recreating`);
     }
   }
 
@@ -442,7 +758,13 @@ function configureOpencodePermissions() {
     config.permission = {};
   }
 
-  const gsdPath = '~/.opencode/get-shit-done/*';
+  // Build the GSD path using the actual config directory
+  // Use ~ shorthand if it's in the default location, otherwise use full path
+  const defaultConfigDir = path.join(os.homedir(), '.config', 'opencode');
+  const gsdPath = opencodeConfigDir === defaultConfigDir
+    ? '~/.config/opencode/get-shit-done/*'
+    : `${opencodeConfigDir}/get-shit-done/*`;
+  
   let modified = false;
 
   // Configure read permission
@@ -511,24 +833,23 @@ function verifyFileInstalled(filePath, description) {
  */
 function install(isGlobal, runtime = 'claude') {
   const isOpencode = runtime === 'opencode';
-  const dirName = getDirName(runtime);
+  const dirName = getDirName(runtime);  // .opencode or .claude (for local installs)
   const src = path.join(__dirname, '..');
 
-  // Priority: explicit --config-dir arg > CLAUDE_CONFIG_DIR env var > default dir
-  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
-  const defaultGlobalDir = configDir || path.join(os.homedir(), dirName);
+  // Get the target directory based on runtime and install type
   const targetDir = isGlobal
-    ? defaultGlobalDir
+    ? getGlobalDir(runtime, explicitConfigDir)
     : path.join(process.cwd(), dirName);
 
   const locationLabel = isGlobal
     ? targetDir.replace(os.homedir(), '~')
     : targetDir.replace(process.cwd(), '.');
 
-  // Path prefix for file references
-  // Use actual path when CLAUDE_CONFIG_DIR is set, otherwise use ~ shorthand
+  // Path prefix for file references in markdown content
+  // For global installs: use full path (necessary when config dir is customized)
+  // For local installs: use relative ./.opencode/ or ./.claude/
   const pathPrefix = isGlobal
-    ? (configDir ? `${targetDir}/` : `~/${dirName}/`)
+    ? `${targetDir}/`
     : `./${dirName}/`;
 
   const runtimeLabel = isOpencode ? 'OpenCode' : 'Claude Code';
@@ -540,18 +861,35 @@ function install(isGlobal, runtime = 'claude') {
   // Clean up orphaned files from previous versions
   cleanupOrphanedFiles(targetDir);
 
-  // Create commands directory
-  const commandsDir = path.join(targetDir, 'commands');
-  fs.mkdirSync(commandsDir, { recursive: true });
-
-  // Copy commands/gsd with path replacement
-  const gsdSrc = path.join(src, 'commands', 'gsd');
-  const gsdDest = path.join(commandsDir, 'gsd');
-  copyWithPathReplacement(gsdSrc, gsdDest, pathPrefix, runtime);
-  if (verifyInstalled(gsdDest, 'commands/gsd')) {
-    console.log(`  ${green}✓${reset} Installed commands/gsd`);
+  // OpenCode uses 'command/' (singular) with flat structure: command/gsd-help.md
+  // Claude Code uses 'commands/' (plural) with nested structure: commands/gsd/help.md
+  if (isOpencode) {
+    // OpenCode: flat structure in command/ directory
+    const commandDir = path.join(targetDir, 'command');
+    fs.mkdirSync(commandDir, { recursive: true });
+    
+    // Copy commands/gsd/*.md as command/gsd-*.md (flatten structure)
+    const gsdSrc = path.join(src, 'commands', 'gsd');
+    copyFlattenedCommands(gsdSrc, commandDir, 'gsd', pathPrefix, runtime);
+    if (verifyInstalled(commandDir, 'command/gsd-*')) {
+      const count = fs.readdirSync(commandDir).filter(f => f.startsWith('gsd-')).length;
+      console.log(`  ${green}✓${reset} Installed ${count} commands to command/`);
+    } else {
+      failures.push('command/gsd-*');
+    }
   } else {
-    failures.push('commands/gsd');
+    // Claude Code: nested structure in commands/ directory
+    const commandsDir = path.join(targetDir, 'commands');
+    fs.mkdirSync(commandsDir, { recursive: true });
+    
+    const gsdSrc = path.join(src, 'commands', 'gsd');
+    const gsdDest = path.join(commandsDir, 'gsd');
+    copyWithPathReplacement(gsdSrc, gsdDest, pathPrefix, runtime);
+    if (verifyInstalled(gsdDest, 'commands/gsd')) {
+      console.log(`  ${green}✓${reset} Installed commands/gsd`);
+    } else {
+      failures.push('commands/gsd');
+    }
   }
 
   // Copy get-shit-done skill with path replacement
@@ -718,9 +1056,11 @@ function finishInstall(settingsPath, settings, statuslineCommand, shouldInstallS
   }
 
   const program = isOpencode ? 'OpenCode' : 'Claude Code';
-  const command = isOpencode ? '/gsd/help' : '/gsd:help';
+  const command = isOpencode ? '/gsd-help' : '/gsd:help';
   console.log(`
   ${green}Done!${reset} Launch ${program} and run ${cyan}${command}${reset}.
+
+  ${cyan}Join the community:${reset} https://discord.gg/5JJgD5svVS
 `);
 }
 
@@ -803,7 +1143,7 @@ function promptRuntime(callback) {
   console.log(`  ${yellow}Which runtime(s) would you like to install for?${reset}
 
   ${cyan}1${reset}) Claude Code ${dim}(~/.claude)${reset}
-  ${cyan}2${reset}) OpenCode    ${dim}(~/.opencode)${reset} - open source, free models
+  ${cyan}2${reset}) OpenCode    ${dim}(~/.config/opencode)${reset} - open source, free models
   ${cyan}3${reset}) Both
 `);
 
@@ -852,10 +1192,9 @@ function promptLocation(runtimes) {
   });
 
   // Show paths for selected runtimes
-  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
   const pathExamples = runtimes.map(r => {
-    const dir = getDirName(r);
-    const globalPath = configDir || path.join(os.homedir(), dir);
+    // Use the proper global directory function for each runtime
+    const globalPath = getGlobalDir(r, explicitConfigDir);
     return globalPath.replace(os.homedir(), '~');
   }).join(', ');
 
@@ -917,6 +1256,17 @@ if (hasGlobal && hasLocal) {
 } else if (explicitConfigDir && hasLocal) {
   console.error(`  ${yellow}Cannot use --config-dir with --local${reset}`);
   process.exit(1);
+} else if (hasUninstall) {
+  // Uninstall mode
+  if (!hasGlobal && !hasLocal) {
+    console.error(`  ${yellow}--uninstall requires --global or --local${reset}`);
+    console.error(`  Example: npx get-shit-done-cc --claude --global --uninstall`);
+    process.exit(1);
+  }
+  const runtimes = selectedRuntimes.length > 0 ? selectedRuntimes : ['claude'];
+  for (const runtime of runtimes) {
+    uninstall(hasGlobal, runtime);
+  }
 } else if (selectedRuntimes.length > 0) {
   // Non-interactive: runtime specified via flags
   if (!hasGlobal && !hasLocal) {

package/commands/gsd/help.md

@@ -352,6 +352,14 @@ Update GSD to latest version with changelog preview.
 
 Usage: `/gsd:update`
 
+**`/gsd:join-discord`**
+Join the GSD Discord community.
+
+- Get help, share what you're building, stay updated
+- Connect with other GSD users
+
+Usage: `/gsd:join-discord`
+
 ## Files & Structure
 
 ```

package/commands/gsd/join-discord.md

@@ -0,0 +1,18 @@
+---
+name: gsd:join-discord
+description: Join the GSD Discord community
+---
+
+<objective>
+Display the Discord invite link for the GSD community server.
+</objective>
+
+<output>
+# Join the GSD Discord
+
+Connect with other GSD users, get help, share what you're building, and stay updated.
+
+**Invite link:** https://discord.gg/5JJgD5svVS
+
+Click the link or paste it into your browser to join.
+</output>

package/commands/gsd/plan-phase.md

@@ -173,7 +173,7 @@ REQUIREMENTS=$(cat .planning/REQUIREMENTS.md 2>/dev/null | grep -A100 "## Requir
 DECISIONS=$(grep -A20 "### Decisions Made" .planning/STATE.md 2>/dev/null)
 
 # Get phase context if exists
-PHASE_CONTEXT=$(cat "${PHASE_DIR}/${PHASE}-CONTEXT.md" 2>/dev/null)
+PHASE_CONTEXT=$(cat "${PHASE_DIR}"/*-CONTEXT.md 2>/dev/null)
 ```
 
 Fill research prompt and spawn:

package/commands/gsd/research-phase.md

@@ -81,7 +81,7 @@ ls .planning/phases/${PHASE}-*/RESEARCH.md 2>/dev/null
 ```bash
 grep -A20 "Phase ${PHASE}:" .planning/ROADMAP.md
 cat .planning/REQUIREMENTS.md 2>/dev/null
-cat .planning/phases/${PHASE}-*/${PHASE}-CONTEXT.md 2>/dev/null
+cat .planning/phases/${PHASE}-*/*-CONTEXT.md 2>/dev/null
 grep -A30 "### Decisions Made" .planning/STATE.md 2>/dev/null
 ```
 

package/get-shit-done/workflows/discuss-phase.md

@@ -132,7 +132,7 @@ Check if CONTEXT.md already exists:
 ```bash
 # Match both zero-padded (05-*) and unpadded (5-*) folders
 PADDED_PHASE=$(printf "%02d" ${PHASE})
-ls .planning/phases/${PADDED_PHASE}-*/CONTEXT.md .planning/phases/${PADDED_PHASE}-*/${PADDED_PHASE}-CONTEXT.md .planning/phases/${PHASE}-*/CONTEXT.md .planning/phases/${PHASE}-*/${PHASE}-CONTEXT.md 2>/dev/null
+ls .planning/phases/${PADDED_PHASE}-*/*-CONTEXT.md .planning/phases/${PHASE}-*/*-CONTEXT.md 2>/dev/null
 ```
 
 **If exists:**

package/get-shit-done/workflows/resume-project.md

@@ -197,7 +197,7 @@ What would you like to do?
 **Note:** When offering phase planning, check for CONTEXT.md existence first:
 
 ```bash
-ls .planning/phases/XX-name/CONTEXT.md 2>/dev/null
+ls .planning/phases/XX-name/*-CONTEXT.md 2>/dev/null
 ```
 
 If missing, suggest discuss-phase before plan. If exists, offer plan directly.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-shit-done-cc",
-  "version": "1.9.6",
+  "version": "1.9.11",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.",
   "bin": {
     "get-shit-done-cc": "bin/install.js"