coder-config 0.45.13 → 0.46.0-beta.10

package/config-loader.js

@@ -22,13 +22,13 @@ const { VERSION, TOOL_PATHS } = require('./lib/constants');
 const { loadJson, saveJson, loadEnvFile, interpolate, resolveEnvVars, copyDirRecursive } = require('./lib/utils');
 const { findProjectRoot, findAllConfigs, mergeConfigs, getConfigPath, collectFilesFromHierarchy, findAllConfigsForTool } = require('./lib/config');
 const { apply, applyForAntigravity, applyForGemini, detectInstalledTools, applyForTools } = require('./lib/apply');
-const { list, add, remove } = require('./lib/mcps');
+const { list, add, remove, listGlobal, addGlobal, removeGlobal } = require('./lib/mcps');
 const { registryList, registryAdd, registryRemove } = require('./lib/registry');
 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, getSettingsPath, loadSettings, saveSettings, workstreamAddTrigger, workstreamRemoveTrigger, workstreamSetAutoActivate, setGlobalAutoActivate, shouldAutoActivate, workstreamCheckFolder, workstreamInstallCdHook, workstreamUninstallCdHook, workstreamCdHookStatus, generateRulesFromRepos, generateRulesWithClaude } = 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, discoverSubProjects, generateRulesFromRepos, generateRulesWithClaude, generateRulesWithAI, getAvailableAITools, findAIBinary, AI_TOOLS } = 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, loopFail, loopStatus, loopHistory, loopConfig, getActiveLoop, recordIteration, saveClarifications, savePlan, loadClarifications, loadPlan, loopInject, archiveLoop } = require('./lib/loops');
 const { getSessionStatus, showSessionStatus, flushContext, clearContext, installHooks: sessionInstallHooks, getFlushedContext, installFlushCommand, installAll: sessionInstallAll, SESSION_DIR, FLUSHED_CONTEXT_FILE } = require('./lib/sessions');
