coder-config 0.42.13 → 0.42.15

package/README.md

@@ -143,6 +143,15 @@ coder-config workstream install-hook      # Install hook for Claude Code
 coder-config workstream install-hook --gemini  # Install hook for Gemini CLI
 coder-config workstream install-hook --codex   # Install hook for Codex CLI
 coder-config workstream install-hook --all     # Install hooks for all supported tools
+
+# Folder auto-activation
+coder-config workstream add-trigger <ws> <folder>  # Add trigger folder
+coder-config workstream remove-trigger <ws> <folder>  # Remove trigger folder
+coder-config workstream auto-activate <ws> [on|off|default]  # Set auto-activate
+coder-config workstream check-folder [path] [--json]  # Check folder for matches
+coder-config workstream install-cd-hook    # Install cd hook for shell
+coder-config workstream uninstall-cd-hook  # Remove cd hook
+coder-config workstream cd-hook-status     # Check cd hook status
 ```
 
 **Per-terminal isolation**: With [shell integration](#shell-integration), each terminal can have its own active workstream:
@@ -171,6 +180,37 @@ coder-config workstream install-hook --codex
 coder-config workstream install-hook --all
 ```
 
+**Folder auto-activation**: Automatically activate workstreams when you cd into matching directories:
+```bash
+# Install the cd hook (adds function to ~/.zshrc or ~/.bashrc)
+coder-config workstream install-cd-hook
+
+# Now when you cd into a project folder:
+cd ~/projects/my-app  # Auto-activates matching workstream
+# Output: 📂 Workstream: My App
+
+# If multiple workstreams match, you'll be prompted:
+cd ~/projects
+# Output: Multiple workstreams match this folder:
+#   1) Frontend
+#   2) Backend
+#   0) Skip
+# Choose [0-2]:
+```
+
+**Trigger folders**: Besides project paths, you can add extra trigger folders:
+```bash
+coder-config workstream add-trigger "My Work" ~/projects
+coder-config workstream remove-trigger "My Work" ~/projects
+```
+
+**Auto-activate setting**: Control per-workstream or globally:
+```bash
+coder-config workstream auto-activate "My Work" on      # Always auto-activate
+coder-config workstream auto-activate "My Work" off     # Never auto-activate
+coder-config workstream auto-activate "My Work" default # Use global setting
+```
+
 ### Loop Commands (Ralph Loop)
 
 Ralph Loops enable autonomous development - Claude Code runs continuously until a task is completed.

package/config-loader.js

@@ -28,7 +28,7 @@ const { init, show } = require('./lib/init');
 const { memoryList, memoryInit, memoryAdd, memorySearch } = require('./lib/memory');
 const { envList, envSet, envUnset } = require('./lib/env');
 const { getProjectsRegistryPath, loadProjectsRegistry, saveProjectsRegistry, projectList, projectAdd, projectRemove } = require('./lib/projects');
