coder-config 0.40.1

package/lib/init.js

@@ -0,0 +1,122 @@
+/**
+ * Project initialization commands
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { loadJson, saveJson } = require('./utils');
+const { findProjectRoot, findAllConfigs, mergeConfigs, collectFilesFromHierarchy } = require('./config');
+
+/**
+ * Initialize project
+ */
+function init(registryPath, projectDir = null) {
+  const dir = projectDir || process.cwd();
+  const claudeDir = path.join(dir, '.claude');
+  const configPath = path.join(claudeDir, 'mcps.json');
+
+  if (!fs.existsSync(claudeDir)) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+  }
+
+  if (!fs.existsSync(configPath)) {
+    const config = {
+      "include": ['github', 'filesystem'],
+      "mcpServers": {}
+    };
+    saveJson(configPath, config);
+    console.log(`✓ Created ${configPath}`);
+  } else {
+    console.log(`⏭  ${configPath} already exists`);
+  }
+
+  const envPath = path.join(claudeDir, '.env');
+  if (!fs.existsSync(envPath)) {
+    fs.writeFileSync(envPath, `# Project secrets (gitignored)
+# GITHUB_TOKEN=ghp_xxx
+# DATABASE_URL=postgres://...
+`);
+    console.log(`✓ Created ${envPath}`);
+  }
+
+  const gitignorePath = path.join(dir, '.gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, 'utf8');
+    if (!content.includes('.claude/.env')) {
+      fs.appendFileSync(gitignorePath, '\n.claude/.env\n');
+      console.log('✓ Updated .gitignore');
+    }
+  }
+
+  console.log('\n✅ Project initialized!');
+  console.log('Next steps:');
+  console.log('  1. Edit .claude/mcps.json to customize MCPs');
+  console.log('  2. Run: claude-config ui');
+  console.log('     (Plugins marketplace auto-installs on first use)');
+  console.log('  3. Run: claude-config apply\n');
+
+  return true;
+}
+
+/**
+ * Show current project config (including hierarchy)
+ */
+function show(projectDir = null) {
+  const dir = projectDir || findProjectRoot() || process.cwd();
+
+  const configLocations = findAllConfigs(dir);
+
+  if (configLocations.length === 0) {
+    console.log('No .claude/mcps.json found in current directory or parents');
+    return;
+  }
+
+  console.log(`\n📁 Project: ${dir}`);
+
+  if (configLocations.length > 1) {
+    console.log('\n📚 Config Hierarchy (root → leaf):');
+  }
+
+  for (const { dir: d, configPath } of configLocations) {
+    const config = loadJson(configPath);
+    const relPath = d === process.env.HOME ? '~' : path.relative(process.cwd(), d) || '.';
+
+    console.log(`\n📄 ${relPath}/.claude/mcps.json:`);
+    console.log(JSON.stringify(config, null, 2));
+  }
+
+  if (configLocations.length > 1) {
+    const loadedConfigs = configLocations.map(loc => ({
+      ...loc,
+      config: loadJson(loc.configPath)
+    }));
+    const merged = mergeConfigs(loadedConfigs);
+    console.log('\n🔀 Merged Config (effective):');
+    console.log(JSON.stringify(merged, null, 2));
+  }
+
+  const allRules = collectFilesFromHierarchy(configLocations, 'rules');
+  const allCommands = collectFilesFromHierarchy(configLocations, 'commands');
+
+  if (allRules.length) {
+    console.log(`\n📜 Rules (${allRules.length} total):`);
+    for (const { file, source } of allRules) {
+      const sourceLabel = source === process.env.HOME ? '~' : path.relative(process.cwd(), source) || '.';
+      console.log(`  • ${file}  (${sourceLabel})`);
+    }
+  }
+
+  if (allCommands.length) {
+    console.log(`\n⚡ Commands (${allCommands.length} total):`);
+    for (const { file, source } of allCommands) {
+      const sourceLabel = source === process.env.HOME ? '~' : path.relative(process.cwd(), source) || '.';
+      console.log(`  • ${file}  (${sourceLabel})`);
+    }
+  }
+  console.log('');
+}
+
+module.exports = {
+  init,
+  show,
+};

package/lib/mcps.js

