gsd-opencode 1.3.31

package/bin/install.js

@@ -0,0 +1,222 @@
+#!/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");
+
+const banner = `
+${cyan}   ██████╗ ███████╗██████╗
+  ██╔════╝ ██╔════╝██╔══██╗
+  ██║  ███╗█████╗  ██║  ██║
+  ██║   ██║╚════██║██║  ██║
+  ╚██████╔╝███████║██████╔╝
+   ╚═════╝ ╚══════╝╚═════╝${reset}
+
+  Get Shit Done ${dim}v${pkg.version}${reset}
+  A meta-prompting, context engineering and spec-driven
+  development system for OpenCode by TÂCHES.
+`;
+
+// Parse args
+const args = process.argv.slice(2);
+const hasGlobal = args.includes("--global") || args.includes("-g");
+const hasLocal = args.includes("--local") || args.includes("-l");
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const configDirIndex = args.findIndex(
+    (arg) => arg === "--config-dir" || arg === "-c",
+  );
+  if (configDirIndex !== -1) {
+    const nextArg = args[configDirIndex + 1];
+    // Error if --config-dir is provided without a value or next arg is another flag
+    if (!nextArg || nextArg.startsWith("-")) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  // Also handle --config-dir=value format
+  const configDirArg = args.find(
+    (arg) => arg.startsWith("--config-dir=") || arg.startsWith("-c="),
+  );
+  if (configDirArg) {
+    return configDirArg.split("=")[1];
+  }
+  return null;
+}
+const explicitConfigDir = parseConfigDirArg();
+const hasHelp = args.includes("--help") || args.includes("-h");
+
+console.log(banner);
+
+// Show help if requested
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx gsd-opencode [options]
+
+  ${yellow}Options:${reset}
+    ${cyan}-g, --global${reset}              Install globally (to OpenCode config directory)
+    ${cyan}-l, --local${reset}               Install locally (to .opencode in current directory)
+    ${cyan}-c, --config-dir <path>${reset}   Specify custom OpenCode config directory
+    ${cyan}-h, --help${reset}                Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Install to default ~/.config/opencode directory${reset}
+    npx gsd-opencode --global
+
+    ${dim}# Install to custom config directory (for multiple OpenCode accounts)${reset}
+    npx gsd-opencode --global --config-dir ~/.opencode-bc
+
+    ${dim}# Using environment variable${reset}
+    OPENCODE_CONFIG_DIR=~/.opencode-bc npx gsd-opencode --global
+
+    ${dim}# Install to current project only${reset}
+    npx gsd-opencode --local
+
+  ${yellow}Notes:${reset}
+    The --config-dir option is useful when you have multiple OpenCode
+    configurations (e.g., for different subscriptions). It takes priority
+    over the OPENCODE_CONFIG_DIR environment variable.
+  `);
+  process.exit(0);
+}
+
+/**
+ * Expand ~ to home directory (shell doesn't expand in env vars passed to node)
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith("~/")) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * 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) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyWithPathReplacement(srcPath, destPath, pathPrefix);
+    } else if (entry.name.endsWith(".md")) {
+      // Replace ~/.claude/ and ./.claude/ with OpenCode paths
+      let content = fs.readFileSync(srcPath, "utf8");
+      content = content.replace(/~\/\.claude\//g, pathPrefix);
+      content = content.replace(/\.\/\.claude\//g, "./.opencode/");
+      fs.writeFileSync(destPath, content);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Install to the specified directory
+ */
+function install(isGlobal) {
+  const src = path.join(__dirname, "..");
+  // Priority: explicit --config-dir arg > OPENCODE_CONFIG_DIR env var > default ~/.config/opencode
+  const configDir =
+    expandTilde(explicitConfigDir) ||
+    expandTilde(process.env.OPENCODE_CONFIG_DIR);
+  const defaultGlobalDir = configDir || path.join(os.homedir(), ".config", "opencode");
+  const opencodeDir = isGlobal
+    ? defaultGlobalDir
+    : path.join(process.cwd(), ".opencode");
+
+  const locationLabel = isGlobal
+    ? opencodeDir.replace(os.homedir(), "~")
+    : opencodeDir.replace(process.cwd(), ".");
+
+  // Path prefix for file references
+  // Use actual path when OPENCODE_CONFIG_DIR is set, otherwise use ~ shorthand
+  const pathPrefix = isGlobal
+    ? configDir
+      ? `${opencodeDir}/`
+      : "~/.config/opencode/"
+    : "./.opencode/";
+
+  console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
+
+  // Create commands directory (singular "command" not "commands")
+  const commandsDir = path.join(opencodeDir, "command");
+  fs.mkdirSync(commandsDir, { recursive: true });
+
+  // Copy commands/gsd with path replacement
+  const gsdSrc = path.join(src, "command", "gsd");
+  const gsdDest = path.join(commandsDir, "gsd");
+  copyWithPathReplacement(gsdSrc, gsdDest, pathPrefix);
+  console.log(`  ${green}✓${reset} Installed command/gsd`);
+
+  // Copy get-shit-done skill with path replacement
+  const skillSrc = path.join(src, "get-shit-done");
+  const skillDest = path.join(opencodeDir, "get-shit-done");
+  copyWithPathReplacement(skillSrc, skillDest, pathPrefix);
+  console.log(`  ${green}✓${reset} Installed get-shit-done`);
+
+  console.log(`
+  ${green}Done!${reset} Run ${cyan}/gsd:help${reset} to get started.
+  `);
+}
+
+/**
+ * Prompt for install location
+ */
+function promptLocation() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const configDir =
+    expandTilde(explicitConfigDir) ||
+    expandTilde(process.env.OPENCODE_CONFIG_DIR);
+  const globalPath = configDir || path.join(os.homedir(), ".config", "opencode");
+  const globalLabel = globalPath.replace(os.homedir(), "~");
+
+  console.log(`  ${yellow}Where would you like to install?${reset}
+
+  ${cyan}1${reset}) Global ${dim}(${globalLabel})${reset} - available in all projects
+  ${cyan}2${reset}) Local  ${dim}(./.opencode)${reset} - this project only
+  `);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    rl.close();
+    const choice = answer.trim() || "1";
+    const isGlobal = choice !== "2";
+    install(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 (hasGlobal) {
+  install(true);
+} else if (hasLocal) {
+  install(false);
+} else {
+  promptLocation();
+}

package/command/gsd/add-phase.md

@@ -0,0 +1,207 @@
+---
+name: gsd:add-phase
+description: Add phase to end of current milestone in roadmap
+argument-hint: <description>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<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.
+</objective>
+
+<execution_context>
+@.planning/ROADMAP.md
+@.planning/STATE.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}`
+
+*`/clear` first → fresh context window*
+
+---
+
+**Also available:**
+- `/gsd:add-phase <description>` — add another phase
+- Review roadmap
+
+---
+```
+</step>
+
+</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>

package/command/gsd/complete-milestone.md

@@ -0,0 +1,105 @@
+---
+name: gsd:complete-milestone
+description: Archive completed milestone and prepare for next version
+argument-hint: <version>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<objective>
+Mark milestone {{version}} complete, archive to milestones/, and update ROADMAP.md.
+
+Purpose: Create historical record of shipped version, collapse completed work in roadmap, and prepare for next milestone.
+Output: Milestone archived, roadmap reorganized, git tagged.
+</objective>
+
+<execution_context>
+**Load these files NOW (before proceeding):**
+
+- @~/.config/opencode/get-shit-done/workflows/complete-milestone.md (main workflow)
+- @~/.config/opencode/get-shit-done/templates/milestone-archive.md (archive template)
+  </execution_context>
+
+<context>
+**Project files:**
+- `.planning/ROADMAP.md`
+- `.planning/STATE.md`
+- `.planning/PROJECT.md`
+
+**User input:**
+
+- Version: {{version}} (e.g., "1.0", "1.1", "2.0")
+  </context>
+
+<process>
+
+**Follow complete-milestone.md workflow:**
+
+1. **Verify readiness:**
+
+   - Check all phases in milestone have completed plans (SUMMARY.md exists)
+   - Present milestone scope and stats
+   - Wait for confirmation
+
+2. **Gather stats:**
+
+   - Count phases, plans, tasks
+   - Calculate git range, file changes, LOC
+   - Extract timeline from git log
+   - Present summary, confirm
+
+3. **Extract accomplishments:**
+
+   - Read all phase SUMMARY.md files in milestone range
+   - Extract 4-6 key accomplishments
+   - Present for approval
+
+4. **Archive milestone:**
+
+   - Create `.planning/milestones/v{{version}}-ROADMAP.md`
+   - Extract full phase details from ROADMAP.md
+   - Fill milestone-archive.md template
+   - Update ROADMAP.md to one-line summary with link
+   - Offer to create next milestone
+
+5. **Update PROJECT.md:**
+
+   - Add "Current State" section with shipped version
+   - Add "Next Milestone Goals" section
+   - Archive previous content in `<details>` (if v1.1+)
+
+6. **Commit and tag:**
+
+   - Stage: MILESTONES.md, PROJECT.md, ROADMAP.md, STATE.md, archive file
+   - Commit: `chore: archive v{{version}} milestone`
+   - Tag: `git tag -a v{{version}} -m "[milestone summary]"`
+   - Ask about pushing tag
+
+7. **Offer next steps:**
+   - Plan next milestone
+   - Archive planning
+   - Done for now
+
+</process>
+
+<success_criteria>
+
+- Milestone archived to `.planning/milestones/v{{version}}-ROADMAP.md`
+- ROADMAP.md collapsed to one-line entry
+- PROJECT.md updated with current state
+- Git tag v{{version}} created
+- Commit successful
+- User knows next steps
+  </success_criteria>
+
+<critical_rules>
+
+- **Load workflow first:** Read complete-milestone.md before executing
+- **Verify completion:** All phases must have SUMMARY.md files
+- **User confirmation:** Wait for approval at verification gates
+- **Archive before collapsing:** Always create archive file before updating ROADMAP.md
+- **One-line summary:** Collapsed milestone in ROADMAP.md should be single line with link
+- **Context efficiency:** Archive keeps ROADMAP.md constant size
+  </critical_rules>