coder-config 0.40.1

package/lib/activity.js

@@ -0,0 +1,283 @@
+/**
+ * Activity tracking for workstream suggestions
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { loadWorkstreams } = require('./workstreams');
+
+/**
+ * Get activity file path
+ */
+function getActivityPath(installDir) {
+  return path.join(installDir, 'activity.json');
+}
+
+/**
+ * Get default activity structure
+ */
+function getDefaultActivity() {
+  return {
+    sessions: [],
+    projectStats: {},
+    coActivity: {},
+    lastUpdated: null
+  };
+}
+
+/**
+ * Load activity data
+ */
+function loadActivity(installDir) {
+  const activityPath = getActivityPath(installDir);
+  if (fs.existsSync(activityPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(activityPath, 'utf8'));
+    } catch (e) {
+      return getDefaultActivity();
+    }
+  }
+  return getDefaultActivity();
+}
+
+/**
+ * Save activity data
+ */
+function saveActivity(installDir, data) {
+  const activityPath = getActivityPath(installDir);
+  const dir = path.dirname(activityPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  data.lastUpdated = new Date().toISOString();
+  fs.writeFileSync(activityPath, JSON.stringify(data, null, 2) + '\n');
+}
+
+/**
+ * Detect project root by finding .git or .claude folder
+ */
+function detectProjectRoot(filePath) {
+  let dir = path.dirname(filePath);
+  const home = process.env.HOME || '';
+
+  while (dir && dir !== '/' && dir !== home) {
+    if (fs.existsSync(path.join(dir, '.git')) || fs.existsSync(path.join(dir, '.claude'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Log activity from a Claude session
+ */
+function activityLog(installDir, files, sessionId = null) {
+  const data = loadActivity(installDir);
+  const now = new Date().toISOString();
+
+  if (!sessionId) {
+    sessionId = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
+  }
+
+  let session = data.sessions.find(s => s.id === sessionId);
+  if (!session) {
+    session = { id: sessionId, startedAt: now, files: [], projects: [] };
+    data.sessions.push(session);
+  }
+
+  const projectsInSession = new Set(session.projects);
+
+  for (const file of files) {
+    const rawPath = typeof file === 'string' ? file : file.path;
+    if (!rawPath) continue;
+    const filePath = path.resolve(rawPath.replace(/^~/, process.env.HOME || ''));
+    const action = typeof file === 'object' ? (file.action || 'access') : 'access';
+
+    session.files.push({ path: filePath, action, timestamp: now });
+
+    const projectPath = detectProjectRoot(filePath);
+    if (projectPath) {
+      projectsInSession.add(projectPath);
+
+      if (!data.projectStats[projectPath]) {
+        data.projectStats[projectPath] = { fileCount: 0, lastActive: now, sessionCount: 0 };
+      }
+      data.projectStats[projectPath].fileCount++;
+      data.projectStats[projectPath].lastActive = now;
+    }
+  }
+
+  session.projects = Array.from(projectsInSession);
+
+  const projects = session.projects;
+  for (let i = 0; i < projects.length; i++) {
+    for (let j = i + 1; j < projects.length; j++) {
+      const p1 = projects[i], p2 = projects[j];
+      if (!data.coActivity[p1]) data.coActivity[p1] = {};
+      if (!data.coActivity[p2]) data.coActivity[p2] = {};
+      data.coActivity[p1][p2] = (data.coActivity[p1][p2] || 0) + 1;
+      data.coActivity[p2][p1] = (data.coActivity[p2][p1] || 0) + 1;
+    }
+  }
+
+  if (data.sessions.length > 100) {
+    data.sessions = data.sessions.slice(-100);
+  }
+
+  saveActivity(installDir, data);
+  return { sessionId, filesLogged: files.length, projects: session.projects };
+}
+
+/**
+ * Get activity summary for UI
+ */
+function activitySummary(installDir) {
+  const data = loadActivity(installDir);
+  const now = new Date();
+  const oneDayAgo = new Date(now - 24 * 60 * 60 * 1000);
+
+  const recentSessions = data.sessions.filter(s => new Date(s.startedAt) > oneDayAgo);
+
+  const projectActivity = Object.entries(data.projectStats)
+    .map(([projectPath, stats]) => ({
+      path: projectPath,
+      name: path.basename(projectPath),
+      ...stats,
+      isRecent: new Date(stats.lastActive) > oneDayAgo
+    }))
+    .sort((a, b) => new Date(b.lastActive) - new Date(a.lastActive));
+
+  const coActiveProjects = [];
+  for (const [project, coProjects] of Object.entries(data.coActivity)) {
+    for (const [otherProject, count] of Object.entries(coProjects)) {
+      if (count >= 2 && project < otherProject) {
+        coActiveProjects.push({
+          projects: [project, otherProject],
+          names: [path.basename(project), path.basename(otherProject)],
+          count
+        });
+      }
+    }
+  }
+  coActiveProjects.sort((a, b) => b.count - a.count);
+
+  const totalFiles = data.sessions.reduce((sum, s) => sum + (s.files?.length || 0), 0);
+
+  return {
+    totalSessions: data.sessions.length,
+    recentSessions: recentSessions.length,
+    totalFiles,
+    projectCount: Object.keys(data.projectStats).length,
+    topProjects: projectActivity.slice(0, 10),
+    projectActivity: projectActivity.slice(0, 20),
+    coActiveProjects: coActiveProjects.slice(0, 10),
+    lastUpdated: data.lastUpdated
+  };
+}
+
+/**
+ * Generate a workstream name from project names
+ */
+function generateWorkstreamName(projects) {
+  const names = projects.map(p => path.basename(p));
+  if (names.length <= 2) return names.join(' + ');
+  return `${names[0]} + ${names.length - 1} more`;
+}
+
+/**
+ * Suggest workstreams based on activity patterns
+ */
+function activitySuggestWorkstreams(installDir) {
+  const data = loadActivity(installDir);
+  const workstreams = loadWorkstreams(installDir);
+  const suggestions = [];
+
+  const coGroups = new Map();
+
+  for (const session of data.sessions) {
+    if (session.projects.length >= 2) {
+      const key = session.projects.sort().join('|');
+      coGroups.set(key, (coGroups.get(key) || 0) + 1);
+    }
+  }
+
+  for (const [key, count] of coGroups) {
+    if (count >= 3) {
+      const projects = key.split('|');
+      const existingWs = workstreams.workstreams.find(ws =>
+        projects.every(p => ws.projects.includes(p))
+      );
+
+      if (!existingWs) {
+        const totalSessions = data.sessions.length;
+        const coActivityScore = totalSessions > 0 ? Math.round((count / totalSessions) * 100) : 0;
+
+        suggestions.push({
+          projects,
+          name: generateWorkstreamName(projects),
+          names: projects.map(p => path.basename(p)),
+          sessionCount: count,
+          coActivityScore: Math.min(coActivityScore, 100),
+        });
+      }
+    }
+  }
+
+  suggestions.sort((a, b) => b.sessionCount - a.sessionCount);
+  return suggestions.slice(0, 5);
+}
+
+/**
+ * Clear old activity data
+ */
+function activityClear(installDir, olderThanDays = 30) {
+  const data = loadActivity(installDir);
+  const cutoff = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000);
+
+  data.sessions = data.sessions.filter(s => new Date(s.startedAt) > cutoff);
+  data.projectStats = {};
+  data.coActivity = {};
+
+  for (const session of data.sessions) {
+    for (const file of session.files) {
+      const projectPath = detectProjectRoot(file.path);
+      if (projectPath) {
+        if (!data.projectStats[projectPath]) {
+          data.projectStats[projectPath] = { fileCount: 0, lastActive: session.startedAt, sessionCount: 0 };
+        }
+        data.projectStats[projectPath].fileCount++;
+        if (session.startedAt > data.projectStats[projectPath].lastActive) {
+          data.projectStats[projectPath].lastActive = session.startedAt;
+        }
+      }
+    }
+
+    const projects = session.projects;
+    for (let i = 0; i < projects.length; i++) {
+      for (let j = i + 1; j < projects.length; j++) {
+        const p1 = projects[i], p2 = projects[j];
+        if (!data.coActivity[p1]) data.coActivity[p1] = {};
+        if (!data.coActivity[p2]) data.coActivity[p2] = {};
+        data.coActivity[p1][p2] = (data.coActivity[p1][p2] || 0) + 1;
+        data.coActivity[p2][p1] = (data.coActivity[p2][p1] || 0) + 1;
+      }
+    }
+  }
+
+  saveActivity(installDir, data);
+  return { sessionsRemaining: data.sessions.length };
+}
+
+module.exports = {
+  getActivityPath,
+  getDefaultActivity,
+  loadActivity,
+  saveActivity,
+  detectProjectRoot,
+  activityLog,
+  activitySummary,
+  generateWorkstreamName,
+  activitySuggestWorkstreams,
+  activityClear,
+};

package/lib/apply.js

@@ -0,0 +1,344 @@
+/**
+ * Apply commands for generating tool configs
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { TOOL_PATHS } = require('./constants');
+const { loadJson, saveJson, loadEnvFile, interpolate, resolveEnvVars } = require('./utils');
+const { findProjectRoot, findAllConfigs, mergeConfigs, findAllConfigsForTool } = require('./config');
+
+/**
+ * Generate .mcp.json for a project (with hierarchical config merging)
+ */
+function apply(registryPath, projectDir = null) {
+  const dir = projectDir || findProjectRoot() || process.cwd();
+
+  const registry = loadJson(registryPath);
+  if (!registry) {
+    console.error('Error: Could not load MCP registry from', registryPath);
+    return false;
+  }
+
+  const configLocations = findAllConfigs(dir);
+
+  if (configLocations.length === 0) {
+    console.error(`No .claude/mcps.json found in ${dir} or parent directories`);
+    console.error('Run: claude-config init');
+    return false;
+  }
+
+  const loadedConfigs = configLocations.map(loc => ({
+    ...loc,
+    config: loadJson(loc.configPath)
+  }));
+
+  if (loadedConfigs.length > 1) {
+    console.log('📚 Config hierarchy (merged):');
+    for (const { dir: d, configPath } of loadedConfigs) {
+      const relPath = d === process.env.HOME ? '~' : path.relative(process.cwd(), d) || '.';
+      console.log(`  • ${relPath}/.claude/mcps.json`);
+    }
+    console.log('');
+  }
+
+  const mergedConfig = mergeConfigs(loadedConfigs);
+
+  const globalEnvPath = path.join(path.dirname(registryPath), '.env');
+  let env = loadEnvFile(globalEnvPath);
+
+  for (const { dir: d } of loadedConfigs) {
+    const envPath = path.join(d, '.claude', '.env');
+    env = { ...env, ...loadEnvFile(envPath) };
+  }
+
+  const output = { mcpServers: {} };
+
+  if (mergedConfig.include && Array.isArray(mergedConfig.include)) {
+    for (const name of mergedConfig.include) {
+      if (registry.mcpServers && registry.mcpServers[name]) {
+        output.mcpServers[name] = interpolate(registry.mcpServers[name], env);
+      } else {
+        console.warn(`Warning: MCP "${name}" not found in registry`);
+      }
+    }
+  }
+
+  if (mergedConfig.mcpServers) {
+    for (const [name, config] of Object.entries(mergedConfig.mcpServers)) {
+      if (name.startsWith('_')) continue;
+      output.mcpServers[name] = interpolate(config, env);
+    }
+  }
+
+  const outputPath = path.join(dir, '.mcp.json');
+  saveJson(outputPath, output);
+
+  const count = Object.keys(output.mcpServers).length;
+  console.log(`✓ Generated ${outputPath}`);
+  console.log(`  └─ ${count} MCP(s): ${Object.keys(output.mcpServers).join(', ')}`);
+
+  // Generate settings.json with enabledPlugins if any are configured
+  if (mergedConfig.enabledPlugins && Object.keys(mergedConfig.enabledPlugins).length > 0) {
+    const settingsPath = path.join(dir, '.claude', 'settings.json');
+    let existingSettings = {};
+
+    // Load existing settings if present
+    if (fs.existsSync(settingsPath)) {
+      try {
+        existingSettings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      } catch (e) {
+        existingSettings = {};
+      }
+    }
+
+    // Merge enabledPlugins into settings
+    const settingsOutput = {
+      ...existingSettings,
+      enabledPlugins: mergedConfig.enabledPlugins
+    };
+
+    saveJson(settingsPath, settingsOutput);
+
+    const pluginCount = Object.entries(mergedConfig.enabledPlugins)
+      .filter(([_, enabled]) => enabled).length;
+    console.log(`✓ Generated ${settingsPath}`);
+    console.log(`  └─ ${pluginCount} plugin(s) enabled`);
+  }
+
+  return true;
+}
+
+/**
+ * Generate MCP config for Antigravity
+ */
+function applyForAntigravity(registryPath, projectDir = null) {
+  const dir = projectDir || findProjectRoot() || process.cwd();
+  const paths = TOOL_PATHS.antigravity;
+  const homeDir = process.env.HOME || '';
+
+  const registry = loadJson(registryPath);
+  if (!registry) {
+    console.error('Error: Could not load MCP registry');
+    return false;
+  }
+
+  const configLocations = findAllConfigsForTool('antigravity', dir);
+
+  if (configLocations.length === 0) {
+    console.log(`  ℹ No .agent/mcps.json found - skipping Antigravity`);
+    console.log(`    Create one with: mkdir -p .agent && echo '{"include":["filesystem"]}' > .agent/mcps.json`);
+    return true;
+  }
+
+  const loadedConfigs = configLocations.map(loc => ({
+    ...loc,
+    config: loadJson(loc.configPath)
+  }));
+  const mergedConfig = mergeConfigs(loadedConfigs);
+
+  let env = {};
+  const globalEnvPath = path.join(homeDir, '.gemini', 'antigravity', '.env');
+  env = { ...env, ...loadEnvFile(globalEnvPath) };
+
+  for (const { dir: d } of configLocations) {
+    if (d !== homeDir) {
+      const envPath = path.join(d, '.agent', '.env');
+      env = { ...env, ...loadEnvFile(envPath) };
+    }
+  }
+
+  const output = { mcpServers: {} };
+
+  if (mergedConfig.include && Array.isArray(mergedConfig.include)) {
+    for (const name of mergedConfig.include) {
+      if (registry.mcpServers && registry.mcpServers[name]) {
+        output.mcpServers[name] = resolveEnvVars(registry.mcpServers[name], env);
+      }
+    }
+  }
+
+  if (mergedConfig.mcpServers) {
+    for (const [name, config] of Object.entries(mergedConfig.mcpServers)) {
+      if (name.startsWith('_')) continue;
+      output.mcpServers[name] = resolveEnvVars(config, env);
+    }
+  }
+
+  const outputPath = paths.outputFile.replace(/^~/, homeDir);
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  saveJson(outputPath, output);
+
+  const count = Object.keys(output.mcpServers).length;
+  console.log(`✓ Generated ${outputPath} (Antigravity)`);
+  console.log(`  └─ ${count} MCP(s): ${Object.keys(output.mcpServers).join(', ')}`);
+
+  return true;
+}
+
+/**
+ * Generate MCP config for Gemini CLI
+ */
+function applyForGemini(registryPath, projectDir = null) {
+  const dir = projectDir || findProjectRoot() || process.cwd();
+  const paths = TOOL_PATHS.gemini;
+  const homeDir = process.env.HOME || '';
+
+  const registry = loadJson(registryPath);
+  if (!registry) {
+    console.error('Error: Could not load MCP registry');
+    return false;
+  }
+
+  const configLocations = findAllConfigsForTool('gemini', dir);
+
+  if (configLocations.length === 0) {
+    console.log(`  ℹ No .gemini/mcps.json found - skipping Gemini CLI`);
+    console.log(`    Create one with: mkdir -p .gemini && echo '{"include":["filesystem"]}' > .gemini/mcps.json`);
+    return true;
+  }
+
+  const loadedConfigs = configLocations.map(loc => ({
+    ...loc,
+    config: loadJson(loc.configPath)
+  }));
+  const mergedConfig = mergeConfigs(loadedConfigs);
+
+  let env = {};
+  const globalEnvPath = path.join(homeDir, '.gemini', '.env');
+  env = { ...env, ...loadEnvFile(globalEnvPath) };
+
+  for (const { dir: d } of configLocations) {
+    if (d !== homeDir) {
+      const envPath = path.join(d, '.gemini', '.env');
+      env = { ...env, ...loadEnvFile(envPath) };
+    }
+  }
+
+  const mcpServers = {};
+
+  if (mergedConfig.include && Array.isArray(mergedConfig.include)) {
+    for (const name of mergedConfig.include) {
+      if (registry.mcpServers && registry.mcpServers[name]) {
+        mcpServers[name] = interpolate(registry.mcpServers[name], env);
+      }
+    }
+  }
+
+  if (mergedConfig.mcpServers) {
+    for (const [name, config] of Object.entries(mergedConfig.mcpServers)) {
+      if (name.startsWith('_')) continue;
+      mcpServers[name] = interpolate(config, env);
+    }
+  }
+
+  // Generate global settings (~/.gemini/settings.json)
+  const globalOutputPath = paths.outputFile.replace(/^~/, homeDir);
+  const globalOutputDir = path.dirname(globalOutputPath);
+  if (!fs.existsSync(globalOutputDir)) {
+    fs.mkdirSync(globalOutputDir, { recursive: true });
+  }
+
+  let existingSettings = {};
+  if (fs.existsSync(globalOutputPath)) {
+    try {
+      existingSettings = JSON.parse(fs.readFileSync(globalOutputPath, 'utf8'));
+    } catch (e) {
+      existingSettings = {};
+    }
+  }
+
+  const globalOutput = {
+    ...existingSettings,
+    mcpServers
+  };
+
+  saveJson(globalOutputPath, globalOutput);
+
+  const count = Object.keys(mcpServers).length;
+  console.log(`✓ Generated ${globalOutputPath} (Gemini CLI - global)`);
+  console.log(`  └─ ${count} MCP(s): ${Object.keys(mcpServers).join(', ')}`);
+
+  // Generate per-project settings (.gemini/settings.json)
+  const projectOutputDir = path.join(dir, '.gemini');
+  const projectOutputPath = path.join(projectOutputDir, 'settings.json');
+
+  if (!fs.existsSync(projectOutputDir)) {
+    fs.mkdirSync(projectOutputDir, { recursive: true });
+  }
+
+  // For per-project, only include mcpServers (not merge with existing)
+  const projectOutput = { mcpServers };
+  saveJson(projectOutputPath, projectOutput);
+
+  console.log(`✓ Generated ${projectOutputPath} (Gemini CLI - project)`);
+
+  return true;
+}
+
+/**
+ * Detect which AI coding tools are installed
+ */
+function detectInstalledTools() {
+  const homeDir = process.env.HOME || '';
+  const results = {};
+
+  try {
+    execSync('which claude', { stdio: 'ignore' });
+    results.claude = { installed: true, method: 'command' };
+  } catch {
+    results.claude = {
+      installed: fs.existsSync(path.join(homeDir, '.claude')),
+      method: 'directory'
+    };
+  }
+
+  try {
+    execSync('which gemini', { stdio: 'ignore' });
+    results.gemini = { installed: true, method: 'command' };
+  } catch {
+    results.gemini = {
+      installed: fs.existsSync(path.join(homeDir, '.gemini')),
+      method: 'directory'
+    };
+  }
+
+  results.antigravity = {
+    installed: fs.existsSync(path.join(homeDir, '.gemini', 'antigravity')),
+    method: 'directory'
+  };
+
+  return results;
+}
+
+/**
+ * Apply config for multiple tools based on preferences
+ */
+function applyForTools(registryPath, projectDir = null, tools = ['claude']) {
+  const results = {};
+
+  for (const tool of tools) {
+    if (tool === 'claude') {
+      results.claude = apply(registryPath, projectDir);
+    } else if (tool === 'gemini') {
+      results.gemini = applyForGemini(registryPath, projectDir);
+    } else if (tool === 'antigravity') {
+      results.antigravity = applyForAntigravity(registryPath, projectDir);
+    }
+  }
+
+  return results;
+}
+
+module.exports = {
+  apply,
+  applyForAntigravity,
+  applyForGemini,
+  detectInstalledTools,
+  applyForTools,
+};