-const { getWorkstreamsPath, loadWorkstreams, saveWorkstreams, workstreamList, workstreamCreate, workstreamUpdate, workstreamDelete, workstreamUse, workstreamActive, workstreamAddProject, workstreamRemoveProject, workstreamInject, workstreamDetect, workstreamGet, getActiveWorkstream, countWorkstreamsForProject, workstreamInstallHook, workstreamInstallHookGemini, workstreamInstallHookCodex, workstreamDeactivate, workstreamCheckPath } = require('./lib/workstreams');
+const { getWorkstreamsPath, loadWorkstreams, saveWorkstreams, workstreamList, workstreamCreate, workstreamUpdate, workstreamDelete, workstreamUse, workstreamActive, workstreamAddProject, workstreamRemoveProject, workstreamInject, workstreamDetect, workstreamGet, getActiveWorkstream, countWorkstreamsForProject, workstreamInstallHook, workstreamInstallHookGemini, workstreamInstallHookCodex, workstreamDeactivate, workstreamCheckPath, getSettingsPath, loadSettings, saveSettings, workstreamAddTrigger, workstreamRemoveTrigger, workstreamSetAutoActivate, setGlobalAutoActivate, shouldAutoActivate, workstreamCheckFolder, workstreamInstallCdHook, workstreamUninstallCdHook, workstreamCdHookStatus } = require('./lib/workstreams');
 const { getActivityPath, getDefaultActivity, loadActivity, saveActivity, detectProjectRoot, activityLog, activitySummary, generateWorkstreamName, activitySuggestWorkstreams, activityClear } = require('./lib/activity');
 const { getLoopsPath, loadLoops, saveLoops, loadLoopState, saveLoopState, loadHistory, saveHistory, loopList, loopCreate, loopGet, loopUpdate, loopDelete, loopStart, loopPause, loopResume, loopCancel, loopApprove, loopComplete, loopStatus, loopHistory, loopConfig, getActiveLoop, recordIteration, saveClarifications, savePlan, loadClarifications, loadPlan, loopInject, archiveLoop } = require('./lib/loops');
 const { runCli } = require('./lib/cli');
