coder-config 0.40.1

package/lib/cli.js

@@ -0,0 +1,267 @@
+/**
+ * CLI command handler
+ */
+
+const path = require('path');
+const { VERSION, TOOL_PATHS } = require('./constants');
+
+/**
+ * Run CLI command
+ */
+function runCli(manager) {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  switch (command) {
+    // Core
+    case 'init':
+      manager.init(args[1]);
+      break;
+    case 'apply':
+      manager.apply(args[1]);
+      break;
+    case 'show':
+      manager.show(args[1]);
+      break;
+    case 'list':
+    case 'mcps':
+      manager.list();
+      break;
+
+    // Edit MCPs
+    case 'add':
+      manager.add(args.slice(1));
+      break;
+    case 'remove':
+    case 'rm':
+      manager.remove(args.slice(1));
+      break;
+
+    // Registry management
+    case 'registry':
+      if (args[1] === 'add') {
+        manager.registryAdd(args[2], args[3]);
+      } else if (args[1] === 'remove' || args[1] === 'rm') {
+        manager.registryRemove(args[2]);
+      } else {
+        manager.registryList();
+      }
+      break;
+
+    // Memory
+    case 'memory':
+      if (args[1] === 'init') {
+        manager.memoryInit(args[2]);
+      } else if (args[1] === 'add') {
+        manager.memoryAdd(args[2], args.slice(3).join(' '));
+      } else if (args[1] === 'search') {
+        manager.memorySearch(args.slice(2).join(' '));
+      } else {
+        manager.memoryList();
+      }
+      break;
+
+    // Environment
+    case 'env':
+      if (args[1] === 'set') {
+        manager.envSet(args[2], args[3]);
+      } else if (args[1] === 'unset') {
+        manager.envUnset(args[2]);
+      } else {
+        manager.envList();
+      }
+      break;
+
+    // Project registry (for UI)
+    case 'project':
+    case 'projects':
+      if (args[1] === 'add') {
+        const nameIdx = args.indexOf('--name');
+        const name = nameIdx !== -1 ? args[nameIdx + 1] : null;
+        const projectPath = args[2] && !args[2].startsWith('--') ? args[2] : process.cwd();
+        manager.projectAdd(projectPath, name);
+      } else if (args[1] === 'remove' || args[1] === 'rm') {
+        manager.projectRemove(args[2]);
+      } else {
+        manager.projectList();
+      }
+      break;
+
+    // Workstreams
+    case 'workstream':
+    case 'ws':
+      if (args[1] === 'create' || args[1] === 'new') {
+        manager.workstreamCreate(args[2]);
+      } else if (args[1] === 'delete' || args[1] === 'rm') {
+        manager.workstreamDelete(args[2]);
+      } else if (args[1] === 'use' || args[1] === 'switch') {
+        manager.workstreamUse(args[2]);
+      } else if (args[1] === 'add') {
+        manager.workstreamAddProject(args[2], args[3]);
+      } else if (args[1] === 'remove' || args[1] === 'rm') {
+        manager.workstreamRemoveProject(args[2], args[3]);
+      } else if (args[1] === 'inject') {
+        const silent = args.includes('--silent') || args.includes('-s');
+        manager.workstreamInject(silent);
+      } else if (args[1] === 'detect') {
+        const ws = manager.workstreamDetect(args[2] || process.cwd());
+        if (ws) {
+          console.log(ws.name);
+        }
+      } else if (args[1] === 'active') {
+        const ws = manager.workstreamActive();
+        if (ws) {
+          console.log(`Active: ${ws.name}`);
+          if (ws.projects && ws.projects.length > 0) {
+            console.log(`Projects: ${ws.projects.map(p => path.basename(p)).join(', ')}`);
+          }
+        } else {
+          console.log('No active workstream');
+        }
+      } else if (args[1] === 'install-hook') {
+        const forGemini = args.includes('--gemini') || args.includes('-g');
+        const forCodex = args.includes('--codex') || args.includes('-x');
+        const forAll = args.includes('--all') || args.includes('-a');
+        if (forAll) {
+          manager.workstreamInstallHook();
+          manager.workstreamInstallHookGemini();
+          manager.workstreamInstallHookCodex();
+        } else if (forGemini) {
+          manager.workstreamInstallHookGemini();
+        } else if (forCodex) {
+          manager.workstreamInstallHookCodex();
+        } else {
+          manager.workstreamInstallHook();
+        }
+      } else if (args[1] === 'deactivate') {
+        manager.workstreamDeactivate();
+      } else if (args[1] === 'check-path') {
+        const targetPath = args[2];
+        if (!targetPath) {
+          console.error('Usage: claude-config workstream check-path <path>');
+          process.exit(1);
+        }
+        const silent = args.includes('--silent') || args.includes('-s');
+        const isValid = manager.workstreamCheckPath(targetPath, silent);
+        process.exit(isValid ? 0 : 1);
+      } else {
+        manager.workstreamList();
+      }
+      break;
+
+    // Maintenance
+    case 'update':
+      manager.update(args.slice(1)).catch(err => {
+        console.error('Update error:', err.message);
+        process.exit(1);
+      });
+      break;
+    case 'ui': {
+      const UIServer = require('../ui/server.cjs');
+      const port = parseInt(args.find(a => a.startsWith('--port='))?.split('=')[1] || '3333');
+      const uiDir = args.find(a => !a.startsWith('--') && a !== 'ui') || process.cwd();
+      const uiServer = new UIServer(port, uiDir, manager);
+      uiServer.start();
+      break;
+    }
+    case 'version':
+    case '-v':
+    case '--version':
+      manager.version();
+      break;
+
+    default:
+      printHelp();
+  }
+}
+
+/**
+ * Print help message
+ */
+function printHelp() {
+  console.log(`
+coder-config v${VERSION}
+Configuration manager for AI coding tools
+
+Usage:
+  coder-config <command> [args]
+  claude-config <command> [args]  (alias)
+
+Project Commands:
+  init                       Initialize project with .claude/mcps.json
+  apply                      Generate .mcp.json from config
+  show                       Show current project config
+  list                       List available MCPs (✓ = active)
+  add <mcp> [mcp...]         Add MCP(s) to project
+  remove <mcp> [mcp...]      Remove MCP(s) from project
+
+Memory Commands:
+  memory                     Show memory status
+  memory init                Initialize project memory
+  memory add <type> <content>  Add entry (types: preference, correction, fact,
+                             context, pattern, decision, issue, history)
+  memory search <query>      Search all memory files
+
+Environment Commands:
+  env                        List environment variables
+  env set <KEY> <value>      Set variable in .claude/.env
+  env unset <KEY>            Remove variable
+
+Project Commands (for UI):
+  project                    List registered projects
+  project add [path]         Add project (defaults to cwd)
+  project add [path] --name X  Add with custom display name
+  project remove <name|path> Remove project from registry
+
+Workstream Commands:
+  workstream                 List all workstreams
+  workstream create "Name"   Create new workstream
+  workstream delete <name>   Delete workstream
+  workstream use <name>      Set active workstream (global)
+  workstream active          Show current active workstream
+  workstream deactivate      Show how to deactivate workstream
+  workstream add <ws> <path>     Add project to workstream
+  workstream remove <ws> <path>  Remove project from workstream
+  workstream inject [--silent]   Output restriction + context (for hooks)
+  workstream detect [path]   Detect workstream for directory
+  workstream install-hook    Install pre-prompt hook for Claude Code
+  workstream install-hook --gemini   Install for Gemini CLI
+  workstream install-hook --codex    Install for Codex CLI
+  workstream install-hook --all      Install for all supported tools
+
+  Per-session activation (enables parallel work):
+    export CLAUDE_WORKSTREAM=<name-or-id>
+
+Registry Commands:
+  registry                       List MCPs in global registry
+  registry add <name> '<json>'   Add MCP to global registry
+  registry remove <name>         Remove MCP from registry
+
+Maintenance:
+  update                     Check npm for updates and install if available
+  update --check             Check for updates without installing
+  update /path/to/source     Update from local development source
+  ui [--port=3333]           Start web UI (daemon mode by default)
+  ui install                 Auto-start on login (macOS LaunchAgent)
+  ui uninstall               Remove auto-start
+  ui status                  Check if UI daemon is running
+  ui stop                    Stop the UI daemon
+  version                    Show version info
+
+Plugins (use Claude Code CLI):
+  claude plugin marketplace add regression-io/claude-config-plugins
+  claude plugin install fastapi-support@claude-config-plugins
+
+Examples:
+  coder-config init
+  coder-config add postgres github
+  coder-config memory add preference "Use TypeScript for new files"
+  coder-config env set GITHUB_TOKEN ghp_xxx
+  coder-config apply
+`);
+}
+
+module.exports = {
+  runCli,
+  printHelp,
+};