@@ -0,0 +1,139 @@
+/**
+ * MCP add/remove commands
+ */
+
+const path = require('path');
+const { loadJson, saveJson } = require('./utils');
+const { findProjectRoot } = require('./config');
+
+/**
+ * List available MCPs
+ */
+function list(registryPath) {
+  const registry = loadJson(registryPath);
+  if (!registry || !registry.mcpServers) {
+    console.error('Error: Could not load MCP registry');
+    return;
+  }
+
+  const dir = findProjectRoot();
+  const projectConfig = dir ? loadJson(path.join(dir, '.claude', 'mcps.json')) : null;
+  const included = projectConfig?.include || [];
+
+  console.log('\n📚 Available MCPs:\n');
+  for (const name of Object.keys(registry.mcpServers)) {
+    const active = included.includes(name) ? ' ✓' : '';
+    console.log(`  • ${name}${active}`);
+  }
+  console.log(`\n  Total: ${Object.keys(registry.mcpServers).length} in registry`);
+  if (included.length) {
+    console.log(`  Active: ${included.join(', ')}`);
+  }
+  console.log('');
+}
+
+/**
+ * Add MCP(s) to current project
+ */
+function add(registryPath, installDir, mcpNames) {
+  if (!mcpNames || mcpNames.length === 0) {
+    console.error('Usage: claude-config add <mcp-name> [mcp-name...]');
+    return false;
+  }
+
+  const dir = findProjectRoot() || process.cwd();
+  const configPath = path.join(dir, '.claude', 'mcps.json');
+  let config = loadJson(configPath);
+
+  if (!config) {
+    console.error('No .claude/mcps.json found. Run: claude-config init');
+    return false;
+  }
+
+  const registry = loadJson(registryPath);
+  if (!config.include) config.include = [];
+
+  const added = [];
+  const notFound = [];
+  const alreadyExists = [];
+
+  for (const name of mcpNames) {
+    if (config.include.includes(name)) {
+      alreadyExists.push(name);
+    } else if (registry?.mcpServers?.[name]) {
+      config.include.push(name);
+      added.push(name);
+    } else {
+      notFound.push(name);
+    }
+  }
+
+  if (added.length) {
+    saveJson(configPath, config);
+    console.log(`✓ Added: ${added.join(', ')}`);
+  }
+  if (alreadyExists.length) {
+    console.log(`Already included: ${alreadyExists.join(', ')}`);
+  }
+  if (notFound.length) {
+    console.log(`Not in registry: ${notFound.join(', ')}`);
+    console.log('  (Use "claude-config list" to see available MCPs)');
+  }
+
+  if (added.length) {
+    console.log('\nRun "claude-config apply" to regenerate .mcp.json');
+  }
+
+  return added.length > 0;
+}
+
+/**
+ * Remove MCP(s) from current project
+ */
+function remove(installDir, mcpNames) {
+  if (!mcpNames || mcpNames.length === 0) {
+    console.error('Usage: claude-config remove <mcp-name> [mcp-name...]');
+    return false;
+  }
+
+  const dir = findProjectRoot() || process.cwd();
+  const configPath = path.join(dir, '.claude', 'mcps.json');
+  let config = loadJson(configPath);
+
+  if (!config) {
+    console.error('No .claude/mcps.json found');
+    return false;
+  }
+
+  if (!config.include) config.include = [];
+
+  const removed = [];
+  const notFound = [];
+
+  for (const name of mcpNames) {
+    const idx = config.include.indexOf(name);
+    if (idx !== -1) {
+      config.include.splice(idx, 1);
+      removed.push(name);
+    } else {
+      notFound.push(name);
+    }
+  }
+
+  if (removed.length) {
+    saveJson(configPath, config);
+    console.log(`✓ Removed: ${removed.join(', ')}`);
+    console.log('\nRun "claude-config apply" to regenerate .mcp.json');
+  }
+  if (notFound.length) {
+    console.log(`Not in project: ${notFound.join(', ')}`);
+  }
+
+  return removed.length > 0;
+}
+
+module.exports = {
+  list,
+  add,
+  remove,
+};

package/lib/memory.js

