@undeemed/get-shit-done-codex 1.6.12 → 1.20.2

package/bin/install.js

@@ -4,16 +4,20 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const readline = require('readline');
+const { execSync } = require('child_process');
 
-// 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');
+const NPM_PACKAGE = pkg.name;
+const NPM_PACKAGE_LATEST = `${NPM_PACKAGE}@latest`;
+const UPSTREAM_PACKAGE = 'get-shit-done-cc';
+const UPSTREAM_REPO = 'https://github.com/glittercowboy/get-shit-done';
+const FORK_REPO = 'https://github.com/undeemed/get-shit-done-codex';
 
 const banner = `
 ${green}   ██████╗ ███████╗██████╗
@@ -24,11 +28,10 @@ ${green}   ██████╗ ███████╗██████╗
     ╚═════╝ ╚══════╝╚═════╝${reset}
 
    Get Shit Done ${dim}v${pkg.version}${reset}
-   A meta - prompting, context engineering and spec - driven
-   development system for OpenAI Codex CLI originally by TÂCHES.
+   A meta-prompting, context engineering, and spec-driven
+   development system for OpenAI Codex (CLI + Desktop).
 `;
 
-// Parse args
 const args = process.argv.slice(2);
 const hasGlobal = args.includes('--global') || args.includes('-g');
 const hasLocal = args.includes('--local') || args.includes('-l');
@@ -36,56 +39,55 @@ const hasHelp = args.includes('--help') || args.includes('-h');
 
 console.log(banner);
 