package/lib/config.js

@@ -0,0 +1,171 @@
+/**
+ * Config finding and merging utilities
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { TOOL_PATHS } = require('./constants');
+const { loadJson } = require('./utils');
+
+/**
+ * Find project root (has .claude/ directory)
+ */
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    if (fs.existsSync(path.join(dir, '.claude'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Find ALL .claude/mcps.json configs from cwd up to root (and ~/.claude)
+ * Returns array from root to leaf (so child overrides parent when merged)
+ */
+function findAllConfigs(startDir = process.cwd()) {
+  const configs = [];
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+  const homeDir = process.env.HOME || '';
+
+  while (dir !== root) {
+    const configPath = path.join(dir, '.claude', 'mcps.json');
+    if (fs.existsSync(configPath)) {
+      configs.unshift({ dir, configPath });
+    }
+    dir = path.dirname(dir);
+  }
+
+  const homeConfig = path.join(homeDir, '.claude', 'mcps.json');
+  if (fs.existsSync(homeConfig)) {
+    if (!configs.some(c => c.configPath === homeConfig)) {
+      configs.unshift({ dir: homeDir, configPath: homeConfig });
+    }
+  }
+
+  return configs;
+}
+
+/**
+ * Merge multiple configs (later ones override earlier)
+ */
+function mergeConfigs(configs) {
+  const merged = {
+    include: [],
+    mcpServers: {},
+    enabledPlugins: {},
+    template: null
+  };
+
+  for (const { config } of configs) {
+    if (!config) continue;
+
+    if (config.include && Array.isArray(config.include)) {
+      for (const mcp of config.include) {
+        if (!merged.include.includes(mcp)) {
+          merged.include.push(mcp);
+        }
+      }
+    }
+
+    if (config.mcpServers) {
+      Object.assign(merged.mcpServers, config.mcpServers);
+    }
+
+    // Merge enabledPlugins - child overrides parent
+    // false explicitly disables a parent-enabled plugin
+    if (config.enabledPlugins) {
+      Object.assign(merged.enabledPlugins, config.enabledPlugins);
+    }
+
+    if (config.template) {
+      merged.template = config.template;
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Get project config path
+ */
+function getConfigPath(installDir, projectDir = null) {
+  const dir = projectDir || findProjectRoot() || process.cwd();
+  return path.join(dir, '.claude', 'mcps.json');
+}
+
+/**
+ * Collect files (rules or commands) from all directories in hierarchy
+ */
+function collectFilesFromHierarchy(configLocations, subdir) {
+  const fileMap = new Map();
+
+  for (const { dir } of configLocations) {
+    const dirPath = path.join(dir, '.claude', subdir);
+    if (fs.existsSync(dirPath)) {
+      const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.md'));
+      for (const file of files) {
+        fileMap.set(file, {
+          file,
+          source: dir,
+          fullPath: path.join(dirPath, file)
+        });
+      }
+    }
+  }
+
+  return Array.from(fileMap.values());
+}
+
+/**
+ * Find all MCP configs for a specific tool in hierarchy
+ */
+function findAllConfigsForTool(toolId, startDir = null) {
+  const tool = TOOL_PATHS[toolId];
+  if (!tool) return [];
+
+  const dir = startDir || findProjectRoot() || process.cwd();
+  const homeDir = process.env.HOME || '';
+  const configs = [];
+
+  let currentDir = dir;
+  const root = path.parse(currentDir).root;
+
+  while (currentDir && currentDir !== root && currentDir !== homeDir) {
+    const configPath = path.join(currentDir, tool.projectConfig || `${tool.projectFolder}/mcps.json`);
+    if (fs.existsSync(configPath)) {
+      configs.push({
+        dir: currentDir,
+        configPath,
+        type: 'project'
+      });
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  if (tool.globalMcpConfig) {
+    const globalPath = tool.globalMcpConfig.replace(/^~/, homeDir);
+    if (fs.existsSync(globalPath)) {
+      configs.push({
+        dir: homeDir,
+        configPath: globalPath,
+        type: 'global'
+      });
+    }
+  }
+
+  return configs.reverse();
+}
+
+module.exports = {
+  findProjectRoot,
+  findAllConfigs,
+  mergeConfigs,
+  getConfigPath,
+  collectFilesFromHierarchy,
+  findAllConfigsForTool,
+};

package/lib/constants.js

@@ -0,0 +1,55 @@
+/**
+ * Constants and tool path configurations
+ */
+
+const VERSION = '0.40.1';
+
+// Tool-specific path configurations
+const TOOL_PATHS = {
+  claude: {
+    name: 'Claude Code',
+    icon: 'sparkles',
+    color: 'orange',
+    globalConfig: '~/.claude/mcps.json',
+    globalSettings: '~/.claude/settings.json',
+    projectFolder: '.claude',
+    projectRules: '.claude/rules',
+    projectCommands: '.claude/commands',
+    projectWorkflows: '.claude/workflows',
+    projectInstructions: 'CLAUDE.md',
+    outputFile: '.mcp.json',
+    supportsEnvInterpolation: true,
+  },
+  gemini: {
+    name: 'Gemini CLI',
+    icon: 'terminal',
+    color: 'blue',
+    globalConfig: '~/.gemini/settings.json',
+    globalSettings: '~/.gemini/settings.json',
+    globalMcpConfig: '~/.gemini/mcps.json',
+    projectFolder: '.gemini',
+    projectConfig: '.gemini/mcps.json',
+    projectRules: '.gemini',
+    projectCommands: '.gemini/commands',
+    projectInstructions: 'GEMINI.md',
+    outputFile: '~/.gemini/settings.json',
+    supportsEnvInterpolation: true,
+    mergeIntoSettings: true,
+  },
+  antigravity: {
+    name: 'Antigravity',
+    icon: 'rocket',
+    color: 'purple',
+    globalConfig: '~/.gemini/antigravity/mcp_config.json',
+    globalMcpConfig: '~/.gemini/antigravity/mcps.json',
+    globalRules: '~/.gemini/GEMINI.md',
+    projectFolder: '.agent',
+    projectConfig: '.agent/mcps.json',
+    projectRules: '.agent/rules',
+    projectInstructions: 'GEMINI.md',
+    outputFile: '~/.gemini/antigravity/mcp_config.json',
+    supportsEnvInterpolation: false,
+  },
+};
+
+module.exports = { VERSION, TOOL_PATHS };

package/lib/env.js

@@ -0,0 +1,114 @@
+/**
+ * Environment variable commands
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * List environment variables
+ */
+function envList(projectDir = process.cwd()) {
+  const envPath = path.join(projectDir, '.claude', '.env');
+
+  console.log(`\n🔐 Environment Variables (${projectDir}/.claude/.env)\n`);
+
+  if (!fs.existsSync(envPath)) {
+    console.log('  No .env file found.');
+    console.log('  Create with: claude-config env set <KEY> <value>\n');
+    return;
+  }
+
+  const content = fs.readFileSync(envPath, 'utf8');
+  const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#'));
+
+  if (lines.length === 0) {
+    console.log('  No variables set.\n');
+    return;
+  }
+
+  for (const line of lines) {
+    const [key] = line.split('=');
+    if (key) {
+      console.log(`  ${key}=****`);
+    }
+  }
+  console.log(`\n  Total: ${lines.length} variable(s)\n`);
+}
+
+/**
+ * Set environment variable
+ */
+function envSet(key, value, projectDir = process.cwd()) {
+  if (!key || value === undefined) {
+    console.error('Usage: claude-config env set <KEY> <value>');
+    return;
+  }
+
+  const claudeDir = path.join(projectDir, '.claude');
+  const envPath = path.join(claudeDir, '.env');
+
+  if (!fs.existsSync(claudeDir)) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+  }
+
+  let lines = [];
+  if (fs.existsSync(envPath)) {
+    lines = fs.readFileSync(envPath, 'utf8').split('\n');
+  }
+
+  const keyUpper = key.toUpperCase();
+  let found = false;
+  lines = lines.map(line => {
+    if (line.startsWith(`${keyUpper}=`)) {
+      found = true;
+      return `${keyUpper}=${value}`;
+    }
+    return line;
+  });
+
+  if (!found) {
+    lines.push(`${keyUpper}=${value}`);
+  }
+
+  fs.writeFileSync(envPath, lines.filter(l => l.trim()).join('\n') + '\n');
+
+  console.log(`✓ Set ${keyUpper} in .claude/.env`);
+}
+
+/**
+ * Unset environment variable
+ */
+function envUnset(key, projectDir = process.cwd()) {
+  if (!key) {
+    console.error('Usage: claude-config env unset <KEY>');
+    return;
+  }
+
+  const envPath = path.join(projectDir, '.claude', '.env');
+
+  if (!fs.existsSync(envPath)) {
+    console.log('No .env file found.');
+    return;
+  }
+
+  const keyUpper = key.toUpperCase();
+  let lines = fs.readFileSync(envPath, 'utf8').split('\n');
+  const originalLength = lines.length;
+
+  lines = lines.filter(line => !line.startsWith(`${keyUpper}=`));
+
+  if (lines.length === originalLength) {
+    console.log(`Variable ${keyUpper} not found.`);
+    return;
+  }
+
+  fs.writeFileSync(envPath, lines.filter(l => l.trim()).join('\n') + '\n');
+  console.log(`✓ Removed ${keyUpper} from .claude/.env`);
+}
+
+module.exports = {
+  envList,
+  envSet,
+  envUnset,
+};

package/lib/index.js

@@ -0,0 +1,47 @@
+/**
+ * Claude Config Library - Modular exports
+ */
+
+module.exports = {
+  // Constants
+  ...require('./constants'),
+
+  // Utils
+  ...require('./utils'),
+
+  // Config
+  ...require('./config'),
+
+  // Templates
+  ...require('./templates'),
+
+  // Apply
+  ...require('./apply'),
+
+  // MCPs
+  ...require('./mcps'),
+
+  // Registry
+  ...require('./registry'),
+
+  // Init
+  ...require('./init'),
+
+  // Memory
+  ...require('./memory'),
+
+  // Env
+  ...require('./env'),
+
+  // Projects
+  ...require('./projects'),
+
+  // Workstreams
+  ...require('./workstreams'),
+
+  // Activity
+  ...require('./activity'),
+
+  // CLI
+  ...require('./cli'),
+};