@@ -0,0 +1,201 @@
+/**
+ * Memory system commands
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Show memory status and contents
+ */
+function memoryList(projectDir = process.cwd()) {
+  const homeDir = process.env.HOME || '';
+  const globalMemoryDir = path.join(homeDir, '.claude', 'memory');
+  const projectMemoryDir = path.join(projectDir, '.claude', 'memory');
+
+  console.log('\n📝 Memory System\n');
+
+  console.log('Global (~/.claude/memory/):');
+  if (fs.existsSync(globalMemoryDir)) {
+    const files = ['preferences.md', 'corrections.md', 'facts.md'];
+    for (const file of files) {
+      const filePath = path.join(globalMemoryDir, file);
+      if (fs.existsSync(filePath)) {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#')).length;
+        console.log(`  ✓ ${file} (${lines} entries)`);
+      } else {
+        console.log(`  ○ ${file} (not created)`);
+      }
+    }
+  } else {
+    console.log('  Not initialized');
+  }
+
+  console.log(`\nProject (${projectDir}/.claude/memory/):`);
+  if (fs.existsSync(projectMemoryDir)) {
+    const files = ['context.md', 'patterns.md', 'decisions.md', 'issues.md', 'history.md'];
+    for (const file of files) {
+      const filePath = path.join(projectMemoryDir, file);
+      if (fs.existsSync(filePath)) {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#')).length;
+        console.log(`  ✓ ${file} (${lines} entries)`);
+      } else {
+        console.log(`  ○ ${file} (not created)`);
+      }
+    }
+  } else {
+    console.log('  Not initialized. Run: claude-config memory init');
+  }
+  console.log();
+}
+
+/**
+ * Initialize project memory
+ */
+function memoryInit(projectDir = process.cwd()) {
+  const memoryDir = path.join(projectDir, '.claude', 'memory');
+
+  if (fs.existsSync(memoryDir)) {
+    console.log('Project memory already initialized at', memoryDir);
+    return;
+  }
+
+  fs.mkdirSync(memoryDir, { recursive: true });
+
+  const files = {
+    'context.md': '# Project Context\n\n<!-- Project overview and key information -->\n',
+    'patterns.md': '# Code Patterns\n\n<!-- Established patterns in this codebase -->\n',
+    'decisions.md': '# Architecture Decisions\n\n<!-- Key decisions and their rationale -->\n',
+    'issues.md': '# Known Issues\n\n<!-- Current issues and workarounds -->\n',
+    'history.md': '# Session History\n\n<!-- Notable changes and milestones -->\n'
+  };
+
+  for (const [file, content] of Object.entries(files)) {
+    fs.writeFileSync(path.join(memoryDir, file), content);
+  }
+
+  console.log(`✓ Initialized project memory at ${memoryDir}`);
+  console.log('\nCreated:');
+  for (const file of Object.keys(files)) {
+    console.log(`  ${file}`);
+  }
+}
+
+/**
+ * Add entry to memory
+ */
+function memoryAdd(type, content, projectDir = process.cwd()) {
+  if (!type || !content) {
+    console.error('Usage: claude-config memory add <type> "<content>"');
+    console.log('\nTypes:');
+    console.log('  Global:  preference, correction, fact');
+    console.log('  Project: context, pattern, decision, issue, history');
+    return;
+  }
+
+  const homeDir = process.env.HOME || '';
+  const timestamp = new Date().toISOString().split('T')[0];
+
+  const typeMap = {
+    preference: { dir: path.join(homeDir, '.claude', 'memory'), file: 'preferences.md' },
+    correction: { dir: path.join(homeDir, '.claude', 'memory'), file: 'corrections.md' },
+    fact: { dir: path.join(homeDir, '.claude', 'memory'), file: 'facts.md' },
+    context: { dir: path.join(projectDir, '.claude', 'memory'), file: 'context.md' },
+    pattern: { dir: path.join(projectDir, '.claude', 'memory'), file: 'patterns.md' },
+    decision: { dir: path.join(projectDir, '.claude', 'memory'), file: 'decisions.md' },
+    issue: { dir: path.join(projectDir, '.claude', 'memory'), file: 'issues.md' },
+    history: { dir: path.join(projectDir, '.claude', 'memory'), file: 'history.md' }
+  };
+
+  const target = typeMap[type];
+  if (!target) {
+    console.error(`Unknown type: ${type}`);
+    console.log('Valid types: preference, correction, fact, context, pattern, decision, issue, history');
+    return;
+  }
+
+  if (!fs.existsSync(target.dir)) {
+    fs.mkdirSync(target.dir, { recursive: true });
+  }
+
+  const filePath = path.join(target.dir, target.file);
+
+  if (!fs.existsSync(filePath)) {
+    const headers = {
+      'preferences.md': '# Preferences\n',
+      'corrections.md': '# Corrections\n',
+      'facts.md': '# Facts\n',
+      'context.md': '# Project Context\n',
+      'patterns.md': '# Code Patterns\n',
+      'decisions.md': '# Architecture Decisions\n',
+      'issues.md': '# Known Issues\n',
+      'history.md': '# Session History\n'
+    };
+    fs.writeFileSync(filePath, headers[target.file] || '');
+  }
+
+  const entry = `\n- [${timestamp}] ${content}\n`;
+  fs.appendFileSync(filePath, entry);
+
+  console.log(`✓ Added ${type} to ${target.file}`);
+}
+
+/**
+ * Search memory files
+ */
+function memorySearch(query, projectDir = process.cwd()) {
+  if (!query) {
+    console.error('Usage: claude-config memory search <query>');
+    return;
+  }
+
+  const homeDir = process.env.HOME || '';
+  const searchDirs = [
+    { label: 'Global', dir: path.join(homeDir, '.claude', 'memory') },
+    { label: 'Project', dir: path.join(projectDir, '.claude', 'memory') }
+  ];
+
+  const results = [];
+  const queryLower = query.toLowerCase();
+
+  for (const { label, dir } of searchDirs) {
+    if (!fs.existsSync(dir)) continue;
+
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.endsWith('.md')) continue;
+      const filePath = path.join(dir, file);
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].toLowerCase().includes(queryLower)) {
+          results.push({
+            location: `${label}/${file}`,
+            line: i + 1,
+            content: lines[i].trim()
+          });
+        }
+      }
+    }
+  }
+
+  if (results.length === 0) {
+    console.log(`No matches found for "${query}"`);
+    return;
+  }
+
+  console.log(`\n🔍 Found ${results.length} match(es) for "${query}":\n`);
+  for (const r of results) {
+    console.log(`  ${r.location}:${r.line}`);
+    console.log(`    ${r.content}\n`);
+  }
+}
+
+module.exports = {
+  memoryList,
+  memoryInit,
+  memoryAdd,
+  memorySearch,
+};