-// Show help if requested
 if (hasHelp) {
-  console.log(`  ${yellow} Usage:${reset} npx get - shit - done - codex[options]
+  console.log(`  ${yellow}Usage:${reset} npx ${NPM_PACKAGE} [options]
 
-  ${yellow} Options:${reset}
-    ${cyan} -g, --global${reset}              Install globally(to ~/.codex/)
-    ${cyan} -l, --local${reset}               Install locally(to current directory)
-    ${cyan} -h, --help${reset}                Show this help message
+  ${yellow}Options:${reset}
+    ${cyan}-g, --global${reset}              Install globally (to ~/.codex/)
+    ${cyan}-l, --local${reset}               Install locally (to current directory)
+    ${cyan}-h, --help${reset}                Show this help message
 
-  ${yellow} Examples:${reset}
-    ${dim}# Install globally to ~/.codex directory${reset}
-    npx get - shit - done - codex--global
+  ${yellow}Examples:${reset}
+    ${dim}# Install globally${reset}
+    npx ${NPM_PACKAGE} --global
 
     ${dim}# Install to current project only${reset}
-    npx get - shit - done - codex--local
-
-  ${yellow} Notes:${reset}
-    For codex - cli, this installer:
-- Creates / updates AGENTS.md in the target directory
-  - Copies the get - shit - done skill and commands
-    - Global install goes to ~/.codex/(inherited by all projects)
-      - Local install puts files in current directory
+    npx ${NPM_PACKAGE} --local
+
+  ${yellow}Notes:${reset}
+    - Installs AGENTS.md into the target directory
+    - Installs GSD prompt commands into prompts/
+    - Installs get-shit-done/ workflow files
 `);
   process.exit(0);
 }
 
-/**
- * Apply content replacements for Codex CLI compatibility
- */
 function applyReplacements(content, pathPrefix) {
-  // Path replacements
-  content = content.replace(/~\/\.claude\//g, pathPrefix);
-  content = content.replace(/\.claude\//g, pathPrefix.replace('~/', ''));
+  const runtimeRelativePrefix = pathPrefix.replace('~/', '');
+  const explicitRelativePrefix = runtimeRelativePrefix === './'
+    ? './'
+    : `./${runtimeRelativePrefix}`;
+
+  // Replace explicit relative/global patterns first to avoid producing "././".
+  content = content.replace(/\.\/\.claude\//g, explicitRelativePrefix);
+  content = content.replace(/~\/\.claude\//g, '~/.codex/');
+  content = content.replace(/\.claude\//g, runtimeRelativePrefix);
 
-  // Claude → Codex naming
   content = content.replace(/Claude Code/g, 'Codex CLI');
   content = content.replace(/Claude/g, 'Codex');
 
-  // Command format: /gsd:name → /prompts:gsd-name (Codex CLI custom prompts format)
   content = content.replace(/\/gsd:/g, '/prompts:gsd-');
 
+  // Keep update workflows pointed to this fork's npm package/repo.
+  content = content.replace(new RegExp(UPSTREAM_PACKAGE, 'g'), NPM_PACKAGE);
+  content = content.replace(new RegExp(UPSTREAM_REPO.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), FORK_REPO);
+  content = content.replace(/npmjs\.com\/package\/get-shit-done-cc/g, `npmjs.com/package/${encodeURIComponent(NPM_PACKAGE)}`);
+
   return content;
 }
 
-/**
- * Recursively copy directory, replacing paths in .md files
- */
 function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
   fs.mkdirSync(destDir, { recursive: true });
-
   const entries = fs.readdirSync(srcDir, { withFileTypes: true });
 
   for (const entry of entries) {
@@ -94,118 +96,122 @@ function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
 
     if (entry.isDirectory()) {
       copyWithPathReplacement(srcPath, destPath, pathPrefix);
-    } else if (entry.name.endsWith('.md')) {
-      let content = fs.readFileSync(srcPath, 'utf8');
-      content = applyReplacements(content, pathPrefix);
-      fs.writeFileSync(destPath, content);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
+      continue;
+    }
+
+    if (entry.name.endsWith('.md')) {
+      const content = fs.readFileSync(srcPath, 'utf8');
+      fs.writeFileSync(destPath, applyReplacements(content, pathPrefix), 'utf8');
+      continue;
     }
+
+    fs.copyFileSync(srcPath, destPath);
   }
 }
 
-/**
- * Install to the specified directory
- */
-function install(isGlobal) {
-  const src = path.join(__dirname, '..');
-  const codexDir = isGlobal
-    ? path.join(os.homedir(), '.codex')
-    : process.cwd();
-
-  const locationLabel = isGlobal
-    ? '~/.codex'
-    : '.';
+function writeVersionFile(destDir, isGlobal) {
+  const versionFile = path.join(destDir, 'VERSION');
+  const installType = isGlobal ? 'GLOBAL' : 'LOCAL';
+  fs.writeFileSync(versionFile, `${pkg.version}\n${installType}\n`, 'utf8');
+}
 
-  // Path prefix for file references
-  const pathPrefix = isGlobal
-    ? '~/.codex/'
-    : './';
+function showCachedVersionWarning() {
+  try {
+    const latest = execSync(`npm view ${NPM_PACKAGE} version`, {
+      encoding: 'utf8',
+      timeout: 4000,
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    if (latest && latest !== pkg.version) {
+      console.log(`  ${yellow}Update available:${reset} v${pkg.version} -> v${latest}`);
+      console.log(`  Run ${cyan}npx ${NPM_PACKAGE_LATEST}${reset} to install the latest release.\n`);
+    }
+  } catch (_) {
+    // Offline or npm unavailable - skip.
+  }
+}
 
-  console.log(`  Installing to ${cyan}${locationLabel}${reset} \n`);
+function install(isGlobal) {
+  const src = path.join(__dirname, '..');
+  const codexDir = isGlobal ? path.join(os.homedir(), '.codex') : process.cwd();
+  const locationLabel = isGlobal ? '~/.codex' : '.';
+  const pathPrefix = isGlobal ? '~/.codex/' : './';
 
-  // Create target directory if needed
+  console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
   fs.mkdirSync(codexDir, { recursive: true });
 
-  // Copy AGENTS.md
   const agentsSrc = path.join(src, 'AGENTS.md');
   const agentsDest = path.join(codexDir, 'AGENTS.md');
-  let agentsContent = fs.readFileSync(agentsSrc, 'utf8');
-  agentsContent = applyReplacements(agentsContent, pathPrefix);
-  fs.writeFileSync(agentsDest, agentsContent);
+  const agentsContent = applyReplacements(fs.readFileSync(agentsSrc, 'utf8'), pathPrefix);
+  fs.writeFileSync(agentsDest, agentsContent, 'utf8');
   console.log(`  ${green}✓${reset} Installed AGENTS.md`);
 
-  // Create prompts directory (Codex CLI uses prompts/ for custom slash commands)
   const promptsDir = path.join(codexDir, 'prompts');
   fs.mkdirSync(promptsDir, { recursive: true });
 
-  // Copy commands/gsd as prompts (flatten the structure for Codex CLI)
-  // Codex CLI expects prompts/command-name.md format
   const gsdSrc = path.join(src, 'commands', 'gsd');
   const entries = fs.readdirSync(gsdSrc);
-  for (const entry of entries) {
-    if (entry.endsWith('.md')) {
-      const srcPath = path.join(gsdSrc, entry);
-      // Convert to gsd-command format (e.g., help.md -> gsd-help.md)
-      const destName = 'gsd-' + entry;
-      const destPath = path.join(promptsDir, destName);
-      let content = fs.readFileSync(srcPath, 'utf8');
-      content = applyReplacements(content, pathPrefix);
-      fs.writeFileSync(destPath, content);
-    }
+  const markdownEntries = entries.filter((entry) => entry.endsWith('.md'));
+  for (const entry of markdownEntries) {
+    const srcPath = path.join(gsdSrc, entry);
+    const destPath = path.join(promptsDir, `gsd-${entry}`);
+    const content = applyReplacements(fs.readFileSync(srcPath, 'utf8'), pathPrefix);
+    fs.writeFileSync(destPath, content, 'utf8');
   }
-  console.log(`  ${green}✓${reset} Installed prompts / gsd -*.md(${entries.filter(e => e.endsWith('.md')).length} commands)`);
+  console.log(`  ${green}✓${reset} Installed prompts/gsd-*.md (${markdownEntries.length} commands)`);
 
-  // Copy get-shit-done skill with path replacement
   const skillSrc = path.join(src, 'get-shit-done');
   const skillDest = path.join(codexDir, 'get-shit-done');
   copyWithPathReplacement(skillSrc, skillDest, pathPrefix);
-  console.log(`  ${green}✓${reset} Installed get - shit - done`);
+  writeVersionFile(skillDest, isGlobal);
+  console.log(`  ${green}✓${reset} Installed get-shit-done/ workflow files`);
+  console.log(`  ${green}✓${reset} Wrote get-shit-done/VERSION (${pkg.version})`);
 
   console.log(`
-  ${green} Done!${reset} 
-  
-  ${yellow}For Codex CLI:${reset}
-- AGENTS.md is at ${cyan}${codexDir}/AGENTS.md${reset}
-  - Slash commands are in ${cyan}${codexDir} /prompts/${reset}
-  
+  ${green}Done!${reset}
+
+  ${yellow}For Codex (CLI + Desktop):${reset}
+  - AGENTS.md: ${cyan}${codexDir}/AGENTS.md${reset}
+  - Prompt commands: ${cyan}${codexDir}/prompts/${reset}
+
   ${yellow}Getting Started:${reset}
-1. Run ${cyan}codex${reset} to start the Codex CLI
-2. Type ${cyan}/${reset} to see available commands
-3. Start with ${cyan}/prompts:gsd-new-project${reset} to initialize a project
+  1. Run ${cyan}codex${reset} (CLI) or ${cyan}codex app${reset} (Desktop)
+  2. Use ${cyan}/prompts:gsd-help${reset} to list commands
+  3. Start with ${cyan}/prompts:gsd-new-project${reset}
 
-  ${dim}Commands use / prompts: gsd - name format(e.g., /prompts:gsd-help)${reset}
+  ${yellow}Staying Updated:${reset}
+  - In Codex: ${cyan}/prompts:gsd-update${reset}
+  - In terminal: ${cyan}npx ${NPM_PACKAGE_LATEST}${reset}
 `);
 }
 
-/**
- * Prompt for install location
- */
 function promptLocation() {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
 
-  console.log(`  ${yellow}Where would you like to install ? ${reset}
+  console.log(`  ${yellow}Where would you like to install?${reset}
 
-  ${cyan} 1${reset}) Global ${dim} (~/.codex)${reset} - available in all projects
-  ${cyan} 2${reset}) Local  ${dim} (.)${reset} - this project only
+  ${cyan}1${reset}) Global ${dim}(~/.codex)${reset} - available in all projects
+  ${cyan}2${reset}) Local  ${dim}(.)${reset} - this project only
 `);
 
-  rl.question(`  Choice ${dim} [1]${reset}: `, (answer) => {
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
     rl.close();
     const choice = answer.trim() || '1';
-    const isGlobal = choice !== '2';
-    install(isGlobal);
+    install(choice !== '2');
   });
 }
 
-// Main
+showCachedVersionWarning();
+
 if (hasGlobal && hasLocal) {
-  console.error(`  ${yellow}Cannot specify both--global and--local${reset} `);
+  console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
   process.exit(1);
-} else if (hasGlobal) {
+}
+
+if (hasGlobal) {
   install(true);
 } else if (hasLocal) {
   install(false);

package/commands/gsd/add-phase.md

@@ -11,197 +11,29 @@ allowed-tools:
 <objective>
 Add a new integer phase to the end of the current milestone in the roadmap.
 
-This command appends sequential phases to the current milestone's phase list, automatically calculating the next phase number based on existing phases.
-
-Purpose: Add planned work discovered during execution that belongs at the end of current milestone.
+Routes to the add-phase workflow which handles:
+- Phase number calculation (next sequential integer)
+- Directory creation with slug generation
+- Roadmap structure updates
+- STATE.md roadmap evolution tracking
 </objective>
 
 <execution_context>
 @.planning/ROADMAP.md
 @.planning/STATE.md
+@~/.claude/get-shit-done/workflows/add-phase.md
 </execution_context>
 
 <process>
-
-<step name="parse_arguments">
-Parse the command arguments:
-- All arguments become the phase description
-- Example: `/gsd:add-phase Add authentication` → description = "Add authentication"
-- Example: `/gsd:add-phase Fix critical performance issues` → description = "Fix critical performance issues"
-
-If no arguments provided:
-
-```
-ERROR: Phase description required
-Usage: /gsd:add-phase <description>
-Example: /gsd:add-phase Add authentication system
-```
-
-Exit.
-</step>
-
-<step name="load_roadmap">
-Load the roadmap file:
-
-```bash
-if [ -f .planning/ROADMAP.md ]; then
-  ROADMAP=".planning/ROADMAP.md"
-else
-  echo "ERROR: No roadmap found (.planning/ROADMAP.md)"
-  exit 1
-fi
-```
-
-Read roadmap content for parsing.
-</step>
-
-<step name="find_current_milestone">
-Parse the roadmap to find the current milestone section:
-
-1. Locate the "## Current Milestone:" heading
-2. Extract milestone name and version
-3. Identify all phases under this milestone (before next "---" separator or next milestone heading)
-4. Parse existing phase numbers (including decimals if present)
-
-Example structure:
-
-```
-## Current Milestone: v1.0 Foundation
-
-### Phase 4: Focused Command System
-### Phase 5: Path Routing & Validation
-### Phase 6: Documentation & Distribution
-```
-
-</step>
-
-<step name="calculate_next_phase">
-Find the highest integer phase number in the current milestone:
-
-1. Extract all phase numbers from phase headings (### Phase N:)
-2. Filter to integer phases only (ignore decimals like 4.1, 4.2)
-3. Find the maximum integer value
-4. Add 1 to get the next phase number
-
-Example: If phases are 4, 5, 5.1, 6 → next is 7
-
-Format as two-digit: `printf "%02d" $next_phase`
-</step>
-
-<step name="generate_slug">
-Convert the phase description to a kebab-case slug:
-
-```bash
-# Example transformation:
-# "Add authentication" → "add-authentication"
-# "Fix critical performance issues" → "fix-critical-performance-issues"
-
-slug=$(echo "$description" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
-```
-
-Phase directory name: `{two-digit-phase}-{slug}`
-Example: `07-add-authentication`
-</step>
-
-<step name="create_phase_directory">
-Create the phase directory structure:
-
-```bash
-phase_dir=".planning/phases/${phase_num}-${slug}"
-mkdir -p "$phase_dir"
-```
-
-Confirm: "Created directory: $phase_dir"
-</step>
-
-<step name="update_roadmap">
-Add the new phase entry to the roadmap:
-
-1. Find the insertion point (after last phase in current milestone, before "---" separator)
-2. Insert new phase heading:
-
-   ```
-   ### Phase {N}: {Description}
-
-   **Goal:** [To be planned]
-   **Depends on:** Phase {N-1}
-   **Plans:** 0 plans
-
-   Plans:
-   - [ ] TBD (run /gsd:plan-phase {N} to break down)
-
-   **Details:**
-   [To be added during planning]
-   ```
-
-3. Write updated roadmap back to file
-
-Preserve all other content exactly (formatting, spacing, other phases).
-</step>
-
-<step name="update_project_state">
-Update STATE.md to reflect the new phase:
-
-1. Read `.planning/STATE.md`
-2. Under "## Current Position" → "**Next Phase:**" add reference to new phase
-3. Under "## Accumulated Context" → "### Roadmap Evolution" add entry:
-   ```
-   - Phase {N} added: {description}
-   ```
-
-If "Roadmap Evolution" section doesn't exist, create it.
-</step>
-
-<step name="completion">
-Present completion summary:
-
-```
-Phase {N} added to current milestone:
-- Description: {description}
-- Directory: .planning/phases/{phase-num}-{slug}/
-- Status: Not planned yet
-
-Roadmap updated: {roadmap-path}
-Project state updated: .planning/STATE.md
-
----
-
-## ▶ Next Up
-
-**Phase {N}: {description}**
-
-`/gsd:plan-phase {N}`
-
-<sub>`/clear` first → fresh context window</sub>
-
----
-
-**Also available:**
-- `/gsd:add-phase <description>` — add another phase
-- Review roadmap
-
----
-```
-</step>
-
+**Follow the add-phase workflow** from `@~/.claude/get-shit-done/workflows/add-phase.md`.
+
+The workflow handles all logic including:
+1. Argument parsing and validation
+2. Roadmap existence checking
+3. Current milestone identification
+4. Next phase number calculation (ignoring decimals)
+5. Slug generation from description
+6. Phase directory creation
+7. Roadmap entry insertion
+8. STATE.md updates
 </process>
-
-<anti_patterns>
-
-- Don't modify phases outside current milestone
-- Don't renumber existing phases
-- Don't use decimal numbering (that's /gsd:insert-phase)
-- Don't create plans yet (that's /gsd:plan-phase)
-- Don't commit changes (user decides when to commit)
-  </anti_patterns>
-
-<success_criteria>
-Phase addition is complete when:
-
-- [ ] Phase directory created: `.planning/phases/{NN}-{slug}/`
-- [ ] Roadmap updated with new phase entry
-- [ ] STATE.md updated with roadmap evolution note
-- [ ] New phase appears at end of current milestone
-- [ ] Next phase number calculated correctly (ignoring decimals)
-- [ ] User informed of next steps
-      </success_criteria>