@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/mcp/config.ts

@@ -1,498 +0,0 @@
-// config.ts - Config loading with import support
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { CONFIG_DIR_NAME, getProjectConfigPaths } from "@bastani/atomic";
-import { getAgentPath, getAgentPaths } from "./agent-dir.ts";
-import type { McpConfig, ServerEntry, McpSettings, ImportKind, ServerProvenance } from "./types.ts";
-import { buildConfigWritePreview, getServersObject, readRawConfigObject, setServersObject, writeRawConfigObject, type ConfigWritePreview } from "./config-write-utils.ts";
-import { MCP_TIMEOUT_MS_CONFIG_ERROR, McpTimeoutConfigError, validateMcpServerTimeouts } from "./tool-call-timeout.js";
-export { MCP_TIMEOUT_MS_CONFIG_ERROR };
-export type { ConfigWritePreview } from "./config-write-utils.ts";
-const GENERIC_GLOBAL_CONFIG_PATH = join(homedir(), ".config", "mcp", "mcp.json");
-const PROJECT_CONFIG_NAME = ".mcp.json";
-const PROJECT_PI_CONFIG_NAME = `${CONFIG_DIR_NAME}/mcp.json`;
-const REPOPROMPT_BINARY_CANDIDATES = [join(homedir(), "RepoPrompt", "repoprompt_cli"), "/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp"];
-
-const IMPORT_PATHS: Record<ImportKind, string[]> = {
-  "claude-code": [
-    join(homedir(), ".claude", "mcp.json"),
-    join(homedir(), ".claude.json"),
-    join(homedir(), ".claude", "claude_desktop_config.json"),
-  ],
-  "claude-desktop": [join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")],
-  codex: [join(homedir(), ".codex", "config.json")],
-  windsurf: [join(homedir(), ".windsurf", "mcp.json")],
-  vscode: [".vscode/mcp.json"],
-};
-interface ConfigSourceSpec {
-  id: "shared-global" | "pi-global" | "shared-project" | "pi-project";
-  label: string;
-  readPath: string;
-  writePath: string;
-  kind: "user" | "project" | "import";
-  importKind?: string;
-  shared: boolean;
-  scope: "global" | "project";
-}
-export interface ConfigDiscoveryPath {
-  label: string;
-  path: string;
-  exists: boolean;
-}
-export interface DiscoveredImportConfig {
-  kind: ImportKind;
-  path: string;
-}
-
-export interface ConfigDiscoverySource extends ConfigDiscoveryPath {
-  id: ConfigSourceSpec["id"];
-  scope: ConfigSourceSpec["scope"];
-  kind: "shared" | "pi";
-  serverCount: number;
-}
-
-export interface ImportConfigSummary extends DiscoveredImportConfig {
-  serverCount: number;
-}
-export interface RepoPromptDiscovery {
-  configured: boolean;
-  configuredPath?: string;
-  executablePath?: string;
-  targetPath?: string;
-  serverName?: string;
-  entry?: ServerEntry;
-}
-export interface McpDiscoverySummary {
-  sources: ConfigDiscoverySource[];
-  imports: ImportConfigSummary[];
-  hasAnyConfig: boolean;
-  hasAnyDetectedPaths: boolean;
-  hasSharedServers: boolean;
-  hasPiOwnedServers: boolean;
-  totalServerCount: number;
-  fingerprint: string;
-  repoPrompt: RepoPromptDiscovery;
-}
-export function getPiGlobalConfigPath(overridePath?: string): string {
-  return overridePath ? resolve(overridePath) : getAgentPath("mcp.json");
-}
-export function getGenericGlobalConfigPath(): string {
-  return GENERIC_GLOBAL_CONFIG_PATH;
-}
-export function getProjectConfigPath(cwd = process.cwd()): string {
-  return resolve(cwd, PROJECT_CONFIG_NAME);
-}
-export function getProjectPiConfigPath(cwd = process.cwd()): string {
-  return resolve(cwd, PROJECT_PI_CONFIG_NAME);
-}
-function getProjectPiConfigPaths(cwd = process.cwd()): string[] {
-  return getProjectConfigPaths(cwd, "mcp.json").map((p) => resolve(p));
-}
-export function getConfigDiscoveryPaths(overridePath?: string, cwd = process.cwd()): ConfigDiscoveryPath[] {
-  return getConfigSources(overridePath, cwd).map((source) => ({
-    label: source.label,
-    path: source.readPath,
-    exists: existsSync(source.readPath),
-  }));
-}
-export function findAvailableImportConfigs(cwd = process.cwd()): DiscoveredImportConfig[] {
-  const discovered: DiscoveredImportConfig[] = [];
-  for (const importKind of Object.keys(IMPORT_PATHS) as ImportKind[]) {
-    const importPath = resolveImportPath(importKind, cwd);
-    if (importPath) {
-      discovered.push({ kind: importKind, path: importPath });
-    }
-  }
-  return discovered;
-}
-export function getMcpDiscoverySummary(overridePath?: string, cwd = process.cwd()): McpDiscoverySummary {
-  const sources = getConfigSources(overridePath, cwd).map((source) => {
-    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
-    return {
-      id: source.id,
-      label: source.label,
-      path: source.readPath,
-      exists: existsSync(source.readPath),
-      scope: source.scope,
-      kind: source.shared ? "shared" : "pi",
-      serverCount: loaded ? Object.keys(loaded.mcpServers).length : 0,
-    } satisfies ConfigDiscoverySource;
-  });
-  const imports = (Object.keys(IMPORT_PATHS) as ImportKind[])
-    .map((kind) => {
-      const path = resolveImportPath(kind, cwd);
-      if (!path) return null;
-      return {
-        kind,
-        path,
-        serverCount: getImportServerCount(kind, path),
-      } satisfies ImportConfigSummary;
-    })
-    .filter((value): value is ImportConfigSummary => value !== null);
-  const totalServerCount = sources.reduce((sum, source) => sum + source.serverCount, 0);
-  const hasSharedServers = sources.some((source) => source.kind === "shared" && source.serverCount > 0);
-  const hasPiOwnedServers = sources.some((source) => source.kind === "pi" && source.serverCount > 0);
-  const hasAnyDetectedPaths = sources.some((source) => source.exists) || imports.length > 0;
-  const hasAnyConfig = totalServerCount > 0 || imports.some((entry) => entry.serverCount > 0) || hasAnyDetectedPaths;
-  const summaryWithoutRepoPrompt = {
-    sources,
-    imports,
-    hasAnyConfig,
-    hasAnyDetectedPaths,
-    hasSharedServers,
-    hasPiOwnedServers,
-    totalServerCount,
-  };
-  const fingerprint = JSON.stringify({
-    sources: sources.map((source) => [source.id, source.exists, source.serverCount]),
-    imports: imports.map((entry) => [entry.kind, entry.path, entry.serverCount]),
-  });
-  return {
-    ...summaryWithoutRepoPrompt,
-    fingerprint,
-    repoPrompt: detectRepoPrompt(summaryWithoutRepoPrompt, cwd),
-  };
-}
-export function loadMcpConfig(overridePath?: string, cwd = process.cwd()): McpConfig {
-  let config: McpConfig = { mcpServers: {} };
-  for (const source of getConfigSources(overridePath, cwd)) {
-    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
-    if (!loaded) continue;
-    config = mergeConfigs(config, expandImports(loaded, cwd));
-  }
-  return config;
-}
-function getConfigSources(overridePath?: string, cwd = process.cwd()): ConfigSourceSpec[] {
-  const userPath = getPiGlobalConfigPath(overridePath);
-  const userPaths = overridePath ? [userPath] : getAgentPaths("mcp.json");
-  const projectPath = getProjectConfigPath(cwd);
-  const projectPiPaths = getProjectPiConfigPaths(cwd);
-  const sources: ConfigSourceSpec[] = [];
-  if (GENERIC_GLOBAL_CONFIG_PATH !== userPath) {
-    sources.push({
-      id: "shared-global",
-      label: "user-global standard MCP",
-      readPath: GENERIC_GLOBAL_CONFIG_PATH,
-      writePath: userPath,
-      kind: "import",
-      importKind: "global MCP config",
-      shared: true,
-      scope: "global",
-    });
-  }
-  for (const readPath of userPaths.reverse()) {
-    sources.push({
-      id: "pi-global",
-      label: readPath === userPath ? "Pi global override" : "Pi legacy global override",
-      readPath,
-      writePath: userPath,
-      kind: "user",
-      shared: false,
-      scope: "global",
-    });
-  }
-  if (projectPath !== userPath) {
-    sources.push({
-      id: "shared-project",
-      label: "project standard MCP",
-      readPath: projectPath,
-      writePath: projectPath,
-      kind: "project",
-      shared: true,
-      scope: "project",
-    });
-  }
-  for (const projectPiPath of projectPiPaths.reverse()) {
-    if (projectPiPath !== userPath && projectPiPath !== projectPath) {
-      sources.push({
-        id: "pi-project",
-        label: projectPiPath === getProjectPiConfigPath(cwd) ? "project Pi override" : "project Pi legacy override",
-        readPath: projectPiPath,
-        writePath: getProjectPiConfigPath(cwd),
-        kind: "project",
-        shared: false,
-        scope: "project",
-      });
-    }
-  }
-  return sources;
-}
-function mergeConfigs(base: McpConfig, next: McpConfig): McpConfig {
-  return {
-    mcpServers: { ...base.mcpServers, ...next.mcpServers },
-    imports: mergeImports(base.imports, next.imports),
-    settings: next.settings ? { ...base.settings, ...next.settings } : base.settings,
-  };
-}
-function mergeImports(left: ImportKind[] | undefined, right: ImportKind[] | undefined): ImportKind[] | undefined {
-  const merged = [...(left ?? []), ...(right ?? [])];
-  if (merged.length === 0) return undefined;
-  return [...new Set(merged)];
-}
-function expandImports(config: McpConfig, cwd = process.cwd()): McpConfig {
-  if (!config.imports?.length) return config;
-  const importedServers: Record<string, ServerEntry> = {};
-  for (const importKind of config.imports) {
-    const importPath = resolveImportPath(importKind, cwd);
-    if (!importPath) continue;
-    try {
-      const imported = JSON.parse(readFileSync(importPath, "utf-8"));
-      const servers = extractServers(imported, importKind);
-      for (const [name, definition] of Object.entries(servers)) {
-        if (!importedServers[name]) {
-          importedServers[name] = definition;
-        }
-      }
-    } catch (error) {
-      if (error instanceof McpTimeoutConfigError) throw error;
-      console.warn(`Failed to import MCP config from ${importKind}:`, error);
-    }
-  }
-  return {
-    imports: config.imports,
-    settings: config.settings,
-    mcpServers: { ...importedServers, ...config.mcpServers },
-  };
-}
-function resolveImportPath(importKind: ImportKind, cwd = process.cwd()): string | null {
-  const candidates = IMPORT_PATHS[importKind] ?? [];
-  for (const candidate of candidates) {
-    const fullPath = candidate.startsWith(".") ? resolve(cwd, candidate) : candidate;
-    if (existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  return null;
-}
-function getImportServerCount(importKind: ImportKind, path: string): number {
-  try {
-    const raw = JSON.parse(readFileSync(path, "utf-8"));
-    return Object.keys(extractServers(raw, importKind)).length;
-  } catch {
-    return 0;
-  }
-}
-function readValidatedConfig(path: string, label: string): McpConfig | null {
-  if (!existsSync(path)) return null;
-  try {
-    return validateMcpConfig(JSON.parse(readFileSync(path, "utf-8")));
-  } catch (error) {
-    if (error instanceof McpTimeoutConfigError) throw error;
-    console.warn(`Failed to load ${label}:`, error);
-    return null;
-  }
-}
-export function validateMcpConfig(raw: unknown): McpConfig {
-  if (!raw || typeof raw !== "object") {
-    return { mcpServers: {} };
-  }
-  const obj = raw as Record<string, unknown>;
-  const servers = obj.mcpServers ?? obj["mcp-servers"] ?? {};
-  if (typeof servers !== "object" || servers === null || Array.isArray(servers)) {
-    return { mcpServers: {} };
-  }
-  return {
-    mcpServers: validateMcpServerTimeouts(servers as Record<string, unknown>),
-    imports: Array.isArray(obj.imports) ? (obj.imports as ImportKind[]) : undefined,
-    settings: obj.settings as McpSettings | undefined,
-  };
-}
-function extractServers(config: unknown, kind: ImportKind): Record<string, ServerEntry> {
-  if (!config || typeof config !== "object") return {};
-  const obj = config as Record<string, unknown>;
-  let servers: unknown;
-  switch (kind) {
-    case "claude-desktop":
-    case "claude-code":
-    case "codex":
-      servers = obj.mcpServers;
-      break;
-    case "windsurf":
-    case "vscode":
-      servers = obj.mcpServers ?? obj["mcp-servers"];
-      break;
-    default:
-      return {};
-  }
-  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
-    return {};
-  }
-  return validateMcpServerTimeouts(servers as Record<string, unknown>);
-}
-function isRepoPromptServer(name: string, entry: ServerEntry): boolean {
-  const normalizedName = name.toLowerCase();
-  if (normalizedName.includes("repoprompt") || normalizedName === "rp") {
-    return true;
-  }
-  const command = entry.command?.toLowerCase() ?? "";
-  if (command.includes("repoprompt") || command.includes("rp-mcp") || command.endsWith("repoprompt_cli")) {
-    return true;
-  }
-  return (entry.args ?? []).some((arg) => typeof arg === "string" && arg.toLowerCase().includes("repoprompt"));
-}
-function findProjectRoot(cwd = process.cwd()): string | null {
-  let current = resolve(cwd);
-  while (true) {
-    if (
-      existsSync(join(current, ".git"))
-      || existsSync(join(current, "package.json"))
-      || existsSync(join(current, PROJECT_CONFIG_NAME))
-      || existsSync(join(current, CONFIG_DIR_NAME))
-    ) {
-      return current;
-    }
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function buildRepoPromptEntry(executablePath: string): ServerEntry {
-  return {
-    command: executablePath,
-    args: [],
-    lifecycle: "lazy",
-  };
-}
-function detectRepoPrompt(summary: Omit<McpDiscoverySummary, "fingerprint" | "repoPrompt">, cwd = process.cwd()): RepoPromptDiscovery {
-  for (const source of summary.sources) {
-    if (source.kind !== "shared" || source.serverCount === 0) continue;
-    const config = readValidatedConfig(source.path, `MCP config from ${source.path}`);
-    if (!config) continue;
-    for (const [name, entry] of Object.entries(config.mcpServers)) {
-      if (isRepoPromptServer(name, entry)) {
-        return { configured: true, configuredPath: source.path };
-      }
-    }
-  }
-  const executablePath = REPOPROMPT_BINARY_CANDIDATES.find((candidate) => existsSync(candidate));
-  if (!executablePath) {
-    return { configured: false };
-  }
-  const projectRoot = findProjectRoot(cwd);
-  const targetPath = projectRoot ? join(projectRoot, PROJECT_CONFIG_NAME) : GENERIC_GLOBAL_CONFIG_PATH;
-  return {
-    configured: false,
-    executablePath,
-    targetPath,
-    serverName: "repoprompt",
-    entry: buildRepoPromptEntry(executablePath),
-  };
-}
-export function previewCompatibilityImports(importKinds: ImportKind[], overridePath?: string): ConfigWritePreview {
-  const targetPath = getPiGlobalConfigPath(overridePath);
-  const raw = readRawConfigObject(targetPath);
-  const currentImports = Array.isArray(raw.imports) ? raw.imports.filter((value): value is ImportKind => typeof value === "string") : [];
-  const merged = [...new Set([...currentImports, ...importKinds])];
-  const nextRaw = { ...raw, imports: merged };
-  setServersObject(nextRaw, getServersObject(nextRaw));
-  return buildConfigWritePreview(targetPath, nextRaw);
-}
-export function ensureCompatibilityImports(importKinds: ImportKind[], overridePath?: string): { path: string; added: ImportKind[] } {
-  const targetPath = getPiGlobalConfigPath(overridePath);
-  const raw = readRawConfigObject(targetPath);
-  const currentImports = Array.isArray(raw.imports) ? raw.imports.filter((value): value is ImportKind => typeof value === "string") : [];
-  const merged = [...new Set([...currentImports, ...importKinds])];
-  const added = merged.filter((kind) => !currentImports.includes(kind));
-  if (added.length === 0) {
-    return { path: targetPath, added: [] };
-  }
-  raw.imports = merged;
-  const servers = getServersObject(raw);
-  setServersObject(raw, servers);
-  writeRawConfigObject(targetPath, raw);
-  return { path: targetPath, added };
-}
-export function buildStarterProjectConfig(): McpConfig {
-  return {
-    mcpServers: {},
-  };
-}
-export function previewStarterProjectConfig(cwd = process.cwd()): ConfigWritePreview {
-  const targetPath = getProjectConfigPath(cwd);
-  const nextRaw = { mcpServers: buildStarterProjectConfig().mcpServers };
-  return buildConfigWritePreview(targetPath, nextRaw);
-}
-export function writeStarterProjectConfig(cwd = process.cwd()): string {
-  const targetPath = getProjectConfigPath(cwd);
-  const raw = { mcpServers: buildStarterProjectConfig().mcpServers };
-  writeRawConfigObject(targetPath, raw);
-  return targetPath;
-}
-export function previewSharedServerEntry(filePath: string, serverName: string, entry: ServerEntry): ConfigWritePreview {
-  const raw = readRawConfigObject(filePath);
-  const nextRaw = { ...raw };
-  const servers = getServersObject(nextRaw);
-  servers[serverName] = entry;
-  setServersObject(nextRaw, servers);
-  return buildConfigWritePreview(filePath, nextRaw);
-}
-export function writeSharedServerEntry(filePath: string, serverName: string, entry: ServerEntry): string {
-  const raw = readRawConfigObject(filePath);
-  const servers = getServersObject(raw);
-  servers[serverName] = entry;
-  setServersObject(raw, servers);
-  writeRawConfigObject(filePath, raw);
-  return filePath;
-}
-export function getServerProvenance(overridePath?: string, cwd = process.cwd()): Map<string, ServerProvenance> {
-  const provenance = new Map<string, ServerProvenance>();
-  const userPath = getPiGlobalConfigPath(overridePath);
-  for (const source of getConfigSources(overridePath, cwd)) {
-    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
-    if (!loaded) continue;
-    if (loaded.imports?.length) {
-      for (const importKind of loaded.imports) {
-        const importPath = resolveImportPath(importKind, cwd);
-        if (!importPath) continue;
-        try {
-          const imported = JSON.parse(readFileSync(importPath, "utf-8"));
-          const servers = extractServers(imported, importKind);
-          for (const name of Object.keys(servers)) {
-            if (!provenance.has(name)) {
-              provenance.set(name, { path: userPath, kind: "import", importKind });
-            }
-          }
-        } catch {}
-      }
-    }
-    for (const name of Object.keys(loaded.mcpServers)) {
-      provenance.set(name, {
-        path: source.writePath,
-        kind: source.kind,
-        importKind: source.importKind,
-      });
-    }
-  }
-  return provenance;
-}
-export function writeDirectToolsConfig(
-  changes: Map<string, true | string[] | false>,
-  provenance: Map<string, ServerProvenance>,
-  fullConfig: McpConfig,
-): void {
-  const byPath = new Map<string, { name: string; value: true | string[] | false; prov: ServerProvenance }[]>();
-  for (const [serverName, value] of changes) {
-    const prov = provenance.get(serverName);
-    if (!prov) continue;
-    const targetPath = prov.path;
-    if (!byPath.has(targetPath)) byPath.set(targetPath, []);
-    byPath.get(targetPath)!.push({ name: serverName, value, prov });
-  }
-  for (const [filePath, entries] of byPath) {
-    const raw = readRawConfigObject(filePath);
-    const servers = getServersObject(raw);
-    for (const { name, value, prov } of entries) {
-      if (prov.kind === "import") {
-        const fullDef = fullConfig.mcpServers[name];
-        if (fullDef) {
-          servers[name] = { ...fullDef, directTools: value };
-        }
-      } else if (servers[name]) {
-        servers[name] = { ...servers[name], directTools: value };
-      }
-    }
-    setServersObject(raw, servers);
-    writeRawConfigObject(filePath, raw);
-  }
-}

package/dist/builtin/mcp/consent-manager.ts

@@ -1,64 +0,0 @@
-import { ConsentError } from "./errors.ts";
-import { logger } from "./logger.ts";
-
-export type ToolConsentMode = "never" | "once-per-server" | "always";
-
-export class ConsentManager {
-  private approvedServers = new Set<string>();
-  private deniedServers = new Set<string>();
-  private log = logger.child({ component: "ConsentManager" });
-
-  constructor(private mode: ToolConsentMode = "once-per-server") {
-    this.log.debug("Initialized", { mode });
-  }
-
-  requiresPrompt(serverName: string): boolean {
-    if (this.mode === "never") return false;
-    if (this.deniedServers.has(serverName)) return true;
-    if (this.mode === "always") return true;
-    return !this.approvedServers.has(serverName);
-  }
-
-  shouldCacheConsent(): boolean {
-    return this.mode !== "always";
-  }
-
-  registerDecision(serverName: string, approved: boolean): void {
-    this.deniedServers.delete(serverName);
-    this.approvedServers.delete(serverName);
-
-    if (approved) {
-      this.approvedServers.add(serverName);
-      this.log.debug("Consent granted", { server: serverName });
-      return;
-    }
-
-    this.deniedServers.add(serverName);
-    this.log.debug("Consent denied", { server: serverName });
-  }
-
-  ensureApproved(serverName: string): void {
-    if (this.mode === "never") return;
-    if (this.deniedServers.has(serverName)) {
-      throw new ConsentError(serverName, { denied: true });
-    }
-    if (!this.approvedServers.has(serverName)) {
-      throw new ConsentError(serverName, { requiresApproval: true });
-    }
-    if (this.mode === "always") {
-      this.approvedServers.delete(serverName);
-    }
-  }
-
-  clear(serverName?: string): void {
-    if (serverName) {
-      this.approvedServers.delete(serverName);
-      this.deniedServers.delete(serverName);
-      this.log.debug("Cleared consent for server", { server: serverName });
-      return;
-    }
-    this.approvedServers.clear();
-    this.deniedServers.clear();
-    this.log.debug("Cleared all consent records");
-  }
-}