@@ -148,6 +148,19 @@ class ClaudeConfigManager {
   workstreamInstallHookCodex() { return workstreamInstallHookCodex(); }
   workstreamDeactivate() { return workstreamDeactivate(); }
   workstreamCheckPath(targetPath, silent) { return workstreamCheckPath(this.installDir, targetPath, silent); }
+  // Workstream folder auto-activation
+  getSettingsPath() { return getSettingsPath(this.installDir); }
+  loadSettings() { return loadSettings(this.installDir); }
+  saveSettings(settings) { return saveSettings(this.installDir, settings); }
+  workstreamAddTrigger(idOrName, folderPath) { return workstreamAddTrigger(this.installDir, idOrName, folderPath); }
+  workstreamRemoveTrigger(idOrName, folderPath) { return workstreamRemoveTrigger(this.installDir, idOrName, folderPath); }
+  workstreamSetAutoActivate(idOrName, value) { return workstreamSetAutoActivate(this.installDir, idOrName, value); }
+  setGlobalAutoActivate(value) { return setGlobalAutoActivate(this.installDir, value); }
+  shouldAutoActivate(workstream) { return shouldAutoActivate(this.installDir, workstream); }
+  workstreamCheckFolder(folderPath, jsonOutput) { return workstreamCheckFolder(this.installDir, folderPath, jsonOutput); }
+  workstreamInstallCdHook() { return workstreamInstallCdHook(); }
+  workstreamUninstallCdHook() { return workstreamUninstallCdHook(); }
+  workstreamCdHookStatus() { return workstreamCdHookStatus(); }
 
   // Loops (Ralph Loop)
   getLoopsPath() { return getLoopsPath(this.installDir); }

package/lib/cli.js

@@ -144,6 +144,38 @@ function runCli(manager) {
         const silent = args.includes('--silent') || args.includes('-s');
         const isValid = manager.workstreamCheckPath(targetPath, silent);
         process.exit(isValid ? 0 : 1);
+      } else if (args[1] === 'add-trigger') {
+        if (!args[2] || !args[3]) {
+          console.error('Usage: coder-config workstream add-trigger <workstream> <folder>');
+          process.exit(1);
+        }
+        manager.workstreamAddTrigger(args[2], args[3]);
+      } else if (args[1] === 'remove-trigger') {
+        if (!args[2] || !args[3]) {
+          console.error('Usage: coder-config workstream remove-trigger <workstream> <folder>');
+          process.exit(1);
+        }
+        manager.workstreamRemoveTrigger(args[2], args[3]);
+      } else if (args[1] === 'auto-activate') {
+        if (!args[2]) {
+          console.error('Usage: coder-config workstream auto-activate <workstream> [on|off|default]');
+          process.exit(1);
+        }
+        const value = args[3] || 'on';
+        manager.workstreamSetAutoActivate(args[2], value);
+      } else if (args[1] === 'check-folder') {
+        const folderPath = args[2] || process.cwd();
+        const jsonOutput = args.includes('--json') || args.includes('-j');
+        manager.workstreamCheckFolder(folderPath, jsonOutput);
+      } else if (args[1] === 'install-cd-hook') {
+        manager.workstreamInstallCdHook();
+      } else if (args[1] === 'uninstall-cd-hook') {
+        manager.workstreamUninstallCdHook();
+      } else if (args[1] === 'cd-hook-status') {
+        const status = manager.workstreamCdHookStatus();
+        console.log(`CD hook: ${status.installed ? 'installed' : 'not installed'}`);
+        console.log(`Shell: ${status.shell}`);
+        console.log(`RC file: ${status.rcFile}`);
       } else {
         manager.workstreamList();
       }
@@ -286,6 +318,15 @@ Workstream Commands:
   workstream install-hook --codex    Install for Codex CLI
   workstream install-hook --all      Install for all supported tools
 
+  Folder Auto-Activation:
+  workstream add-trigger <ws> <folder>    Add trigger folder
+  workstream remove-trigger <ws> <folder> Remove trigger folder
+  workstream auto-activate <ws> [on|off|default]  Set auto-activate
+  workstream check-folder [path] [--json] Check folder for matches
+  workstream install-cd-hook       Install cd hook for auto-activation
+  workstream uninstall-cd-hook     Remove cd hook
+  workstream cd-hook-status        Check if cd hook is installed
+
   Per-session activation (enables parallel work):
     export CODER_WORKSTREAM=<name-or-id>
 

package/lib/constants.js

@@ -2,7 +2,7 @@
  * Constants and tool path configurations
  */
 
-const VERSION = '0.42.13';
+const VERSION = '0.42.15';
 
 // Tool-specific path configurations
 const TOOL_PATHS = {

package/lib/workstreams.js

@@ -875,6 +875,371 @@ function extractFirstParagraph(content) {
   return result.join(' ').replace(/\s+/g, ' ').trim();
 }
 
+/**
+ * Get global settings path
+ */
+function getSettingsPath(installDir) {
+  return path.join(installDir, 'settings.json');
+}
+
+/**
+ * Load global settings
+ */
+function loadSettings(installDir) {
+  const settingsPath = getSettingsPath(installDir);
+  if (fs.existsSync(settingsPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    } catch (e) {
+      return { workstreamAutoActivate: true };
+    }
+  }
+  return { workstreamAutoActivate: true };
+}
+
+/**
+ * Save global settings
+ */
+function saveSettings(installDir, settings) {
+  const settingsPath = getSettingsPath(installDir);
+  const dir = path.dirname(settingsPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
+/**
+ * Add trigger folder to workstream
+ */
+function workstreamAddTrigger(installDir, idOrName, folderPath) {
+  const data = loadWorkstreams(installDir);
+  const ws = data.workstreams.find(
+    w => w.id === idOrName || w.name.toLowerCase() === idOrName.toLowerCase()
+  );
+
+  if (!ws) {
+    console.error(`Workstream not found: ${idOrName}`);
+    return null;
+  }
+
+  const absPath = path.resolve(folderPath.replace(/^~/, process.env.HOME || ''));
+
+  if (!ws.triggerFolders) {
+    ws.triggerFolders = [];
+  }
+
+  if (!ws.triggerFolders.includes(absPath)) {
+    ws.triggerFolders.push(absPath);
+    ws.updatedAt = new Date().toISOString();
+    saveWorkstreams(installDir, data);
+    console.log(`✓ Added trigger folder ${path.basename(absPath)} to ${ws.name}`);
+  } else {
+    console.log(`Trigger folder already in workstream: ${path.basename(absPath)}`);
+  }
+
+  return ws;
+}
+
+/**
+ * Remove trigger folder from workstream
+ */
+function workstreamRemoveTrigger(installDir, idOrName, folderPath) {
+  const data = loadWorkstreams(installDir);
+  const ws = data.workstreams.find(
+    w => w.id === idOrName || w.name.toLowerCase() === idOrName.toLowerCase()
+  );
+
+  if (!ws) {
+    console.error(`Workstream not found: ${idOrName}`);
+    return null;
+  }
+
+  const absPath = path.resolve(folderPath.replace(/^~/, process.env.HOME || ''));
+
+  if (!ws.triggerFolders) {
+    ws.triggerFolders = [];
+  }
+
+  const idx = ws.triggerFolders.indexOf(absPath);
+
+  if (idx !== -1) {
+    ws.triggerFolders.splice(idx, 1);
+    ws.updatedAt = new Date().toISOString();
+    saveWorkstreams(installDir, data);
+    console.log(`✓ Removed trigger folder ${path.basename(absPath)} from ${ws.name}`);
+  } else {
+    console.log(`Trigger folder not in workstream: ${path.basename(absPath)}`);
+  }
+
+  return ws;
+}
+
+/**
+ * Set auto-activate for a workstream
+ * value: true, false, or null (use global default)
+ */
+function workstreamSetAutoActivate(installDir, idOrName, value) {
+  const data = loadWorkstreams(installDir);
+  const ws = data.workstreams.find(
+    w => w.id === idOrName || w.name.toLowerCase() === idOrName.toLowerCase()
+  );
+
+  if (!ws) {
+    console.error(`Workstream not found: ${idOrName}`);
+    return null;
+  }
+
+  if (value === 'on' || value === true) {
+    ws.autoActivate = true;
+    console.log(`✓ Auto-activate enabled for ${ws.name}`);
+  } else if (value === 'off' || value === false) {
+    ws.autoActivate = false;
+    console.log(`✓ Auto-activate disabled for ${ws.name}`);
+  } else if (value === 'default' || value === null) {
+    delete ws.autoActivate;
+    console.log(`✓ Auto-activate set to global default for ${ws.name}`);
+  }
+
+  ws.updatedAt = new Date().toISOString();
+  saveWorkstreams(installDir, data);
+  return ws;
+}
+
+/**
+ * Set global auto-activate setting
+ */
+function setGlobalAutoActivate(installDir, value) {
+  const settings = loadSettings(installDir);
+  settings.workstreamAutoActivate = value === true || value === 'true' || value === 'on';
+  saveSettings(installDir, settings);
+  console.log(`✓ Global workstream auto-activate: ${settings.workstreamAutoActivate ? 'on' : 'off'}`);
+  return settings;
+}
+
+/**
+ * Check if a workstream should auto-activate based on its setting and global default
+ */
+function shouldAutoActivate(installDir, workstream) {
+  if (workstream.autoActivate === true) return true;
+  if (workstream.autoActivate === false) return false;
+  // Use global default
+  const settings = loadSettings(installDir);
+  return settings.workstreamAutoActivate !== false;
+}
+
+/**
+ * Check folder for matching workstreams
+ * Returns { count, current, matches: [{id, name, autoActivate}] }
+ */
+function workstreamCheckFolder(installDir, folderPath = process.cwd(), jsonOutput = false) {
+  const data = loadWorkstreams(installDir);
+  const absPath = path.resolve(folderPath.replace(/^~/, process.env.HOME || ''));
+
+  // Find all workstreams that match this folder
+  const matches = data.workstreams.filter(ws => {
+    // Check if folder is within any project
+    const inProject = (ws.projects || []).some(p =>
+      absPath === p || absPath.startsWith(p + path.sep) || p.startsWith(absPath + path.sep)
+    );
+    // Check if folder is within any trigger folder
+    const inTrigger = (ws.triggerFolders || []).some(t =>
+      absPath === t || absPath.startsWith(t + path.sep) || t.startsWith(absPath + path.sep)
+    );
+    return inProject || inTrigger;
+  });
+
+  // Filter to only those that should auto-activate
+  const autoActivateMatches = matches.filter(ws => shouldAutoActivate(installDir, ws));
+
+  // Check if current workstream is already one of the matches
+  const currentWs = getActiveWorkstream(installDir);
+  const currentIsMatch = currentWs && autoActivateMatches.some(m => m.id === currentWs.id);
+
+  const result = {
+    count: autoActivateMatches.length,
+    current: currentIsMatch,
+    matches: autoActivateMatches.map(ws => ({
+      id: ws.id,
+      name: ws.name,
+      autoActivate: ws.autoActivate
+    }))
+  };
+
+  if (jsonOutput) {
+    console.log(JSON.stringify(result));
+  } else {
+    if (result.count === 0) {
+      console.log('No matching workstreams for this folder');
+    } else if (result.current) {
+      console.log(`Current workstream "${currentWs.name}" matches this folder`);
+    } else if (result.count === 1) {
+      console.log(`Matching workstream: ${result.matches[0].name}`);
+    } else {
+      console.log(`${result.count} matching workstreams:`);
+      result.matches.forEach((m, i) => {
+        console.log(`  ${i + 1}) ${m.name}`);
+      });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Install the cd hook for automatic workstream activation
+ */
+function workstreamInstallCdHook() {
+  const shell = process.env.SHELL || '/bin/zsh';
+  const isZsh = shell.includes('zsh');
+  const rcFile = isZsh
+    ? path.join(process.env.HOME || '', '.zshrc')
+    : path.join(process.env.HOME || '', '.bashrc');
+
+  const hookMarker = '# coder-config workstream cd hook';
+  const hookCode = `
+${hookMarker}
+coder_workstream_cd() {
+  builtin cd "$@" || return $?
+
+  # Check for matching workstreams
+  local result
+  result=$(coder-config workstream check-folder "$PWD" --json 2>/dev/null)
+
+  [ -z "$result" ] && return 0
+
+  local count current
+  count=$(echo "$result" | grep -o '"count":[0-9]*' | cut -d: -f2)
+  current=$(echo "$result" | grep -o '"current":true' || echo "")
+
+  # Already on matching workstream
+  [ -n "$current" ] && return 0
+
+  [ "$count" = "0" ] && return 0
+
+  if [ "$count" = "1" ]; then
+    # Single match - auto-activate
+    local name id
+    name=$(echo "$result" | grep -o '"name":"[^"]*"' | head -1 | cut -d'"' -f4)
+    id=$(echo "$result" | grep -o '"id":"[^"]*"' | head -1 | cut -d'"' -f4)
+    export CODER_WORKSTREAM="$id"
+    echo "📂 Workstream: $name"
+  elif [ "$count" -gt 1 ]; then
+    # Multiple matches - prompt
+    echo "Multiple workstreams match this folder:"
+    local i=1
+    echo "$result" | grep -o '"name":"[^"]*"' | cut -d'"' -f4 | while read -r name; do
+      echo "  $i) $name"
+      i=$((i + 1))
+    done
+    echo "  0) Skip"
+    ${isZsh ? 'read "choice?Choose [0-$count]: "' : 'read -p "Choose [0-$count]: " choice'}
+    if [ "$choice" -gt 0 ] 2>/dev/null; then
+      local id name
+      id=$(echo "$result" | grep -o '"id":"[^"]*"' | sed -n "${choice}p" | cut -d'"' -f4)
+      name=$(echo "$result" | grep -o '"name":"[^"]*"' | sed -n "${choice}p" | cut -d'"' -f4)
+      if [ -n "$id" ]; then
+        export CODER_WORKSTREAM="$id"
+        echo "📂 Workstream: $name"
+      fi
+    fi
+  fi
+}
+alias cd='coder_workstream_cd'
+# end coder-config workstream cd hook
+`;
+
+  // Check if hook already installed
+  if (fs.existsSync(rcFile)) {
+    const content = fs.readFileSync(rcFile, 'utf8');
+    if (content.includes(hookMarker)) {
+      console.log('✓ Workstream cd hook already installed');
+      console.log(`  Location: ${rcFile}`);
+      return true;
+    }
+  }
+
+  // Append hook to rc file
+  fs.appendFileSync(rcFile, hookCode);
+  console.log(`✓ Installed workstream cd hook`);
+  console.log(`  Location: ${rcFile}`);
+  console.log('');
+  console.log('Restart your shell or run:');
+  console.log(`  source ${rcFile}`);
+
+  return true;
+}
+
+/**
+ * Uninstall the cd hook
+ */
+function workstreamUninstallCdHook() {
+  const shell = process.env.SHELL || '/bin/zsh';
+  const isZsh = shell.includes('zsh');
+  const rcFile = isZsh
+    ? path.join(process.env.HOME || '', '.zshrc')
+    : path.join(process.env.HOME || '', '.bashrc');
+
+  if (!fs.existsSync(rcFile)) {
+    console.log('Shell config file not found');
+    return false;
+  }
+
+  const content = fs.readFileSync(rcFile, 'utf8');
+  const hookMarker = '# coder-config workstream cd hook';
+  const endMarker = '# end coder-config workstream cd hook';
+
+  if (!content.includes(hookMarker)) {
+    console.log('Workstream cd hook not installed');
+    return false;
+  }
+
+  // Remove the hook block
+  const startIdx = content.indexOf(hookMarker);
+  const endIdx = content.indexOf(endMarker);
+
+  if (startIdx === -1 || endIdx === -1) {
+    console.error('Could not find hook boundaries');
+    return false;
+  }
+
+  // Find the newline before the marker (to remove leading blank line)
+  let removeStart = startIdx;
+  if (startIdx > 0 && content[startIdx - 1] === '\n') {
+    removeStart = startIdx - 1;
+  }
+
+  const newContent = content.slice(0, removeStart) + content.slice(endIdx + endMarker.length);
+  fs.writeFileSync(rcFile, newContent);
+
+  console.log(`✓ Uninstalled workstream cd hook from ${rcFile}`);
+  console.log('');
+  console.log('Restart your shell or run:');
+  console.log(`  source ${rcFile}`);
+
+  return true;
+}
+
+/**
+ * Check if cd hook is installed
+ */
+function workstreamCdHookStatus() {
+  const shell = process.env.SHELL || '/bin/zsh';
+  const isZsh = shell.includes('zsh');
+  const rcFile = isZsh
+    ? path.join(process.env.HOME || '', '.zshrc')
+    : path.join(process.env.HOME || '', '.bashrc');
+
+  if (!fs.existsSync(rcFile)) {
+    return { installed: false, shell: isZsh ? 'zsh' : 'bash', rcFile };
+  }
+
+  const content = fs.readFileSync(rcFile, 'utf8');
+  const installed = content.includes('# coder-config workstream cd hook');
+
+  return { installed, shell: isZsh ? 'zsh' : 'bash', rcFile };
+}
+
 module.exports = {
   getWorkstreamsPath,
   loadWorkstreams,
@@ -899,4 +1264,17 @@ module.exports = {
   workstreamCheckPath,
   generateRulesFromRepos,
   generateRulesWithClaude,
+  // New folder auto-activation functions
+  getSettingsPath,
+  loadSettings,
+  saveSettings,
+  workstreamAddTrigger,
+  workstreamRemoveTrigger,
+  workstreamSetAutoActivate,
+  setGlobalAutoActivate,
+  shouldAutoActivate,
+  workstreamCheckFolder,
+  workstreamInstallCdHook,
+  workstreamUninstallCdHook,
+  workstreamCdHookStatus,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coder-config",
-  "version": "0.42.13",
+  "version": "0.42.15",
   "description": "Configuration manager for AI coding tools - Claude Code, Gemini CLI, Codex CLI, Antigravity. Manage MCPs, rules, permissions, memory, and workstreams.",
   "author": "regression.io",
   "main": "config-loader.js",