package/lib/projects.js

@@ -0,0 +1,138 @@
+/**
+ * Project registry for UI project switching
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { loadJson, saveJson } = require('./utils');
+
+/**
+ * Get projects registry path
+ */
+function getProjectsRegistryPath(installDir) {
+  return path.join(installDir, 'projects.json');
+}
+
+/**
+ * Load projects registry
+ */
+function loadProjectsRegistry(installDir) {
+  const registryPath = getProjectsRegistryPath(installDir);
+  if (fs.existsSync(registryPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    } catch (e) {
+      return { projects: [], activeProjectId: null };
+    }
+  }
+  return { projects: [], activeProjectId: null };
+}
+
+/**
+ * Save projects registry
+ */
+function saveProjectsRegistry(installDir, registry) {
+  const registryPath = getProjectsRegistryPath(installDir);
+  fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\n');
+}
+
+/**
+ * List registered projects
+ */
+function projectList(installDir) {
+  const registry = loadProjectsRegistry(installDir);
+
+  if (registry.projects.length === 0) {
+    console.log('\nNo projects registered.');
+    console.log('Add one with: claude-config project add [path]\n');
+    return;
+  }
+
+  console.log('\n📁 Registered Projects:\n');
+  for (const p of registry.projects) {
+    const active = p.id === registry.activeProjectId ? '→ ' : '  ';
+    const exists = fs.existsSync(p.path) ? '' : ' (not found)';
+    console.log(`${active}${p.name}${exists}`);
+    console.log(`    ${p.path}`);
+  }
+  console.log('');
+}
+
+/**
+ * Add project to registry
+ */
+function projectAdd(installDir, projectPath = process.cwd(), name = null) {
+  const absPath = path.resolve(projectPath.replace(/^~/, process.env.HOME || ''));
+
+  if (!fs.existsSync(absPath)) {
+    console.error(`Path not found: ${absPath}`);
+    return false;
+  }
+
+  const registry = loadProjectsRegistry(installDir);
+
+  if (registry.projects.some(p => p.path === absPath)) {
+    console.log(`Already registered: ${absPath}`);
+    return false;
+  }
+
+  const project = {
+    id: Date.now().toString(36) + Math.random().toString(36).substr(2, 5),
+    name: name || path.basename(absPath),
+    path: absPath,
+    addedAt: new Date().toISOString(),
+    lastOpened: null
+  };
+
+  registry.projects.push(project);
+
+  if (!registry.activeProjectId) {
+    registry.activeProjectId = project.id;
+  }
+
+  saveProjectsRegistry(installDir, registry);
+  console.log(`✓ Added project: ${project.name}`);
+  console.log(`  ${absPath}`);
+  return true;
+}
+
+/**
+ * Remove project from registry
+ */
+function projectRemove(installDir, nameOrPath) {
+  if (!nameOrPath) {
+    console.error('Usage: claude-config project remove <name|path>');
+    return false;
+  }
+
+  const registry = loadProjectsRegistry(installDir);
+  const absPath = path.resolve(nameOrPath.replace(/^~/, process.env.HOME || ''));
+
+  const idx = registry.projects.findIndex(
+    p => p.name === nameOrPath || p.path === absPath
+  );
+
+  if (idx === -1) {
+    console.error(`Project not found: ${nameOrPath}`);
+    return false;
+  }
+
+  const removed = registry.projects.splice(idx, 1)[0];
+
+  if (registry.activeProjectId === removed.id) {
+    registry.activeProjectId = registry.projects[0]?.id || null;
+  }
+
+  saveProjectsRegistry(installDir, registry);
+  console.log(`✓ Removed project: ${removed.name}`);
+  return true;
+}
+
+module.exports = {
+  getProjectsRegistryPath,
+  loadProjectsRegistry,
+  saveProjectsRegistry,
+  projectList,
+  projectAdd,
+  projectRemove,
+};

