get-shit-pretty 0.1.0

package/bin/install.js

@@ -0,0 +1,1084 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+// Colors
+const cyan = '\x1b[36m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+// Parse args
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+const hasClaude = args.includes('--claude');
+const hasOpencode = args.includes('--opencode');
+const hasGemini = args.includes('--gemini');
+const hasCodex = args.includes('--codex');
+const hasAll = args.includes('--all');
+const hasUninstall = args.includes('--uninstall') || args.includes('-u');
+const hasHelp = args.includes('--help') || args.includes('-h');
+const forceStatusline = args.includes('--force-statusline');
+
+// Runtime selection
+let selectedRuntimes = [];
+if (hasAll) {
+  selectedRuntimes = ['claude', 'opencode', 'gemini', 'codex'];
+} else {
+  if (hasClaude) selectedRuntimes.push('claude');
+  if (hasOpencode) selectedRuntimes.push('opencode');
+  if (hasGemini) selectedRuntimes.push('gemini');
+  if (hasCodex) selectedRuntimes.push('codex');
+}
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const idx = args.findIndex(a => a === '--config-dir' || a === '-c');
+  if (idx !== -1) {
+    const next = args[idx + 1];
+    if (!next || next.startsWith('-')) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return next;
+  }
+  const eqArg = args.find(a => a.startsWith('--config-dir=') || a.startsWith('-c='));
+  if (eqArg) {
+    const val = eqArg.split('=')[1];
+    if (!val) {
+      console.error(`  ${yellow}--config-dir requires a non-empty path${reset}`);
+      process.exit(1);
+    }
+    return val;
+  }
+  return null;
+}
+const explicitConfigDir = parseConfigDirArg();
+
+// Banner
+const banner = '\n' +
+  cyan + '   ██████╗ ███████╗██████╗\n' +
+  '  ██╔════╝ ██╔════╝██╔══██╗\n' +
+  '  ██║  ███╗███████╗██████╔╝\n' +
+  '  ██║   ██║╚════██║██╔═══╝\n' +
+  '  ╚██████╔╝███████║██║\n' +
+  '   ╚═════╝ ╚══════╝╚═╝' + reset + '\n' +
+  '\n' +
+  '  Get Shit Pretty ' + dim + 'v' + pkg.version + reset + '\n' +
+  '  A design engineering system for Claude Code,\n' +
+  '  OpenCode, Gemini, and Codex.\n';
+
+console.log(banner);
+
+// Help
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx get-shit-pretty [options]\n
+  ${yellow}Options:${reset}
+    ${cyan}-g, --global${reset}              Install globally (to config directory)
+    ${cyan}-l, --local${reset}               Install locally (to current directory)
+    ${cyan}--claude${reset}                  Install for Claude Code only
+    ${cyan}--opencode${reset}                Install for OpenCode only
+    ${cyan}--gemini${reset}                  Install for Gemini only
+    ${cyan}--codex${reset}                   Install for Codex CLI only
+    ${cyan}--all${reset}                     Install for all runtimes
+    ${cyan}-u, --uninstall${reset}           Uninstall GSP (remove GSP files only)
+    ${cyan}-c, --config-dir <path>${reset}   Specify custom config directory
+    ${cyan}--force-statusline${reset}        Replace existing statusline config
+    ${cyan}-h, --help${reset}                Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Interactive install (prompts for runtime and location)${reset}
+    npx get-shit-pretty
+
+    ${dim}# Install for Claude Code globally${reset}
+    npx get-shit-pretty --claude --global
+
+    ${dim}# Install for all runtimes globally${reset}
+    npx get-shit-pretty --all --global
+
+    ${dim}# Install to current project only${reset}
+    npx get-shit-pretty --claude --local
+
+    ${dim}# Uninstall GSP from Claude Code globally${reset}
+    npx get-shit-pretty --claude --global --uninstall
+`);
+  process.exit(0);
+}
+
+// ──────────────────────────────────────────────────────
+// Utility functions
+// ──────────────────────────────────────────────────────
+
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+function getDirName(runtime) {
+  if (runtime === 'opencode') return '.opencode';
+  if (runtime === 'gemini') return '.gemini';
+  if (runtime === 'codex') return '.codex';
+  return '.claude';
+}
+
+function getGlobalDir(runtime, explicitDir = null) {
+  if (explicitDir) return expandTilde(explicitDir);
+
+  if (runtime === 'opencode') {
+    if (process.env.OPENCODE_CONFIG_DIR) return expandTilde(process.env.OPENCODE_CONFIG_DIR);
+    if (process.env.OPENCODE_CONFIG) return path.dirname(expandTilde(process.env.OPENCODE_CONFIG));
+    if (process.env.XDG_CONFIG_HOME) return path.join(expandTilde(process.env.XDG_CONFIG_HOME), 'opencode');
+    return path.join(os.homedir(), '.config', 'opencode');
+  }
+
+  if (runtime === 'gemini') {
+    if (process.env.GEMINI_CONFIG_DIR) return expandTilde(process.env.GEMINI_CONFIG_DIR);
+    return path.join(os.homedir(), '.gemini');
+  }
+
+  if (runtime === 'codex') {
+    if (process.env.CODEX_CONFIG_DIR) return expandTilde(process.env.CODEX_CONFIG_DIR);
+    return path.join(os.homedir(), '.codex');
+  }
+
+  // Claude
+  if (process.env.CLAUDE_CONFIG_DIR) return expandTilde(process.env.CLAUDE_CONFIG_DIR);
+  return path.join(os.homedir(), '.claude');
+}
+
+function getConfigDirFromHome(runtime, isGlobal) {
+  if (!isGlobal) return `'${getDirName(runtime)}'`;
+  if (runtime === 'opencode') return "'.config', 'opencode'";
+  if (runtime === 'gemini') return "'.gemini'";
+  if (runtime === 'codex') return "'.codex'";
+  return "'.claude'";
+}
+
+function getRuntimeLabel(runtime) {
+  if (runtime === 'opencode') return 'OpenCode';
+  if (runtime === 'gemini') return 'Gemini';
+  if (runtime === 'codex') return 'Codex';
+  return 'Claude Code';
+}
+
+function readSettings(settingsPath) {
+  if (fs.existsSync(settingsPath)) {
+    try { return JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch (e) { return {}; }
+  }
+  return {};
+}
+
+function writeSettings(settingsPath, settings) {
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
+// ──────────────────────────────────────────────────────
+// Tool name mappings
+// ──────────────────────────────────────────────────────
+
+const claudeToOpencodeTools = {
+  AskUserQuestion: 'question',
+  SlashCommand: 'skill',
+  TodoWrite: 'todowrite',
+  WebFetch: 'webfetch',
+  WebSearch: 'websearch',
+};
+
+const claudeToGeminiTools = {
+  Read: 'read_file',
+  Write: 'write_file',
+  Edit: 'replace',
+  Bash: 'run_shell_command',
+  Glob: 'glob',
+  Grep: 'search_file_content',
+  WebSearch: 'google_web_search',
+  WebFetch: 'web_fetch',
+  TodoWrite: 'write_todos',
+  AskUserQuestion: 'ask_user',
+};
+
+const claudeToCodexTools = {
+  Read: 'read',
+  Write: 'write',
+  Edit: 'edit',
+  Bash: 'shell',
+  Glob: 'glob',
+  Grep: 'grep',
+  WebSearch: 'web_search',
+  WebFetch: 'web_fetch',
+};
+
+const colorNameToHex = {
+  cyan: '#00FFFF', red: '#FF0000', green: '#00FF00', blue: '#0000FF',
+  yellow: '#FFFF00', magenta: '#FF00FF', orange: '#FFA500', purple: '#800080',
+  pink: '#FFC0CB', white: '#FFFFFF', black: '#000000', gray: '#808080', grey: '#808080',
+};
+
+// ──────────────────────────────────────────────────────
+// Conversion functions
+// ──────────────────────────────────────────────────────
+
+function convertToolName(claudeTool) {
+  if (claudeToOpencodeTools[claudeTool]) return claudeToOpencodeTools[claudeTool];
+  if (claudeTool.startsWith('mcp__')) return claudeTool;
+  return claudeTool.toLowerCase();
+}
+
+function convertGeminiToolName(claudeTool) {
+  if (claudeTool.startsWith('mcp__')) return null;
+  if (claudeTool === 'Task') return null;
+  if (claudeToGeminiTools[claudeTool]) return claudeToGeminiTools[claudeTool];
+  return claudeTool.toLowerCase();
+}
+
+function convertCodexToolName(claudeTool) {
+  if (claudeTool.startsWith('mcp__')) return null;
+  if (claudeTool === 'Task') return null;
+  if (claudeToCodexTools[claudeTool]) return claudeToCodexTools[claudeTool];
+  return claudeTool.toLowerCase();
+}
+
+function stripSubTags(content) {
+  return content.replace(/<sub>(.*?)<\/sub>/g, '*($1)*');
+}
+
+/**
+ * Convert Claude frontmatter to OpenCode format
+ */
+function convertClaudeToOpencodeFrontmatter(content) {
+  let converted = content;
+  converted = converted.replace(/\bAskUserQuestion\b/g, 'question');
+  converted = converted.replace(/\bSlashCommand\b/g, 'skill');
+  converted = converted.replace(/\bTodoWrite\b/g, 'todowrite');
+  converted = converted.replace(/\/gsp:/g, '/gsp-');
+  converted = converted.replace(/~\/\.claude\b/g, '~/.config/opencode');
+  converted = converted.replace(/subagent_type="general-purpose"/g, 'subagent_type="general"');
+
+  if (!converted.startsWith('---')) return converted;
+  const endIndex = converted.indexOf('---', 3);
+  if (endIndex === -1) return converted;
+
+  const frontmatter = converted.substring(3, endIndex).trim();
+  const body = converted.substring(endIndex + 3);
+  const lines = frontmatter.split('\n');
+  const newLines = [];
+  let inAllowedTools = false;
+  const allowedTools = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith('allowed-tools:')) { inAllowedTools = true; continue; }
+
+    if (trimmed.startsWith('tools:')) {
+      const val = trimmed.substring(6).trim();
+      if (val) {
+        allowedTools.push(...val.split(',').map(t => t.trim()).filter(Boolean));
+      } else {
+        inAllowedTools = true;
+      }
+      continue;
+    }
+
+    if (trimmed.startsWith('name:')) continue;
+
+    if (trimmed.startsWith('color:')) {
+      const colorValue = trimmed.substring(6).trim().toLowerCase();
+      const hex = colorNameToHex[colorValue];
+      if (hex) newLines.push(`color: "${hex}"`);
+      else if (colorValue.startsWith('#') && /^#[0-9a-f]{3}$|^#[0-9a-f]{6}$/i.test(colorValue)) {
+        newLines.push(line);
+      }
+      continue;
+    }
+
+    if (inAllowedTools) {
+      if (trimmed.startsWith('- ')) { allowedTools.push(trimmed.substring(2).trim()); continue; }
+      else if (trimmed && !trimmed.startsWith('-')) { inAllowedTools = false; }
+    }
+
+    if (!inAllowedTools) newLines.push(line);
+  }
+
+  if (allowedTools.length > 0) {
+    newLines.push('tools:');
+    for (const tool of allowedTools) {
+      newLines.push(`  ${convertToolName(tool)}: true`);
+    }
+  }
+
+  return `---\n${newLines.join('\n').trim()}\n---${body}`;
+}
+
+/**
+ * Convert Claude command to Gemini TOML format
+ */
+function convertClaudeToGeminiToml(content) {
+  if (!content.startsWith('---')) return `prompt = ${JSON.stringify(content)}\n`;
+  const endIndex = content.indexOf('---', 3);
+  if (endIndex === -1) return `prompt = ${JSON.stringify(content)}\n`;
+
+  const frontmatter = content.substring(3, endIndex).trim();
+  const body = content.substring(endIndex + 3).trim();
+
+  let description = '';
+  for (const line of frontmatter.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('description:')) {
+      description = trimmed.substring(12).trim();
+      break;
+    }
+  }
+
+  let toml = '';
+  if (description) toml += `description = ${JSON.stringify(description)}\n`;
+  toml += `prompt = ${JSON.stringify(body)}\n`;
+  return toml;
+}
+
+/**
+ * Convert Claude agent to Gemini agent format
+ */
+function convertClaudeToGeminiAgent(content) {
+  if (!content.startsWith('---')) return content;
+  const endIndex = content.indexOf('---', 3);
+  if (endIndex === -1) return content;
+
+  const frontmatter = content.substring(3, endIndex).trim();
+  const body = content.substring(endIndex + 3);
+  const lines = frontmatter.split('\n');
+  const newLines = [];
+  let inAllowedTools = false;
+  const tools = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('allowed-tools:')) { inAllowedTools = true; continue; }
+    if (trimmed.startsWith('tools:')) {
+      const val = trimmed.substring(6).trim();
+      if (val) {
+        for (const t of val.split(',').map(s => s.trim()).filter(Boolean)) {
+          const mapped = convertGeminiToolName(t);
+          if (mapped) tools.push(mapped);
+        }
+      } else { inAllowedTools = true; }
+      continue;
+    }
+    if (trimmed.startsWith('color:')) continue;
+    if (inAllowedTools) {
+      if (trimmed.startsWith('- ')) {
+        const mapped = convertGeminiToolName(trimmed.substring(2).trim());
+        if (mapped) tools.push(mapped);
+        continue;
+      } else if (trimmed && !trimmed.startsWith('-')) { inAllowedTools = false; }
+    }
+    if (!inAllowedTools) newLines.push(line);
+  }
+
+  if (tools.length > 0) {
+    newLines.push('tools:');
+    for (const tool of tools) newLines.push(`  - ${tool}`);
+  }
+
+  const escapedBody = body.replace(/\$\{(\w+)\}/g, '$$$1');
+  return `---\n${newLines.join('\n').trim()}\n---${stripSubTags(escapedBody)}`;
+}
+
+/**
+ * Convert Claude command to Codex SKILL.md format
+ * Codex expects: ~/.codex/skills/gsp-help/SKILL.md
+ */
+function convertClaudeCommandToCodexSkill(content) {
+  if (!content.startsWith('---')) return content;
+  const endIndex = content.indexOf('---', 3);
+  if (endIndex === -1) return content;
+
+  const frontmatter = content.substring(3, endIndex).trim();
+  let body = content.substring(endIndex + 3).trim();
+
+  // Extract metadata from frontmatter
+  let description = '';
+  const tools = [];
+  let inTools = false;
+
+  for (const line of frontmatter.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('description:')) {
+      description = trimmed.substring(12).trim();
+      inTools = false;
+      continue;
+    }
+    if (trimmed.startsWith('allowed-tools:') || trimmed.startsWith('tools:')) {
+      const val = trimmed.includes(':') ? trimmed.split(':').slice(1).join(':').trim() : '';
+      if (val) {
+        for (const t of val.split(',').map(s => s.trim()).filter(Boolean)) {
+          const mapped = convertCodexToolName(t);
+          if (mapped) tools.push(mapped);
+        }
+      } else {
+        inTools = true;
+      }
+      continue;
+    }
+    if (inTools) {
+      if (trimmed.startsWith('- ')) {
+        const mapped = convertCodexToolName(trimmed.substring(2).trim());
+        if (mapped) tools.push(mapped);
+        continue;
+      } else if (trimmed && !trimmed.startsWith('-')) {
+        inTools = false;
+      }
+    }
+  }
+
+  // Replace slash command references: /gsp: → $gsp-
+  body = body.replace(/\/gsp:/g, '$gsp-');
+  // Replace ~/.claude references
+  body = body.replace(/~\/\.claude\b/g, '~/.codex');
+
+  // Build SKILL.md
+  let skill = '';
+  if (description) skill += `# ${description}\n\n`;
+  if (tools.length > 0) skill += `Tools: ${tools.join(', ')}\n\n`;
+  skill += body;
+  return skill;
+}
+
+/**
+ * Convert Claude agent to Codex agent format
+ */
+function convertClaudeToCodexAgent(content) {
+  let converted = content;
+  converted = converted.replace(/\/gsp:/g, '$gsp-');
+  converted = converted.replace(/~\/\.claude\b/g, '~/.codex');
+
+  if (!converted.startsWith('---')) return converted;
+  const endIndex = converted.indexOf('---', 3);
+  if (endIndex === -1) return converted;
+
+  const frontmatter = converted.substring(3, endIndex).trim();
+  const body = converted.substring(endIndex + 3);
+  const lines = frontmatter.split('\n');
+  const newLines = [];
+  let inTools = false;
+  const tools = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('allowed-tools:') || trimmed.startsWith('tools:')) {
+      const val = trimmed.includes(':') ? trimmed.split(':').slice(1).join(':').trim() : '';
+      if (val) {
+        for (const t of val.split(',').map(s => s.trim()).filter(Boolean)) {
+          const mapped = convertCodexToolName(t);
+          if (mapped) tools.push(mapped);
+        }
+      } else { inTools = true; }
+      continue;
+    }
+    if (trimmed.startsWith('color:')) continue;
+    if (inTools) {
+      if (trimmed.startsWith('- ')) {
+        const mapped = convertCodexToolName(trimmed.substring(2).trim());
+        if (mapped) tools.push(mapped);
+        continue;
+      } else if (trimmed && !trimmed.startsWith('-')) { inTools = false; }
+    }
+    if (!inTools) newLines.push(line);
+  }
+
+  if (tools.length > 0) {
+    newLines.push('tools: ' + tools.join(', '));
+  }
+
+  return `---\n${newLines.join('\n').trim()}\n---${body}`;
+}
+
+// ──────────────────────────────────────────────────────
+// File copy helpers
+// ──────────────────────────────────────────────────────
+
+/**
+ * Copy commands to flat structure for OpenCode
+ * commands/gsp/help.md → command/gsp-help.md
+ */
+function copyFlattenedCommands(srcDir, destDir, prefix, pathPrefix, runtime) {
+  if (!fs.existsSync(srcDir)) return;
+
+  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()) {
+      copyFlattenedCommands(srcPath, destDir, `${prefix}-${entry.name}`, pathPrefix, runtime);
+    } else if (entry.name.endsWith('.md')) {
+      const baseName = entry.name.replace('.md', '');
+      const destPath = path.join(destDir, `${prefix}-${baseName}.md`);
+      let content = fs.readFileSync(srcPath, 'utf8');
+      content = content.replace(/~\/\.claude\//g, pathPrefix);
+      content = content.replace(/\.\/\.claude\//g, `./${getDirName(runtime)}/`);
+      content = convertClaudeToOpencodeFrontmatter(content);
+      fs.writeFileSync(destPath, content);
+    }
+  }
+}
+
+/**
+ * Copy commands to Codex skill structure
+ * commands/gsp/help.md → skills/gsp-help/SKILL.md
+ */
+function copyCodexSkills(srcDir, destDir, prefix, pathPrefix) {
+  if (!fs.existsSync(srcDir)) return;
+  fs.mkdirSync(destDir, { recursive: true });
+
+  // Clean old gsp-* skill dirs
+  if (fs.existsSync(destDir)) {
+    for (const entry of fs.readdirSync(destDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name.startsWith(`${prefix}-`)) {
+        fs.rmSync(path.join(destDir, entry.name), { recursive: true });
+      }
+    }
+  }
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    if (entry.isDirectory()) {
+      copyCodexSkills(srcPath, destDir, `${prefix}-${entry.name}`, pathPrefix);
+    } else if (entry.name.endsWith('.md')) {
+      const baseName = entry.name.replace('.md', '');
+      const skillDir = path.join(destDir, `${prefix}-${baseName}`);
+      fs.mkdirSync(skillDir, { recursive: true });
+      let content = fs.readFileSync(srcPath, 'utf8');
+      content = content.replace(/~\/\.claude\//g, pathPrefix);
+      content = convertClaudeCommandToCodexSkill(content);
+      fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content);
+    }
+  }
+}
+
+/**
+ * Recursively copy directory with path replacement and runtime conversion
+ */
+function copyWithPathReplacement(srcDir, destDir, pathPrefix, runtime, isCommand = false) {
+  const dirName = getDirName(runtime);
+
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true });
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyWithPathReplacement(srcPath, destPath, pathPrefix, runtime, isCommand);
+    } else if (entry.name.endsWith('.md')) {
+      let content = fs.readFileSync(srcPath, 'utf8');
+      content = content.replace(/~\/\.claude\//g, pathPrefix);
+      content = content.replace(/\.\/\.claude\//g, `./${dirName}/`);
+
+      if (runtime === 'opencode') {
+        content = convertClaudeToOpencodeFrontmatter(content);
+        fs.writeFileSync(destPath, content);
+      } else if (runtime === 'gemini') {
+        if (isCommand) {
+          content = stripSubTags(content);
+          const tomlContent = convertClaudeToGeminiToml(content);
+          fs.writeFileSync(destPath.replace(/\.md$/, '.toml'), tomlContent);
+        } else {
+          fs.writeFileSync(destPath, content);
+        }
+      } else if (runtime === 'codex') {
+        content = content.replace(/\/gsp:/g, '$gsp-');
+        fs.writeFileSync(destPath, content);
+      } else {
+        fs.writeFileSync(destPath, content);
+      }
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function verifyInstalled(dirPath, description) {
+  if (!fs.existsSync(dirPath)) {
+    console.error(`  ${yellow}!${reset} Failed to install ${description}: directory not created`);
+    return false;
+  }
+  try {
+    if (fs.readdirSync(dirPath).length === 0) {
+      console.error(`  ${yellow}!${reset} Failed to install ${description}: directory is empty`);
+      return false;
+    }
+  } catch (e) {
+    console.error(`  ${yellow}!${reset} Failed to install ${description}: ${e.message}`);
+    return false;
+  }
+  return true;
+}
+
+// ──────────────────────────────────────────────────────
+// Install
+// ──────────────────────────────────────────────────────
+
+function install(isGlobal, runtime = 'claude') {
+  const isOpencode = runtime === 'opencode';
+  const isGemini = runtime === 'gemini';
+  const isCodex = runtime === 'codex';
+  const dirName = getDirName(runtime);
+  const src = path.join(__dirname, '..');
+
+  const targetDir = isGlobal
+    ? getGlobalDir(runtime, explicitConfigDir)
+    : path.join(process.cwd(), dirName);
+
+  const locationLabel = isGlobal
+    ? targetDir.replace(os.homedir(), '~')
+    : targetDir.replace(process.cwd(), '.');
+
+  const pathPrefix = isGlobal
+    ? `${targetDir.replace(/\\/g, '/')}/`
+    : `./${dirName}/`;
+
+  const runtimeLabel = getRuntimeLabel(runtime);
+  console.log(`  Installing for ${cyan}${runtimeLabel}${reset} to ${cyan}${locationLabel}${reset}\n`);
+
+  const failures = [];
+
+  // ── Commands ──
+  if (isOpencode) {
+    const commandDir = path.join(targetDir, 'command');
+    fs.mkdirSync(commandDir, { recursive: true });
+    copyFlattenedCommands(path.join(src, 'commands', 'gsp'), commandDir, 'gsp', pathPrefix, runtime);
+    if (verifyInstalled(commandDir, 'command/gsp-*')) {
+      const count = fs.readdirSync(commandDir).filter(f => f.startsWith('gsp-')).length;
+      console.log(`  ${green}+${reset} Installed ${count} commands to command/`);
+    } else { failures.push('commands'); }
+  } else if (isCodex) {
+    const skillsDir = path.join(targetDir, 'skills');
+    fs.mkdirSync(skillsDir, { recursive: true });
+    copyCodexSkills(path.join(src, 'commands', 'gsp'), skillsDir, 'gsp', pathPrefix);
+    if (verifyInstalled(skillsDir, 'skills/gsp-*')) {
+      const count = fs.readdirSync(skillsDir).filter(f => f.startsWith('gsp-')).length;
+      console.log(`  ${green}+${reset} Installed ${count} skills to skills/`);
+    } else { failures.push('skills'); }
+  } else {
+    const commandsDir = path.join(targetDir, 'commands');
+    fs.mkdirSync(commandsDir, { recursive: true });
+    const gspDest = path.join(commandsDir, 'gsp');
+    copyWithPathReplacement(path.join(src, 'commands', 'gsp'), gspDest, pathPrefix, runtime, true);
+    if (verifyInstalled(gspDest, 'commands/gsp')) {
+      console.log(`  ${green}+${reset} Installed commands/gsp`);
+    } else { failures.push('commands'); }
+  }
+
+  // ── Agents ──
+  const agentsSrc = path.join(src, 'agents');
+  if (fs.existsSync(agentsSrc)) {
+    const agentsDest = path.join(targetDir, 'agents');
+    fs.mkdirSync(agentsDest, { recursive: true });
+
+    // Remove old GSP agents before copying new ones
+    if (fs.existsSync(agentsDest)) {
+      for (const file of fs.readdirSync(agentsDest)) {
+        if (file.startsWith('gsp-') && file.endsWith('.md')) {
+          fs.unlinkSync(path.join(agentsDest, file));
+        }
+      }
+    }
+
+    const agentEntries = fs.readdirSync(agentsSrc, { withFileTypes: true });
+    for (const entry of agentEntries) {
+      if (entry.isFile() && entry.name.endsWith('.md')) {
+        let content = fs.readFileSync(path.join(agentsSrc, entry.name), 'utf8');
+        content = content.replace(/~\/\.claude\//g, pathPrefix);
+
+        if (isOpencode) {
+          content = convertClaudeToOpencodeFrontmatter(content);
+        } else if (isGemini) {
+          content = convertClaudeToGeminiAgent(content);
+        } else if (isCodex) {
+          content = convertClaudeToCodexAgent(content);
+        }
+        fs.writeFileSync(path.join(agentsDest, entry.name), content);
+      }
+    }
+    if (verifyInstalled(agentsDest, 'agents')) {
+      const count = fs.readdirSync(agentsDest).filter(f => f.startsWith('gsp-')).length;
+      console.log(`  ${green}+${reset} Installed ${count} agents`);
+    } else { failures.push('agents'); }
+  }
+
+  // ── Bundle: prompts, templates, references → get-shit-pretty/ ──
+  const bundleDest = path.join(targetDir, 'get-shit-pretty');
+  // Clean install: remove old bundle dir to prevent stale files from previous installs
+  if (fs.existsSync(bundleDest)) {
+    fs.rmSync(bundleDest, { recursive: true });
+  }
+  fs.mkdirSync(bundleDest, { recursive: true });
+
+  const bundleDirs = ['prompts', 'templates', 'references'];
+  for (const dir of bundleDirs) {
+    const dirSrc = path.join(src, dir);
+    if (fs.existsSync(dirSrc)) {
+      copyWithPathReplacement(dirSrc, path.join(bundleDest, dir), pathPrefix, runtime);
+      if (verifyInstalled(path.join(bundleDest, dir), `get-shit-pretty/${dir}`)) {
+        console.log(`  ${green}+${reset} Installed get-shit-pretty/${dir}`);
+      } else { failures.push(dir); }
+    }
+  }
+
+  // Write VERSION file
+  fs.writeFileSync(path.join(bundleDest, 'VERSION'), pkg.version);
+  console.log(`  ${green}+${reset} Wrote VERSION (${pkg.version})`);
+
+  // ── Statusline (Claude Code only) ──
+  if (runtime === 'claude') {
+    const statuslineSrc = path.join(src, 'scripts', 'gsp-statusline.js');
+    if (fs.existsSync(statuslineSrc)) {
+      const hooksDest = path.join(targetDir, 'hooks');
+      fs.mkdirSync(hooksDest, { recursive: true });
+      let content = fs.readFileSync(statuslineSrc, 'utf8');
+      content = content.replace(/'\.claude'/g, getConfigDirFromHome(runtime, isGlobal));
+      fs.writeFileSync(path.join(hooksDest, 'gsp-statusline.js'), content);
+      console.log(`  ${green}+${reset} Installed statusline hook`);
+    }
+  }
+
+  if (failures.length > 0) {
+    console.error(`\n  ${yellow}Installation incomplete!${reset} Failed: ${failures.join(', ')}`);
+    process.exit(1);
+  }
+
+  // ── Settings (Claude Code & Gemini only) ──
+  const settingsPath = path.join(targetDir, 'settings.json');
+  const settings = readSettings(settingsPath);
+
+  const statuslineCommand = isGlobal
+    ? `node "${targetDir.replace(/\\/g, '/')}/hooks/gsp-statusline.js"`
+    : `node ${dirName}/hooks/gsp-statusline.js`;
+
+  return { settingsPath, settings, statuslineCommand, runtime };
+}
+
+// ──────────────────────────────────────────────────────
+// Uninstall
+// ──────────────────────────────────────────────────────
+
+function uninstall(isGlobal, runtime = 'claude') {
+  const isOpencode = runtime === 'opencode';
+  const isCodex = runtime === 'codex';
+  const dirName = getDirName(runtime);
+
+  const targetDir = isGlobal
+    ? getGlobalDir(runtime, explicitConfigDir)
+    : path.join(process.cwd(), dirName);
+
+  const locationLabel = isGlobal
+    ? targetDir.replace(os.homedir(), '~')
+    : targetDir.replace(process.cwd(), '.');
+
+  const runtimeLabel = getRuntimeLabel(runtime);
+  console.log(`  Uninstalling GSP from ${cyan}${runtimeLabel}${reset} at ${cyan}${locationLabel}${reset}\n`);
+
+  if (!fs.existsSync(targetDir)) {
+    console.log(`  ${yellow}!${reset} Directory does not exist: ${locationLabel}`);
+    console.log(`  Nothing to uninstall.\n`);
+    return;
+  }
+
+  let removedCount = 0;
+
+  // Remove commands
+  if (isOpencode) {
+    const commandDir = path.join(targetDir, 'command');
+    if (fs.existsSync(commandDir)) {
+      for (const file of fs.readdirSync(commandDir)) {
+        if (file.startsWith('gsp-') && file.endsWith('.md')) {
+          fs.unlinkSync(path.join(commandDir, file));
+          removedCount++;
+        }
+      }
+      if (removedCount > 0) console.log(`  ${green}+${reset} Removed GSP commands from command/`);
+    }
+  } else if (isCodex) {
+    const skillsDir = path.join(targetDir, 'skills');
+    if (fs.existsSync(skillsDir)) {
+      for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name.startsWith('gsp-')) {
+          fs.rmSync(path.join(skillsDir, entry.name), { recursive: true });
+          removedCount++;
+        }
+      }
+      if (removedCount > 0) console.log(`  ${green}+${reset} Removed GSP skills from skills/`);
+    }
+  } else {
+    const gspCommandsDir = path.join(targetDir, 'commands', 'gsp');
+    if (fs.existsSync(gspCommandsDir)) {
+      fs.rmSync(gspCommandsDir, { recursive: true });
+      removedCount++;
+      console.log(`  ${green}+${reset} Removed commands/gsp/`);
+    }
+  }
+
+  // Remove get-shit-pretty bundle dir
+  const gspDir = path.join(targetDir, 'get-shit-pretty');
+  if (fs.existsSync(gspDir)) {
+    fs.rmSync(gspDir, { recursive: true });
+    removedCount++;
+    console.log(`  ${green}+${reset} Removed get-shit-pretty/`);
+  }
+
+  // Remove GSP agents
+  const agentsDir = path.join(targetDir, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    let agentCount = 0;
+    for (const file of fs.readdirSync(agentsDir)) {
+      if (file.startsWith('gsp-') && file.endsWith('.md')) {
+        fs.unlinkSync(path.join(agentsDir, file));
+        agentCount++;
+      }
+    }
+    if (agentCount > 0) {
+      removedCount++;
+      console.log(`  ${green}+${reset} Removed ${agentCount} GSP agents`);
+    }
+  }
+
+  // Remove statusline hook
+  const statuslineHook = path.join(targetDir, 'hooks', 'gsp-statusline.js');
+  if (fs.existsSync(statuslineHook)) {
+    fs.unlinkSync(statuslineHook);
+    removedCount++;
+    console.log(`  ${green}+${reset} Removed statusline hook`);
+  }
+
+  // Clean up settings.json (statusline only — no hooks to clean)
+  const settingsPath = path.join(targetDir, 'settings.json');
+  if (fs.existsSync(settingsPath)) {
+    const settings = readSettings(settingsPath);
+    let modified = false;
+
+    if (settings.statusLine && settings.statusLine.command &&
+        settings.statusLine.command.includes('gsp-statusline')) {
+      delete settings.statusLine;
+      modified = true;
+      console.log(`  ${green}+${reset} Removed GSP statusline from settings`);
+    }
+
+    if (modified) {
+      writeSettings(settingsPath, settings);
+      removedCount++;
+    }
+  }
+
+  if (removedCount === 0) {
+    console.log(`  ${yellow}!${reset} No GSP files found to remove.`);
+  }
+
+  console.log(`\n  ${green}Done!${reset} GSP has been uninstalled from ${runtimeLabel}.\n  Your other files and settings have been preserved.\n`);
+}
+
+// ──────────────────────────────────────────────────────
+// Statusline handling
+// ──────────────────────────────────────────────────────
+
+function handleStatusline(settings, isInteractive, callback) {
+  const hasExisting = settings.statusLine != null;
+
+  if (!hasExisting) { callback(true); return; }
+  if (forceStatusline) { callback(true); return; }
+
+  if (!isInteractive) {
+    console.log(`  ${yellow}!${reset} Skipping statusline (already configured)`);
+    console.log(`    Use ${cyan}--force-statusline${reset} to replace\n`);
+    callback(false);
+    return;
+  }
+
+  const existingCmd = settings.statusLine.command || settings.statusLine.url || '(custom)';
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  console.log(`\n  ${yellow}!${reset} Existing statusline detected\n
+  Your current statusline:
+    ${dim}command: ${existingCmd}${reset}
+
+  GSP includes a statusline showing:
+    * Model name
+    * Current design phase + prettiness meter
+    * Context window usage (color-coded)
+
+  ${cyan}1${reset}) Keep existing
+  ${cyan}2${reset}) Replace with GSP statusline\n`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    rl.close();
+    callback((answer.trim() || '1') === '2');
+  });
+}
+
+function finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline, runtime = 'claude', isGlobal = true) {
+  const isOpencode = runtime === 'opencode';
+  const isCodex = runtime === 'codex';
+
+  // Only Claude Code and Gemini support statusline
+  if (shouldInstallStatusline && !isOpencode && !isCodex) {
+    settings.statusLine = {
+      type: 'command',
+      command: statuslineCommand
+    };
+    console.log(`  ${green}+${reset} Configured statusline`);
+  }
+
+  // Write settings for Claude/Gemini (they use settings.json)
+  if (!isOpencode && !isCodex) {
+    writeSettings(settingsPath, settings);
+  }
+
+  const runtimeLabel = getRuntimeLabel(runtime);
+  const command = isOpencode ? '/gsp-help' : isCodex ? '$gsp-help' : '/gsp:help';
+  console.log(`\n  ${green}Done!${reset} Launch ${runtimeLabel} and run ${cyan}${command}${reset}.\n`);
+}
+
+// ──────────────────────────────────────────────────────
+// Interactive prompts
+// ──────────────────────────────────────────────────────
+
+function promptRuntime(callback) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let answered = false;
+
+  rl.on('close', () => {
+    if (!answered) { answered = true; console.log(`\n  ${yellow}Installation cancelled${reset}\n`); process.exit(0); }
+  });
+
+  console.log(`  ${yellow}Which runtime(s) would you like to install for?${reset}\n
+  ${cyan}1${reset}) Claude Code ${dim}(~/.claude)${reset}
+  ${cyan}2${reset}) OpenCode    ${dim}(~/.config/opencode)${reset}
+  ${cyan}3${reset}) Gemini      ${dim}(~/.gemini)${reset}
+  ${cyan}4${reset}) Codex       ${dim}(~/.codex)${reset}
+  ${cyan}5${reset}) All\n`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    answered = true;
+    rl.close();
+    const choice = answer.trim() || '1';
+    if (choice === '5') callback(['claude', 'opencode', 'gemini', 'codex']);
+    else if (choice === '4') callback(['codex']);
+    else if (choice === '3') callback(['gemini']);
+    else if (choice === '2') callback(['opencode']);
+    else callback(['claude']);
+  });
+}
+
+function promptLocation(runtimes) {
+  if (!process.stdin.isTTY) {
+    console.log(`  ${yellow}Non-interactive terminal detected, defaulting to global install${reset}\n`);
+    installAllRuntimes(runtimes, true, false);
+    return;
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let answered = false;
+
+  rl.on('close', () => {
+    if (!answered) { answered = true; console.log(`\n  ${yellow}Installation cancelled${reset}\n`); process.exit(0); }
+  });
+
+  const pathExamples = runtimes.map(r => getGlobalDir(r, explicitConfigDir).replace(os.homedir(), '~')).join(', ');
+  const localExamples = runtimes.map(r => `./${getDirName(r)}`).join(', ');
+
+  console.log(`  ${yellow}Where would you like to install?${reset}\n
+  ${cyan}1${reset}) Global ${dim}(${pathExamples})${reset} - available in all projects
+  ${cyan}2${reset}) Local  ${dim}(${localExamples})${reset} - this project only\n`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    answered = true;
+    rl.close();
+    const isGlobal = (answer.trim() || '1') !== '2';
+    installAllRuntimes(runtimes, isGlobal, true);
+  });
+}
+
+function installAllRuntimes(runtimes, isGlobal, isInteractive) {
+  const results = [];
+  for (const runtime of runtimes) {
+    results.push(install(isGlobal, runtime));
+  }
+
+  // Handle statusline for Claude & Gemini
+  const claudeResult = results.find(r => r.runtime === 'claude');
+  const geminiResult = results.find(r => r.runtime === 'gemini');
+
+  if (claudeResult || geminiResult) {
+    const primaryResult = claudeResult || geminiResult;
+    handleStatusline(primaryResult.settings, isInteractive, (shouldInstallStatusline) => {
+      for (const result of results) {
+        finishInstall(result.settingsPath, result.settings, result.statuslineCommand, shouldInstallStatusline, result.runtime, isGlobal);
+      }
+    });
+  } else {
+    for (const result of results) {
+      finishInstall(result.settingsPath, result.settings, result.statuslineCommand, false, result.runtime, isGlobal);
+    }
+  }
+}
+
+// ──────────────────────────────────────────────────────
+// Main
+// ──────────────────────────────────────────────────────
+
+if (hasGlobal && hasLocal) {
+  console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
+  process.exit(1);
+} else if (explicitConfigDir && hasLocal) {
+  console.error(`  ${yellow}Cannot use --config-dir with --local${reset}`);
+  process.exit(1);
+} else if (hasUninstall) {
+  if (!hasGlobal && !hasLocal) {
+    console.error(`  ${yellow}--uninstall requires --global or --local${reset}`);
+    process.exit(1);
+  }
+  const runtimes = selectedRuntimes.length > 0 ? selectedRuntimes : ['claude'];
+  for (const runtime of runtimes) {
+    uninstall(hasGlobal, runtime);
+  }
+} else if (selectedRuntimes.length > 0) {
+  if (!hasGlobal && !hasLocal) {
+    promptLocation(selectedRuntimes);
+  } else {
+    installAllRuntimes(selectedRuntimes, hasGlobal, false);
+  }
+} else if (hasGlobal || hasLocal) {
+  installAllRuntimes(['claude'], hasGlobal, false);
+} else {
+  if (!process.stdin.isTTY) {
+    console.log(`  ${yellow}Non-interactive terminal detected, defaulting to Claude Code global install${reset}\n`);
+    installAllRuntimes(['claude'], true, false);
+  } else {
+    promptRuntime((runtimes) => {
+      promptLocation(runtimes);
+    });
+  }
+}