@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-GZDFVP2N.js

@@ -1,540 +0,0 @@
-#!/usr/bin/env node
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-
-// src/commands/mcp/setup.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import chalk from "chalk";
-import ora from "ora";
-function detectCursor() {
-  const homeDir = os.homedir();
-  const cursorDir = path.join(homeDir, ".cursor");
-  const projectCursorDir = path.join(process.cwd(), ".cursor");
-  const detected = fs.existsSync(cursorDir) || fs.existsSync(projectCursorDir);
-  return {
-    name: "Cursor",
-    id: "cursor",
-    detected,
-    configPath: path.join(process.cwd(), ".cursor", "mcp.json"),
-    configType: "project",
-    instructions: "Restart Cursor to activate MCP"
-  };
-}
-function detectClaudeDesktop() {
-  const homeDir = os.homedir();
-  let configPath;
-  let detected = false;
-  if (process.platform === "darwin") {
-    const claudeDir = path.join(homeDir, "Library", "Application Support", "Claude");
-    detected = fs.existsSync(claudeDir);
-    configPath = path.join(claudeDir, "claude_desktop_config.json");
-  } else if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path.join(homeDir, "AppData", "Roaming");
-    const claudeDir = path.join(appData, "Claude");
-    detected = fs.existsSync(claudeDir);
-    configPath = path.join(claudeDir, "claude_desktop_config.json");
-  } else {
-    const claudeDir = path.join(homeDir, ".config", "Claude");
-    detected = fs.existsSync(claudeDir);
-    configPath = path.join(claudeDir, "claude_desktop_config.json");
-  }
-  return {
-    name: "Claude Desktop",
-    id: "claude-desktop",
-    detected,
-    configPath,
-    configType: "user",
-    instructions: "Restart Claude Desktop to activate MCP"
-  };
-}
-function detectContinue() {
-  const homeDir = os.homedir();
-  const continueDir = path.join(homeDir, ".continue");
-  const detected = fs.existsSync(continueDir);
-  return {
-    name: "Continue (VS Code)",
-    id: "continue",
-    detected,
-    configPath: path.join(continueDir, "config.json"),
-    configType: "user",
-    instructions: "Restart VS Code to activate MCP"
-  };
-}
-function detectClaudeCode() {
-  const projectMcpJson = path.join(process.cwd(), ".mcp.json");
-  const claudeDir = path.join(process.cwd(), ".claude");
-  const detected = fs.existsSync(projectMcpJson) || fs.existsSync(claudeDir);
-  return {
-    name: "Claude Code",
-    id: "claude-code",
-    detected,
-    configPath: projectMcpJson,
-    configType: "project",
-    instructions: "Restart Claude Code session to activate MCP"
-  };
-}
-function detectCline() {
-  const projectClineDir = path.join(process.cwd(), ".cline");
-  const detected = fs.existsSync(projectClineDir);
-  return {
-    name: "Cline (VS Code)",
-    id: "cline",
-    detected,
-    configPath: path.join(process.cwd(), ".cline", "mcp.json"),
-    configType: "project",
-    instructions: "Restart VS Code to activate MCP"
-  };
-}
-function detectAllClients() {
-  return [
-    detectCursor(),
-    detectClaudeCode(),
-    detectClaudeDesktop(),
-    detectContinue(),
-    detectCline()
-  ];
-}
-function generateMCPConfig(client, projectPath, projectName) {
-  const serverName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-  if (client.id === "continue") {
-    return {
-      experimental: {
-        modelContextProtocolServers: [
-          {
-            transport: {
-              type: "stdio",
-              command: "paradigm-mcp",
-              args: ["."],
-              cwd: projectPath
-            }
-          }
-        ]
-      }
-    };
-  }
-  return {
-    mcpServers: {
-      [serverName]: {
-        command: "paradigm-mcp",
-        args: ["."],
-        cwd: projectPath
-      }
-    }
-  };
-}
-function mergeConfig(existing, newConfig, client) {
-  if (client.id === "continue") {
-    const existingServers = existing?.experimental?.modelContextProtocolServers || [];
-    const newServers = newConfig?.experimental?.modelContextProtocolServers || [];
-    return {
-      ...existing,
-      experimental: {
-        ...existing?.experimental,
-        modelContextProtocolServers: [...existingServers, ...newServers]
-      }
-    };
-  }
-  return {
-    ...existing,
-    mcpServers: {
-      ...existing?.mcpServers,
-      ...newConfig?.mcpServers
-    }
-  };
-}
-function writeConfig(client, config, force) {
-  const configDir = path.dirname(client.configPath);
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
-    log.component("mcp-config").debug("Created config directory", { path: configDir });
-  }
-  let finalConfig = config;
-  if (fs.existsSync(client.configPath) && !force) {
-    try {
-      const existingContent = fs.readFileSync(client.configPath, "utf8");
-      const existingConfig = JSON.parse(existingContent);
-      finalConfig = mergeConfig(existingConfig, config, client);
-      log.component("mcp-config").debug("Merged with existing config", { client: client.id });
-    } catch {
-      log.component("mcp-config").warn("Could not parse existing config, using new", { client: client.id });
-    }
-  }
-  fs.writeFileSync(client.configPath, JSON.stringify(finalConfig, null, 2) + "\n");
-  log.component("mcp-config").success("Config written", { client: client.id, path: client.configPath });
-  return {
-    success: true,
-    message: `Config written to ${client.configPath}`
-  };
-}
-function addToGitignore(configPath) {
-  const gitignorePath = path.join(process.cwd(), ".gitignore");
-  const relativePath = path.relative(process.cwd(), configPath);
-  let content = "";
-  if (fs.existsSync(gitignorePath)) {
-    content = fs.readFileSync(gitignorePath, "utf8");
-    if (content.includes(relativePath) || content.includes(path.dirname(relativePath))) {
-      return false;
-    }
-  }
-  const addition = `
-# MCP config (contains local paths)
-${relativePath}
-`;
-  fs.appendFileSync(gitignorePath, addition);
-  return true;
-}
-function getProjectName() {
-  const paradigmPath = path.join(process.cwd(), ".paradigm", "config.yaml");
-  if (fs.existsSync(paradigmPath)) {
-    const content = fs.readFileSync(paradigmPath, "utf8");
-    const match = content.match(/project:\s*["']?([^"'\n]+)["']?/);
-    if (match) return match[1].trim();
-  }
-  return path.basename(process.cwd());
-}
-async function mcpSetupCommand(options) {
-  const spinner = ora();
-  const projectPath = process.cwd();
-  const projectName = getProjectName();
-  console.log(chalk.blue("\n\u{1F50C} Paradigm MCP Setup\n"));
-  const hasParadigm = fs.existsSync(path.join(projectPath, ".paradigm")) || fs.existsSync(path.join(projectPath, ".purpose"));
-  if (!hasParadigm) {
-    console.log(chalk.yellow("\u26A0\uFE0F  No .paradigm/ or .purpose file found."));
-    console.log(chalk.gray("   MCP will work, but you should run `paradigm init` first for full functionality.\n"));
-  }
-  spinner.start("Detecting AI clients...");
-  const clients = detectAllClients();
-  const detectedClients = clients.filter((c) => c.detected);
-  spinner.stop();
-  console.log(chalk.gray("Detected AI clients:\n"));
-  for (const client of clients) {
-    const icon = client.detected ? chalk.green("\u2713") : chalk.gray("\u25CB");
-    const name = client.detected ? client.name : chalk.gray(client.name);
-    const note = client.detected ? chalk.gray(client.configType === "project" ? "(project-level)" : "(user-level)") : chalk.gray("(not found)");
-    console.log(`  ${icon} ${name} ${note}`);
-  }
-  console.log();
-  if (detectedClients.length === 0) {
-    console.log(chalk.yellow("No supported AI clients detected.\n"));
-    console.log(chalk.gray("Supported clients:"));
-    console.log(chalk.gray("  - Cursor (https://cursor.sh)"));
-    console.log(chalk.gray("  - Claude Desktop (https://claude.ai/download)"));
-    console.log(chalk.gray("  - Continue for VS Code"));
-    console.log(chalk.gray("  - Cline for VS Code\n"));
-    console.log(chalk.gray("Install one of these clients and run this command again.\n"));
-    return;
-  }
-  let clientsToSetup = [];
-  if (options.client) {
-    if (options.client === "all") {
-      clientsToSetup = detectedClients;
-    } else {
-      const client = clients.find((c) => c.id === options.client);
-      if (!client) {
-        console.log(chalk.red(`Unknown client: ${options.client}`));
-        console.log(chalk.gray(`Available: ${clients.map((c) => c.id).join(", ")}
-`));
-        return;
-      }
-      if (!client.detected) {
-        console.log(chalk.yellow(`${client.name} not detected on this system.`));
-        console.log(chalk.gray("Proceeding anyway...\n"));
-      }
-      clientsToSetup = [client];
-    }
-  } else if (detectedClients.length === 1) {
-    clientsToSetup = detectedClients;
-  } else {
-    console.log(chalk.cyan("Multiple clients detected. Specify which to configure:\n"));
-    console.log(chalk.white("  paradigm mcp setup --client=cursor"));
-    console.log(chalk.white("  paradigm mcp setup --client=claude-desktop"));
-    console.log(chalk.white("  paradigm mcp setup --client=all"));
-    console.log();
-    return;
-  }
-  for (const client of clientsToSetup) {
-    spinner.start(`Configuring ${client.name}...`);
-    const tracker = log.operation(`mcp-setup-${client.id}`).start("Configuring MCP", { client: client.id });
-    const config = generateMCPConfig(client, projectPath, projectName);
-    const result = writeConfig(client, config, options.force || false);
-    if (result.success) {
-      spinner.succeed(`${client.name} configured`);
-      tracker.success("MCP configured", { client: client.id, path: client.configPath });
-      console.log(chalk.gray(`   \u2192 ${client.configPath}`));
-      if (client.configType === "project" && options.gitignore !== false) {
-        const added = addToGitignore(client.configPath);
-        if (added) {
-          console.log(chalk.gray("   \u2192 Added to .gitignore"));
-          log.component("gitignore").debug("Added MCP config to .gitignore", { path: client.configPath });
-        }
-      }
-    } else {
-      spinner.fail(`Failed to configure ${client.name}: ${result.message}`);
-      tracker.error("MCP configuration failed", { client: client.id, message: result.message });
-    }
-  }
-  console.log(chalk.green("\n\u2713 MCP setup complete!\n"));
-  console.log(chalk.cyan("Next steps:"));
-  const uniqueInstructions = [...new Set(clientsToSetup.map((c) => c.instructions))];
-  uniqueInstructions.forEach((instruction) => {
-    console.log(chalk.gray(`  \u2022 ${instruction}`));
-  });
-  console.log(chalk.gray("\nThen try asking your AI:"));
-  console.log(chalk.white(`  "What features are in the ${projectName} project?"`));
-  console.log(chalk.white('  "What would break if I changed @feature-name?"'));
-  console.log();
-  if (options.json) {
-    const output = {
-      project: projectName,
-      path: projectPath,
-      configured: clientsToSetup.map((c) => ({
-        client: c.id,
-        name: c.name,
-        configPath: c.configPath,
-        configType: c.configType
-      }))
-    };
-    console.log(JSON.stringify(output, null, 2));
-  }
-}
-async function mcpStatusCommand(options) {
-  console.log(chalk.blue("\n\u{1F50C} Paradigm MCP Status\n"));
-  const clients = detectAllClients();
-  const results = [];
-  for (const client of clients) {
-    let configured = false;
-    let servers = [];
-    if (fs.existsSync(client.configPath)) {
-      try {
-        const content = fs.readFileSync(client.configPath, "utf8");
-        const config = JSON.parse(content);
-        if (client.id === "continue") {
-          const mcpServers = config?.experimental?.modelContextProtocolServers || [];
-          configured = mcpServers.length > 0;
-          servers = mcpServers.map((_, i) => `server-${i + 1}`);
-        } else {
-          const mcpServers = config?.mcpServers || {};
-          configured = Object.keys(mcpServers).length > 0;
-          servers = Object.keys(mcpServers);
-        }
-      } catch {
-      }
-    }
-    const icon = client.detected ? configured ? chalk.green("\u2713") : chalk.yellow("\u25CB") : chalk.gray("\u25CB");
-    const status = configured ? chalk.green("configured") : client.detected ? chalk.yellow("not configured") : chalk.gray("not detected");
-    console.log(`  ${icon} ${client.name}: ${status}`);
-    if (configured && servers.length > 0) {
-      console.log(chalk.gray(`     Servers: ${servers.join(", ")}`));
-    }
-    results.push({
-      client: client.id,
-      configured,
-      path: client.configPath,
-      servers: configured ? servers : void 0
-    });
-  }
-  console.log();
-  if (options.json) {
-    console.log(JSON.stringify(results, null, 2));
-  }
-}
-function getServersFromConfig(client) {
-  if (!fs.existsSync(client.configPath)) {
-    return [];
-  }
-  try {
-    const content = fs.readFileSync(client.configPath, "utf8");
-    const config = JSON.parse(content);
-    if (client.id === "continue") {
-      const mcpServers = config?.experimental?.modelContextProtocolServers || [];
-      return mcpServers.map((server, i) => {
-        const transport = server?.transport;
-        return {
-          name: `server-${i + 1}`,
-          cwd: transport?.cwd || "unknown",
-          command: transport?.command || "unknown",
-          args: transport?.args || []
-        };
-      });
-    } else {
-      const mcpServers = config?.mcpServers || {};
-      return Object.entries(mcpServers).map(([name, server]) => {
-        const s = server;
-        return {
-          name,
-          cwd: s?.cwd || "unknown",
-          command: s?.command || "unknown",
-          args: s?.args || []
-        };
-      });
-    }
-  } catch {
-    return [];
-  }
-}
-async function mcpListCommand(options) {
-  console.log(chalk.blue("\n\u{1F50C} Configured MCP Servers\n"));
-  const clients = detectAllClients();
-  const currentProjectPath = process.cwd();
-  const allClientServers = [];
-  let totalServers = 0;
-  for (const client of clients) {
-    const servers = getServersFromConfig(client);
-    allClientServers.push({ client, servers });
-    if (servers.length === 0) {
-      continue;
-    }
-    totalServers += servers.length;
-    const scope = client.configType === "project" ? "this project" : "user-level";
-    console.log(chalk.cyan(`${client.name} (${scope}):`));
-    for (const server of servers) {
-      const isCurrentProject = server.cwd === currentProjectPath;
-      const icon = isCurrentProject ? chalk.green("\u25CF") : chalk.gray("\u25CB");
-      const nameDisplay = isCurrentProject ? chalk.green(server.name) : chalk.white(server.name);
-      const cwdDisplay = isCurrentProject ? chalk.green("(current)") : chalk.gray(server.cwd);
-      console.log(`  ${icon} ${nameDisplay.padEnd(20)} \u2192 ${cwdDisplay}`);
-    }
-    console.log();
-  }
-  if (totalServers === 0) {
-    console.log(chalk.yellow("No MCP servers configured.\n"));
-    console.log(chalk.gray("Run `paradigm mcp setup` to configure MCP for your AI clients.\n"));
-  } else {
-    console.log(chalk.gray(`Total: ${totalServers} server(s) across ${allClientServers.filter((cs) => cs.servers.length > 0).length} client(s)
-`));
-  }
-  if (options.json) {
-    const output = allClientServers.map((cs) => ({
-      client: cs.client.id,
-      name: cs.client.name,
-      configType: cs.client.configType,
-      configPath: cs.client.configPath,
-      servers: cs.servers
-    }));
-    console.log(JSON.stringify(output, null, 2));
-  }
-}
-async function mcpRemoveCommand(serverName, options) {
-  const spinner = ora();
-  const projectPath = process.cwd();
-  const projectName = getProjectName();
-  const defaultServerName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-  const targetServerName = serverName || defaultServerName;
-  console.log(chalk.blue("\n\u{1F50C} Paradigm MCP Remove\n"));
-  const clients = detectAllClients();
-  let clientsToCheck = [];
-  if (options.client) {
-    if (options.client === "all") {
-      clientsToCheck = clients;
-    } else {
-      const client = clients.find((c) => c.id === options.client);
-      if (!client) {
-        console.log(chalk.red(`Unknown client: ${options.client}`));
-        console.log(chalk.gray(`Available: ${clients.map((c) => c.id).join(", ")}
-`));
-        return;
-      }
-      clientsToCheck = [client];
-    }
-  } else {
-    clientsToCheck = clients;
-  }
-  let removed = 0;
-  let notFound = 0;
-  const results = [];
-  for (const client of clientsToCheck) {
-    if (!fs.existsSync(client.configPath)) {
-      continue;
-    }
-    spinner.start(`Checking ${client.name}...`);
-    try {
-      const content = fs.readFileSync(client.configPath, "utf8");
-      const config = JSON.parse(content);
-      let modified = false;
-      if (client.id === "continue") {
-        const servers = config?.experimental?.modelContextProtocolServers || [];
-        const originalLength = servers.length;
-        const filtered = servers.filter((server) => {
-          const transport = server?.transport;
-          const serverCwd = transport?.cwd || "";
-          return serverCwd !== projectPath;
-        });
-        if (filtered.length < originalLength) {
-          config.experimental.modelContextProtocolServers = filtered;
-          modified = true;
-          removed++;
-          results.push({ client: client.id, removed: true, serverName: "server (by path)" });
-        } else {
-          notFound++;
-          results.push({ client: client.id, removed: false, serverName: targetServerName });
-        }
-      } else {
-        const servers = config?.mcpServers || {};
-        if (servers[targetServerName]) {
-          delete servers[targetServerName];
-          config.mcpServers = servers;
-          modified = true;
-          removed++;
-          results.push({ client: client.id, removed: true, serverName: targetServerName });
-        } else {
-          let foundByPath = false;
-          for (const [name, server] of Object.entries(servers)) {
-            if (server?.cwd === projectPath) {
-              delete servers[name];
-              config.mcpServers = servers;
-              modified = true;
-              removed++;
-              foundByPath = true;
-              results.push({ client: client.id, removed: true, serverName: name });
-              break;
-            }
-          }
-          if (!foundByPath) {
-            notFound++;
-            results.push({ client: client.id, removed: false, serverName: targetServerName });
-          }
-        }
-      }
-      if (modified) {
-        fs.writeFileSync(client.configPath, JSON.stringify(config, null, 2) + "\n");
-        spinner.succeed(`Removed from ${client.name}`);
-      } else {
-        spinner.info(`${client.name}: Server "${targetServerName}" not found`);
-      }
-    } catch (err) {
-      spinner.fail(`Error reading ${client.name} config`);
-    }
-  }
-  console.log();
-  if (removed > 0) {
-    console.log(chalk.green(`\u2713 Removed from ${removed} client(s)
-`));
-    console.log(chalk.gray("Remember to restart your AI client(s) for changes to take effect.\n"));
-  } else {
-    console.log(chalk.yellow(`Server "${targetServerName}" not found in any client config.
-`));
-    console.log(chalk.gray("Use `paradigm mcp list` to see all configured servers.\n"));
-  }
-  if (options.json) {
-    console.log(JSON.stringify({
-      targetServer: targetServerName,
-      projectPath,
-      results
-    }, null, 2));
-  }
-}
-
-export {
-  detectAllClients,
-  generateMCPConfig,
-  writeConfig,
-  getProjectName,
-  mcpSetupCommand,
-  mcpStatusCommand,
-  getServersFromConfig,
-  mcpListCommand,
-  mcpRemoveCommand
-};