@@ -138,11 +138,16 @@ class ClaudeConfigManager {
   getToolPaths() { return TOOL_PATHS; }
   applyForTools(projectDir, tools) { return applyForTools(this.registryPath, projectDir, tools); }
 
-  // MCPs
+  // MCPs (project)
   list() { return list(this.registryPath); }
   add(mcpNames) { return add(this.registryPath, this.installDir, mcpNames); }
   remove(mcpNames) { return remove(this.installDir, mcpNames); }
 
+  // MCPs (global - ~/.claude.json)
+  globalList() { return listGlobal(); }
+  globalAdd(mcpNames) { return addGlobal(this.registryPath, mcpNames); }
+  globalRemove(mcpNames) { return removeGlobal(mcpNames); }
+
   // Registry
   registryList() { return registryList(this.registryPath); }
   registryAdd(name, configJson) { return registryAdd(this.registryPath, name, configJson); }
@@ -208,6 +213,11 @@ class ClaudeConfigManager {
   workstreamCdHookStatus() { return workstreamCdHookStatus(); }
   generateRulesFromRepos(projects) { return generateRulesFromRepos(projects); }
   generateRulesWithClaude(projects) { return generateRulesWithClaude(projects); }
+  generateRulesWithAI(projects, toolId, options) { return generateRulesWithAI(projects, toolId, options); }
+  getAvailableAITools() { return getAvailableAITools(); }
+  findAIBinary(toolId) { return findAIBinary(toolId); }
+  get AI_TOOLS() { return AI_TOOLS; }
+  discoverSubProjects(rootPath, maxDepth) { return discoverSubProjects(rootPath, maxDepth); }
 
   // Loops (Ralph Loop)
   getLoopsPath() { return getLoopsPath(this.installDir); }

package/lib/apply.js

@@ -29,16 +29,37 @@ function apply(registryPath, projectDir = null) {
     return false;
   }
 
-  const loadedConfigs = configLocations.map(loc => ({
-    ...loc,
-    config: loadJson(loc.configPath)
-  }));
+  const loadedConfigs = configLocations.map(loc => {
+    const rawConfig = loadJson(loc.configPath);
+
+    // Handle ~/.claude.json format (global MCPs under mcpServers key)
+    if (loc.isGlobalClaudeJson && rawConfig) {
+      return {
+        ...loc,
+        config: {
+          include: [],
+          mcpServers: rawConfig.mcpServers || {}
+        }
+      };
+    }
 
-  if (loadedConfigs.length > 1) {
+    return {
+      ...loc,
+      config: rawConfig
+    };
+  });
+
+  // Filter out empty configs and show hierarchy
+  const activeConfigs = loadedConfigs.filter(c => c.config);
+  if (activeConfigs.length > 1) {
     console.log('📚 Config hierarchy (merged):');
-    for (const { dir: d, configPath } of loadedConfigs) {
+    for (const { dir: d, configPath, isGlobalClaudeJson } of activeConfigs) {
       const relPath = d === process.env.HOME ? '~' : path.relative(process.cwd(), d) || '.';
-      console.log(`  • ${relPath}/.claude/mcps.json`);
+      if (isGlobalClaudeJson) {
+        console.log(`  • ~/.claude.json (global MCPs)`);
+      } else {
+        console.log(`  • ${relPath}/.claude/mcps.json`);
+      }
     }
     console.log('');
   }

package/lib/cli.js

@@ -63,6 +63,17 @@ function runCli(manager) {
       manager.remove(args.slice(1));
       break;
 
+    // Global MCPs (~/.claude.json)
+    case 'global':
+      if (args[1] === 'add') {
+        manager.globalAdd(args.slice(2));
+      } else if (args[1] === 'remove' || args[1] === 'rm') {
+        manager.globalRemove(args.slice(2));
+      } else {
+        manager.globalList();
+      }
+      break;
+
     // Registry management
     case 'registry':
       if (args[1] === 'add') {
@@ -371,6 +382,14 @@ ${chalk.dim('Configuration manager for AI coding tools (Claude Code, Gemini CLI,
   ]));
   console.log();
 
+  // Global MCPs (~/.claude.json)
+  console.log(box('Global MCPs', [
+    cmd('global', 'List global MCPs (~/.claude.json)'),
+    cmd('global add <mcp> [mcp...]', 'Add MCP(s) to global config'),
+    cmd('global remove <mcp>', 'Remove MCP from global config'),
+  ]));
+  console.log();
+
   // Memory Commands
   console.log(box('Memory', [
     cmd('memory', 'Show memory status'),

package/lib/config.js

@@ -23,8 +23,11 @@ function findProjectRoot(startDir = process.cwd()) {
 }
 
 /**
- * Find ALL .claude/mcps.json configs from cwd up to root (and ~/.claude)
+ * Find ALL .claude/mcps.json configs from cwd up to root (and ~/.claude.json for global)
  * Returns array from root to leaf (so child overrides parent when merged)
+ *
+ * Global MCPs: Read from ~/.claude.json under mcpServers key (Claude Code's native format)
+ * Project MCPs: Read from .claude/mcps.json files in hierarchy
  */
 function findAllConfigs(startDir = process.cwd()) {
   const configs = [];
@@ -32,6 +35,7 @@ function findAllConfigs(startDir = process.cwd()) {
   const root = path.parse(dir).root;
   const homeDir = process.env.HOME || '';
 
+  // Find project configs in hierarchy
   while (dir !== root) {
     const configPath = path.join(dir, '.claude', 'mcps.json');
     if (fs.existsSync(configPath)) {
@@ -40,10 +44,21 @@ function findAllConfigs(startDir = process.cwd()) {
     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 });
+  // Read global MCPs from ~/.claude.json (Claude Code's native config)
+  const claudeJsonPath = path.join(homeDir, '.claude.json');
+  if (fs.existsSync(claudeJsonPath)) {
+    configs.unshift({
+      dir: homeDir,
+      configPath: claudeJsonPath,
+      isGlobalClaudeJson: true  // Flag to handle different format
+    });
+  }
+
+  // Legacy: Also check ~/.claude/mcps.json for backwards compatibility
+  const legacyHomeConfig = path.join(homeDir, '.claude', 'mcps.json');
+  if (fs.existsSync(legacyHomeConfig)) {
+    if (!configs.some(c => c.configPath === legacyHomeConfig)) {
+      configs.unshift({ dir: homeDir, configPath: legacyHomeConfig, isLegacy: true });
     }
   }
 

package/lib/constants.js

@@ -2,7 +2,7 @@
  * Constants and tool path configurations
  */
 
-const VERSION = '0.45.13';
+const VERSION = '0.46.0-beta.10';
 
 // Tool-specific path configurations
 const TOOL_PATHS = {
@@ -10,14 +10,16 @@ const TOOL_PATHS = {
     name: 'Claude Code',
     icon: 'sparkles',
     color: 'orange',
-    globalConfig: '~/.claude/mcps.json',
+    // Global MCPs are embedded in ~/.claude.json under mcpServers key (no separate file)
+    globalConfig: '~/.claude.json',
     globalSettings: '~/.claude/settings.json',
+    globalMcpKey: 'mcpServers', // MCPs are under this key in globalConfig
     projectFolder: '.claude',
     projectRules: '.claude/rules',
     projectCommands: '.claude/commands',
     projectWorkflows: '.claude/workflows',
     projectInstructions: 'CLAUDE.md',
-    outputFile: '.mcp.json',
+    outputFile: '.mcp.json', // Per-project MCPs go here (shared via git)
     supportsEnvInterpolation: true,
   },
   gemini: {

package/lib/mcps.js

@@ -2,10 +2,19 @@
  * MCP add/remove commands
  */
 
+const fs = require('fs');
 const path = require('path');
 const { loadJson, saveJson } = require('./utils');
 const { findProjectRoot } = require('./config');
 
+/**
+ * Get path to Claude's global config (~/.claude.json)
+ */
+function getGlobalConfigPath() {
+  const homeDir = process.env.HOME || '';
+  return path.join(homeDir, '.claude.json');
+}
+
 /**
  * List available MCPs
  */
@@ -132,8 +141,122 @@ function remove(installDir, mcpNames) {
   return removed.length > 0;
 }
 
+/**
+ * List global MCPs from ~/.claude.json
+ */
+function listGlobal() {
+  const configPath = getGlobalConfigPath();
+  const config = loadJson(configPath);
+
+  if (!config || !config.mcpServers) {
+    console.log('\n📚 Global MCPs (~/.claude.json): None configured\n');
+    return;
+  }
+
+  const mcps = Object.keys(config.mcpServers);
+  console.log('\n📚 Global MCPs (~/.claude.json):\n');
+  for (const name of mcps) {
+    const server = config.mcpServers[name];
+    const type = server.type || 'stdio';
+    console.log(`  • ${name} (${type})`);
+  }
+  console.log(`\n  Total: ${mcps.length} global MCP(s)\n`);
+}
+
+/**
+ * Add MCP(s) to global config (~/.claude.json)
+ */
+function addGlobal(registryPath, mcpNames) {
+  if (!mcpNames || mcpNames.length === 0) {
+    console.error('Usage: coder-config global add <mcp-name> [mcp-name...]');
+    return false;
+  }
+
+  const configPath = getGlobalConfigPath();
+  let config = loadJson(configPath) || {};
+
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+
+  const registry = loadJson(registryPath);
+  const added = [];
+  const notFound = [];
+  const alreadyExists = [];
+
+  for (const name of mcpNames) {
+    if (config.mcpServers[name]) {
+      alreadyExists.push(name);
+    } else if (registry?.mcpServers?.[name]) {
+      config.mcpServers[name] = registry.mcpServers[name];
+      added.push(name);
+    } else {
+      notFound.push(name);
+    }
+  }
+
+  if (added.length) {
+    saveJson(configPath, config);
+    console.log(`✓ Added to ~/.claude.json: ${added.join(', ')}`);
+    console.log('  (Global MCPs apply to all projects)');
+  }
+  if (alreadyExists.length) {
+    console.log(`Already in global config: ${alreadyExists.join(', ')}`);
+  }
+  if (notFound.length) {
+    console.log(`Not in registry: ${notFound.join(', ')}`);
+    console.log('  (Use "coder-config list" to see available MCPs)');
+  }
+
+  return added.length > 0;
+}
+
+/**
+ * Remove MCP(s) from global config (~/.claude.json)
+ */
+function removeGlobal(mcpNames) {
+  if (!mcpNames || mcpNames.length === 0) {
+    console.error('Usage: coder-config global remove <mcp-name> [mcp-name...]');
+    return false;
+  }
+
+  const configPath = getGlobalConfigPath();
+  let config = loadJson(configPath);
+
+  if (!config || !config.mcpServers) {
+    console.error('No global MCPs configured in ~/.claude.json');
+    return false;
+  }
+
+  const removed = [];
+  const notFound = [];
+
+  for (const name of mcpNames) {
+    if (config.mcpServers[name]) {
+      delete config.mcpServers[name];
+      removed.push(name);
+    } else {
+      notFound.push(name);
+    }
+  }
+
+  if (removed.length) {
+    saveJson(configPath, config);
+    console.log(`✓ Removed from ~/.claude.json: ${removed.join(', ')}`);
+  }
+  if (notFound.length) {
+    console.log(`Not in global config: ${notFound.join(', ')}`);
+  }
+
+  return removed.length > 0;
+}
+
 module.exports = {
   list,
   add,
   remove,
+  listGlobal,
+  addGlobal,
+  removeGlobal,
+  getGlobalConfigPath,
 };

package/lib/workstreams.js

@@ -688,34 +688,130 @@ function workstreamCheckPath(installDir, targetPath, silent = false) {
 }
 
 /**
- * Generate rules/context from project repositories using Claude Code
- * Runs `claude -p` to analyze repos and generate smart context
+ * Supported AI tools for context generation
  */
-async function generateRulesWithClaude(projects) {
+const AI_TOOLS = {
+  claude: {
+    name: 'Claude',
+    binary: 'claude',
+    buildArgs: (prompt) => ['-p', prompt],
+    candidates: (os) => [
+      path.join(os.homedir(), '.local', 'bin', 'claude'),
+      '/usr/local/bin/claude',
+      '/opt/homebrew/bin/claude',
+      path.join(os.homedir(), '.npm-global', 'bin', 'claude'),
+    ],
+  },
+  gemini: {
+    name: 'Gemini',
+    binary: 'gemini',
+    buildArgs: (prompt) => ['-p', prompt],
+    candidates: (os) => [
+      path.join(os.homedir(), '.local', 'bin', 'gemini'),
+      '/usr/local/bin/gemini',
+      '/opt/homebrew/bin/gemini',
+      path.join(os.homedir(), '.npm-global', 'bin', 'gemini'),
+    ],
+  },
+  codex: {
+    name: 'Codex',
+    binary: 'codex',
+    buildArgs: (prompt) => ['exec', prompt],
+    candidates: (os) => [
+      path.join(os.homedir(), '.local', 'bin', 'codex'),
+      '/usr/local/bin/codex',
+      '/opt/homebrew/bin/codex',
+      path.join(os.homedir(), '.npm-global', 'bin', 'codex'),
+    ],
+  },
+  ollama: {
+    name: 'Ollama',
+    binary: 'ollama',
+    // Model must be specified in options
+    buildArgs: (prompt, options) => ['run', options.model || 'llama3.2', prompt],
+    candidates: (os) => [
+      path.join(os.homedir(), '.local', 'bin', 'ollama'),
+      '/usr/local/bin/ollama',
+      '/opt/homebrew/bin/ollama',
+    ],
+  },
+  aider: {
+    name: 'Aider',
+    binary: 'aider',
+    buildArgs: (prompt) => ['--message', prompt, '--yes', '--no-git'],
+    candidates: (os) => [
+      path.join(os.homedir(), '.local', 'bin', 'aider'),
+      '/usr/local/bin/aider',
+      '/opt/homebrew/bin/aider',
+      path.join(os.homedir(), '.local', 'pipx', 'venvs', 'aider-chat', 'bin', 'aider'),
+    ],
+  },
+};
+
+/**
+ * Find the binary path for an AI tool
+ */
+function findAIBinary(toolId) {
+  const { execFileSync } = require('child_process');
+  const os = require('os');
+
+  const tool = AI_TOOLS[toolId];
+  if (!tool) {
+    throw new Error(`Unknown AI tool: ${toolId}`);
+  }
+
+  // Check candidate paths
+  for (const p of tool.candidates(os)) {
+    if (fs.existsSync(p)) return p;
+  }
+
+  // Try which command
+  try {
+    const resolved = execFileSync('which', [tool.binary], { encoding: 'utf8' }).trim();
+    if (resolved && fs.existsSync(resolved)) return resolved;
+  } catch (e) {}
+
+  // Fall back to bare binary name (let shell resolve it)
+  return tool.binary;
+}
+
+/**
+ * Get list of available AI tools (ones that are installed)
+ */
+function getAvailableAITools() {
+  const available = [];
+  for (const [id, tool] of Object.entries(AI_TOOLS)) {
+    try {
+      const binaryPath = findAIBinary(id);
+      if (fs.existsSync(binaryPath)) {
+        available.push({ id, name: tool.name, path: binaryPath });
+      }
+    } catch (e) {
+      // Tool not available
+    }
+  }
+  return available;
+}
+
+/**
+ * Generate rules/context from project repositories using an AI tool
+ * Supports: claude, gemini, codex, ollama, aider
+ * @param {string[]} projects - Array of project paths
+ * @param {string} toolId - AI tool to use (default: 'claude')
+ * @param {object} options - Tool-specific options (e.g., { model: 'llama3.2' } for ollama)
+ */
+async function generateRulesWithAI(projects, toolId = 'claude', options = {}) {
   if (!projects || projects.length === 0) {
     return '';
   }
 
   const { execFileSync } = require('child_process');
-  const os = require('os');
 
-  // Find claude binary (daemon processes may not have full PATH)
-  const getClaudePath = () => {
-    const candidates = [
-      path.join(os.homedir(), '.local', 'bin', 'claude'),
-      '/usr/local/bin/claude',
-      '/opt/homebrew/bin/claude',
-      path.join(os.homedir(), '.npm-global', 'bin', 'claude'),
-    ];
-    for (const p of candidates) {
-      if (fs.existsSync(p)) return p;
-    }
-    try {
-      const resolved = execFileSync('which', ['claude'], { encoding: 'utf8' }).trim();
-      if (resolved && fs.existsSync(resolved)) return resolved;
-    } catch (e) {}
-    return 'claude';
-  };
+  const tool = AI_TOOLS[toolId];
+  if (!tool) {
+    console.error(`Unknown AI tool: ${toolId}. Available: ${Object.keys(AI_TOOLS).join(', ')}`);
+    return generateRulesFromRepos(projects);
+  }
 
   // Expand projects to include discovered sub-projects
   const allProjects = [];
@@ -728,7 +824,7 @@ async function generateRulesWithClaude(projects) {
       allProjects.push(absPath);
     }
 
-    // Discover sub-projects (discoverSubProjects defined below)
+    // Discover sub-projects
     const subProjects = discoverSubProjects(absPath);
     for (const subPath of subProjects) {
       if (!seen.has(subPath)) {
@@ -752,23 +848,34 @@ ${projectList}
 Output markdown suitable for injecting into an AI assistant's context. Keep it concise (under 500 words). Do not include code blocks or examples - just descriptions and guidelines.`;
 
   try {
-    // Run claude -p with the prompt using execFileSync (safer than exec)
-    const claudePath = getClaudePath();
-    const result = execFileSync(claudePath, ['-p', prompt], {
+    const binaryPath = findAIBinary(toolId);
+    const args = tool.buildArgs(prompt, options);
+
+    console.log(`Generating context with ${tool.name}...`);
+
+    const result = execFileSync(binaryPath, args, {
       cwd: allProjects[0],
       encoding: 'utf8',
-      timeout: 60000, // 60 second timeout
+      timeout: 120000, // 2 minute timeout (some models are slower)
       maxBuffer: 1024 * 1024, // 1MB buffer
     });
 
     return result.trim();
   } catch (error) {
-    console.error('Claude generation failed:', error.message);
+    console.error(`${tool.name} generation failed:`, error.message);
     // Fall back to simple generation
     return generateRulesFromRepos(projects);
   }
 }
 
+/**
+ * Generate rules/context from project repositories using Claude Code
+ * @deprecated Use generateRulesWithAI(projects, 'claude') instead
+ */
+async function generateRulesWithClaude(projects) {
+  return generateRulesWithAI(projects, 'claude');
+}
+
 /**
  * Discover sub-projects within a directory
  * Looks for directories containing project markers (package.json, pyproject.toml, etc.)
@@ -1460,6 +1567,10 @@ module.exports = {
   discoverSubProjects,
   generateRulesFromRepos,
   generateRulesWithClaude,
+  generateRulesWithAI,
+  getAvailableAITools,
+  findAIBinary,
+  AI_TOOLS,
   // New folder auto-activation functions
   getSettingsPath,
   loadSettings,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coder-config",
-  "version": "0.45.13",
+  "version": "0.46.0-beta.10",
   "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",