package/lib/registry.js

@@ -0,0 +1,83 @@
+/**
+ * MCP Registry management commands
+ */
+
+const { loadJson, saveJson } = require('./utils');
+
+/**
+ * List MCPs in global registry
+ */
+function registryList(registryPath) {
+  const registry = loadJson(registryPath);
+  const mcps = registry?.mcpServers || {};
+  const names = Object.keys(mcps);
+
+  if (names.length === 0) {
+    console.log('\nNo MCPs in global registry.');
+    console.log('Add one with: claude-config registry add <name> \'{"command":"..."}\'');
+    return [];
+  }
+
+  console.log('\n📦 Global MCP Registry:\n');
+  for (const name of names.sort()) {
+    const mcp = mcps[name];
+    const cmd = mcp.command || 'unknown';
+    console.log(`  ${name}`);
+    console.log(`    command: ${cmd}`);
+  }
+  console.log('');
+  return names;
+}
+
+/**
+ * Add MCP to global registry
+ */
+function registryAdd(registryPath, name, configJson) {
+  if (!name || !configJson) {
+    console.error('Usage: claude-config registry add <name> \'{"command":"...","args":[...]}\'');
+    return false;
+  }
+
+  let mcpConfig;
+  try {
+    mcpConfig = JSON.parse(configJson);
+  } catch (e) {
+    console.error('Invalid JSON:', e.message);
+    return false;
+  }
+
+  const registry = loadJson(registryPath) || { mcpServers: {} };
+  registry.mcpServers[name] = mcpConfig;
+  saveJson(registryPath, registry);
+
+  console.log(`✓ Added "${name}" to registry`);
+  return true;
+}
+
+/**
+ * Remove MCP from global registry
+ */
+function registryRemove(registryPath, name) {
+  if (!name) {
+    console.error('Usage: claude-config registry remove <name>');
+    return false;
+  }
+
+  const registry = loadJson(registryPath);
+  if (!registry?.mcpServers?.[name]) {
+    console.error(`"${name}" not found in registry`);
+    return false;
+  }
+
+  delete registry.mcpServers[name];
+  saveJson(registryPath, registry);
+
+  console.log(`✓ Removed "${name}" from registry`);
+  return true;
+}
+
+module.exports = {
+  registryList,
+  registryAdd,
+  registryRemove,
+};