@codemap-ai/cli 0.1.5 → 0.1.8

package/dist/{chunk-GGIXJZYK.js → chunk-57JG7UZE.js}

@@ -4,8 +4,9 @@ import {
   __require,
   __toESM,
   createCodeMapClient,
+  findMonorepoRoot,
   loadConfig
-} from "./chunk-AXGGL47C.js";
+} from "./chunk-4F6G2Q7W.js";
 
 // ../code-index/dist/language-utils.js
 var require_language_utils = __commonJS({
@@ -215409,7 +215410,7 @@ var require_dist = __commonJS({
   }
 });
 
-// src/lib/workspace-git.ts
+// ../core/src/lib/workspace-git.ts
 import { execFile } from "child_process";
 import path from "path";
 import { promisify } from "util";
@@ -215462,14 +215463,14 @@ async function getCurrentWorkspaceInfo(cwd = process.cwd()) {
   };
 }
 
-// src/lib/local-index.ts
+// ../core/src/lib/local-index.ts
 var import_code_index = __toESM(require_dist(), 1);
 import path5 from "path";
 
-// src/lib/workspace-resolver.ts
+// ../core/src/lib/workspace-resolver.ts
 import path3 from "path";
 
-// src/lib/workspace-project.ts
+// ../core/src/lib/workspace-project.ts
 import path2 from "path";
 import { access, mkdir, readFile, writeFile } from "fs/promises";
 var WORKSPACE_CONFIG_FILE = ".codemap/mcp.json";
@@ -215479,21 +215480,30 @@ async function readWorkspaceProjectConfigAt(configPath) {
   let mcpServers;
   if (parsed.mcpServers && typeof parsed.mcpServers === "object" && !Array.isArray(parsed.mcpServers)) {
     mcpServers = {};
-    for (const [name, config] of Object.entries(parsed.mcpServers)) {
+    for (const [name, config] of Object.entries(
+      parsed.mcpServers
+    )) {
       if (config && typeof config === "object" && !Array.isArray(config)) {
         const sc = config;
         const entry = {};
         if (typeof sc.type === "string") entry.type = sc.type;
         if (typeof sc.command === "string") entry.command = sc.command;
-        if (Array.isArray(sc.args)) entry.args = sc.args.filter((a) => typeof a === "string");
+        if (Array.isArray(sc.args))
+          entry.args = sc.args.filter(
+            (a) => typeof a === "string"
+          );
         if (sc.env && typeof sc.env === "object" && !Array.isArray(sc.env)) {
           entry.env = {};
-          for (const [k, v] of Object.entries(sc.env)) {
+          for (const [k, v] of Object.entries(
+            sc.env
+          )) {
             if (typeof v === "string") entry.env[k] = v;
           }
         }
         if (Array.isArray(sc.priorityResources)) {
-          entry.priorityResources = sc.priorityResources.filter((r) => typeof r === "string");
+          entry.priorityResources = sc.priorityResources.filter(
+            (r) => typeof r === "string"
+          );
         }
         mcpServers[name] = entry;
       }
@@ -215529,6 +215539,10 @@ async function readWorkspaceProjectConfig(cwd = process.cwd()) {
       resolvedRepoRoot ??= workspace.repoRootPath;
     }
   }
+  try {
+    candidateRoots.add(await findMonorepoRoot(cwd));
+  } catch {
+  }
   for (const root of candidateRoots) {
     try {
       const config = await readWorkspaceProjectConfigAt(
@@ -215551,42 +215565,39 @@ async function readPriorityResources(serverName = "codemap", cwd = process.cwd()
   const config = await readWorkspaceProjectConfig(cwd);
   return config.mcpServers?.[serverName]?.priorityResources ?? [];
 }
-async function readMcpServerConfigs(cwd = process.cwd()) {
+async function readMcpServerConfigs(cwd = process.cwd(), globalMcpServers) {
   const config = await readWorkspaceProjectConfig(cwd);
   const result = /* @__PURE__ */ new Map();
-  if (!config.mcpServers) return result;
-  for (const [name, entry] of Object.entries(config.mcpServers)) {
-    if (entry.command) {
-      result.set(name, { command: entry.command, args: entry.args, env: entry.env });
+  if (globalMcpServers) {
+    for (const [name, entry] of Object.entries(globalMcpServers)) {
+      if (entry.command) {
+        result.set(name, {
+          command: entry.command,
+          args: entry.args,
+          env: entry.env
+        });
+      }
+    }
+  }
+  if (config.mcpServers) {
+    for (const [name, entry] of Object.entries(config.mcpServers)) {
+      if (entry.command) {
+        result.set(name, {
+          command: entry.command,
+          args: entry.args,
+          env: entry.env
+        });
+      }
     }
   }
   return result;
 }
-async function readWorkspaceProjectId(cwd = process.cwd()) {
-  return (await readWorkspaceProjectConfig(cwd)).projectId;
-}
 async function readWorkspacePath(cwd = process.cwd()) {
   const config = await readWorkspaceProjectConfig(cwd);
   if (config.workspaceRootPath) return config.workspaceRootPath;
   const workspace = await tryGetCurrentWorkspaceInfo(cwd);
   return workspace?.repoRootPath ?? cwd;
 }
-async function saveWorkspaceProjectId(workspaceRoot, projectId) {
-  const configPath = path2.join(workspaceRoot, WORKSPACE_CONFIG_FILE);
-  let existing = {};
-  try {
-    const raw = await readFile(configPath, "utf8");
-    existing = JSON.parse(raw);
-  } catch {
-  }
-  await mkdir(path2.dirname(configPath), { recursive: true });
-  await writeFile(
-    configPath,
-    `${JSON.stringify({ ...existing, projectId, workspaceRootPath: workspaceRoot }, null, 2)}
-`,
-    "utf8"
-  );
-}
 async function saveMcpServerEntry(workspaceRoot, name, entry) {
   const configPath = path2.join(workspaceRoot, WORKSPACE_CONFIG_FILE);
   let existing = {};
@@ -215618,16 +215629,12 @@ async function removeMcpServerEntry(workspaceRoot, name) {
   if (!(name in mcpServers)) return false;
   delete mcpServers[name];
   existing.mcpServers = mcpServers;
-  await writeFile(
-    configPath,
-    `${JSON.stringify(existing, null, 2)}
-`,
-    "utf8"
-  );
+  await writeFile(configPath, `${JSON.stringify(existing, null, 2)}
+`, "utf8");
   return true;
 }
 
-// src/lib/workspace-resolver.ts
+// ../core/src/lib/workspace-resolver.ts
 async function resolveWorkspace(input) {
   const cwd = input?.cwd ?? process.cwd();
   const envWorkspaceRoot = process.env.WORKSPACE_ROOT?.trim() || null;
@@ -215649,6 +215656,13 @@ async function resolveWorkspace(input) {
       resolution: "project_local_path"
     });
   }
+  try {
+    const monorepoRoot = await findMonorepoRoot(cwd);
+    if (monorepoRoot !== cwd) {
+      candidates.push({ path: monorepoRoot, resolution: "monorepo" });
+    }
+  } catch {
+  }
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of candidates) {
     const candidatePath = path3.resolve(candidate.path);
@@ -215672,7 +215686,7 @@ async function resolveWorkspace(input) {
   };
 }
 
-// src/lib/import-health.ts
+// ../core/src/lib/import-health.ts
 function normalizeRepositoryUrl(value) {
   const trimmed = value.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
   const githubSshMatch = /^git@github\.com:(.+)$/i.exec(trimmed);
@@ -215697,9 +215711,6 @@ function shouldCompareWorkspaceCommit(project, workspace) {
     project.localWorkspacePath && workspace.repoRootPath && project.localWorkspacePath === workspace.repoRootPath
   );
 }
-function isImportDone(status) {
-  return status === "completed" || status === "failed";
-}
 async function fetchLatestProjectImport(client, projectId) {
   const imports = await client.request(
     `/projects/${encodeURIComponent(projectId)}/imports`,
@@ -215826,22 +215837,8 @@ async function getProjectImportHealth(client, projectId, project) {
     project
   });
 }
-function formatShortCommit(commit) {
-  return commit ? commit.slice(0, 8) : null;
-}
-function describeImportHealth(health) {
-  const lines = [
-    `Index health: ${health.state}`,
-    health.latestImport?.commitSha ? `Import commit: ${formatShortCommit(health.latestImport.commitSha)}` : null,
-    health.workspace?.commitSha ? `Local commit: ${formatShortCommit(health.workspace.commitSha)}` : null,
-    health.workspaceResolution ? `Workspace: ${health.workspaceResolution}` : null,
-    health.commitComparison.status === "different" ? "Local workspace differs from the latest indexed commit." : null,
-    health.nextAction !== "none" ? `Next action: ${health.nextAction}` : null
-  ];
-  return lines.filter(Boolean).join("\n");
-}
 
-// src/lib/sqlite-index-store.ts
+// ../core/src/lib/sqlite-index-store.ts
 import { DatabaseSync } from "node:sqlite";
 import { existsSync, mkdirSync } from "fs";
 import path4 from "path";
@@ -216543,7 +216540,7 @@ var SQLiteIndexStore = class _SQLiteIndexStore {
   }
 };
 
-// src/lib/local-index.ts
+// ../core/src/lib/local-index.ts
 var _cachedStore = null;
 function toLocalFile(file, semantics) {
   return {
@@ -216692,49 +216689,11 @@ async function removeLocalFile(relativePath, workspaceRootPath) {
   _cachedStore = null;
   return removed;
 }
-async function getLocalIndexSummary(store) {
-  const files = await collectFilesForStore(store);
-  return store.getSummary(files.length > 0 ? store.isStale(files) : false);
-}
 async function ensureLocalIndexWithSummary(input) {
   const store = await ensureLocalIndex(input);
   const summary = store.getSummary(false);
   return { store, summary };
 }
-function isCloudContentEmpty(content) {
-  return content?.status === "ready" && !content.content;
-}
-function shouldFallbackToLocal(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return message.includes("Not authenticated") || message.includes("Failed to reach CodeMap API") || message.includes("CodeMap API returned 401") || message.includes("CodeMap API returned 403") || message.includes("CodeMap API returned 404") || message.includes("CodeMap API returned 409") || message.includes("CodeMap API returned 422") || message.includes("Unexpected response from API");
-}
-async function shouldUseLocalIndexBeforeRemote(client, projectId) {
-  try {
-    const [latestImport, workspace] = await Promise.all([
-      fetchLatestProjectImport(client, projectId),
-      resolveWorkspace()
-    ]);
-    if (!latestImport) return true;
-    if (latestImport.status !== "completed" || latestImport.parseStatus !== "completed") {
-      return true;
-    }
-    if (latestImport.commitSha && workspace.workspace?.commitSha && latestImport.commitSha !== workspace.workspace.commitSha) {
-      return true;
-    }
-    return false;
-  } catch (error) {
-    return shouldFallbackToLocal(error);
-  }
-}
-function toRepoRelativePath(filePath, workspaceRootPath) {
-  const normalized = path5.normalize(filePath);
-  const root = path5.normalize(workspaceRootPath);
-  if (path5.isAbsolute(normalized) && normalized.startsWith(root)) {
-    const rel = normalized.slice(root.length);
-    return rel.startsWith(path5.sep) ? rel.slice(1) : rel;
-  }
-  return filePath;
-}
 
 // src/commands/status.ts
 function formatAge(date) {
@@ -218193,32 +218152,18 @@ async function switchMastraThread(threadId) {
 
 export {
   tryGetCurrentWorkspaceInfo,
-  readWorkspaceProjectConfig,
   readPriorityResources,
   readMcpServerConfigs,
-  readWorkspaceProjectId,
   readWorkspacePath,
-  saveWorkspaceProjectId,
   saveMcpServerEntry,
   removeMcpServerEntry,
-  resolveWorkspace,
-  isImportDone,
-  buildImportHealth,
-  getProjectImportHealth,
-  formatShortCommit,
-  describeImportHealth,
   require_dist,
   buildLocalIndex,
   readLocalIndex,
   ensureLocalIndex,
   refreshLocalFile,
   removeLocalFile,
-  getLocalIndexSummary,
   ensureLocalIndexWithSummary,
-  isCloudContentEmpty,
-  shouldFallbackToLocal,
-  shouldUseLocalIndexBeforeRemote,
-  toRepoRelativePath,
   getWorkspaceStatusLines,
   runStatusCommand,
   resolveGatewayModel,

package/dist/{chunk-MF6QRGI5.js → chunk-7NZT33JN.js}

@@ -2,7 +2,7 @@ import{createRequire as __cmr}from"node:module";import{fileURLToPath as __f2p}fr
 import {
   readMcpServerConfigs,
   readPriorityResources
-} from "./chunk-GGIXJZYK.js";
+} from "./chunk-57JG7UZE.js";
 
 // src/cli-agent/chat/mcp-tools/mcp-tool-client.ts
 import { existsSync } from "fs";
@@ -46,8 +46,8 @@ var CodeMapMcpToolClient = class {
   getExtraServerConfigs() {
     return Object.fromEntries(this._extraConfigs);
   }
-  async connectExtras() {
-    const configs = await readMcpServerConfigs();
+  async connectExtras(globalMcpServers) {
+    const configs = await readMcpServerConfigs(process.cwd(), globalMcpServers);
     for (const [name, config] of configs) {
       this._extraConfigs.set(name, config);
     }
@@ -189,25 +189,36 @@ function resolvePackageRuntime() {
 function resolveServerCommand(runtime) {
   const { packageRoot, isSourceRuntime } = runtime;
   if (isSourceRuntime) {
-    return {
-      command: process.execPath,
-      args: [
-        require2.resolve("tsx/cli"),
-        path.join(packageRoot, "src", "index.ts")
-      ]
-    };
+    const mcpSrcEntry = path.join(
+      path.dirname(packageRoot),
+      "mcp",
+      "src",
+      "index.ts"
+    );
+    if (existsSync(mcpSrcEntry)) {
+      return {
+        command: process.execPath,
+        args: [require2.resolve("tsx/cli"), mcpSrcEntry]
+      };
+    }
   }
-  const distEntry = path.join(packageRoot, "dist", "index.js");
-  if (existsSync(distEntry)) {
-    return { command: process.execPath, args: [distEntry] };
+  try {
+    const mcpEntry = require2.resolve("@codemap-ai/mcp");
+    return { command: process.execPath, args: [mcpEntry] };
+  } catch {
+    const mcpDistEntry = path.join(
+      path.dirname(packageRoot),
+      "mcp",
+      "dist",
+      "index.js"
+    );
+    if (existsSync(mcpDistEntry)) {
+      return { command: process.execPath, args: [mcpDistEntry] };
+    }
   }
-  return {
-    command: process.execPath,
-    args: [
-      require2.resolve("tsx/cli"),
-      path.join(packageRoot, "src", "index.ts")
-    ]
-  };
+  throw new Error(
+    "Cannot locate CodeMap MCP server. Ensure @codemap-ai/mcp is installed."
+  );
 }
 
 export {

package/dist/{chunk-EUHYFJ32.js → chunk-XBXR7XCX.js}

@@ -10,21 +10,21 @@ import {
   removeMcpServerEntry,
   require_dist,
   saveMcpServerEntry
-} from "./chunk-GGIXJZYK.js";
+} from "./chunk-57JG7UZE.js";
 import {
   __toESM,
   clearGlobalAuthConfig,
   createCodeMapClient,
+  findMonorepoRoot,
   loadConfig,
   startMcpLogin,
   tryOpenLoginBrowser,
   waitForLoginAuthorization
-} from "./chunk-AXGGL47C.js";
+} from "./chunk-4F6G2Q7W.js";
 
 // src/cli-agent/core/convention-synthesizer.ts
 import { readFile, writeFile, mkdir, stat, readdir } from "fs/promises";
 import { createHash } from "crypto";
-import { spawnSync } from "child_process";
 import path from "path";
 var CONVENTION_SOURCES = [
   { label: "Claude Code", paths: ["CLAUDE.md", ".claude/CLAUDE.md"] },
@@ -40,15 +40,14 @@ var RULE_SOURCES = [
   { label: "Claude Code rules", paths: [".claude/rules/*.md"] }
 ];
 var SKILL_DIRS = [".claude/skills", ".codex/skills"];
-function getWorkspaceRoot() {
-  const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8", cwd: process.cwd() });
-  return r.stdout?.trim() || process.cwd();
+async function getWorkspaceRoot() {
+  return findMonorepoRoot(process.cwd());
 }
-function dotCodemap() {
-  return path.join(getWorkspaceRoot(), ".codemap");
+async function dotCodemap() {
+  return path.join(await getWorkspaceRoot(), ".codemap");
 }
-function cachePaths() {
-  const dir = dotCodemap();
+async function cachePaths() {
+  const dir = await dotCodemap();
   return {
     conventions: { md: path.join(dir, "synthesized-conventions.md"), meta: path.join(dir, "conventions-meta.json") },
     rules: { md: path.join(dir, "synthesized-rules.md"), meta: path.join(dir, "rules-meta.json") },
@@ -156,7 +155,7 @@ async function loadCache(paths, hash) {
 }
 async function saveCache(paths, content, hash, files) {
   const meta = { hash, scannedFiles: files.map((f) => f.filePath), tokenCount: estimateTokens(content), synthesizedAt: Date.now() };
-  await mkdir(dotCodemap(), { recursive: true });
+  await mkdir(await dotCodemap(), { recursive: true });
   await Promise.all([writeFile(paths.md, content, "utf8"), writeFile(paths.meta, JSON.stringify(meta, null, 2), "utf8")]);
 }
 async function stream(provider, model, prompt, userContent) {
@@ -229,10 +228,10 @@ _[Truncated \u2014 increase \`conventionMaxTokens\` in .codemap/agent-context.js
   return final;
 }
 async function loadOrSynthesizeAll(provider, model, forceRefresh = false) {
-  const root = getWorkspaceRoot();
+  const root = await getWorkspaceRoot();
   const config = await readConfig(root);
   const maxTokens = config.conventionMaxTokens ?? null;
-  const cp = cachePaths();
+  const cp = await cachePaths();
   const [conventionFiles, ruleFiles, skillFiles] = await Promise.all([
     scanSources(root, CONVENTION_SOURCES),
     scanSources(root, RULE_SOURCES),
@@ -251,7 +250,7 @@ async function refreshAll(provider, model) {
   return loadOrSynthesizeAll(provider, model, true);
 }
 async function getCachedContext() {
-  const cp = cachePaths();
+  const cp = await cachePaths();
   const [conventions, rules, skills] = await Promise.all([
     readFile(cp.conventions.md, "utf8").then((s) => s.trim() || null).catch(() => null),
     readFile(cp.rules.md, "utf8").then((s) => s.trim() || null).catch(() => null),
@@ -1242,19 +1241,19 @@ _/conventions refresh \u2014 re-synthesize from source files_`);
 };
 
 // src/cli-agent/chat/ui/pi-tui/clipboard.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 function copyToClipboard(text) {
   try {
     if (process.platform === "darwin") {
-      return spawnSync2("pbcopy", { input: text, encoding: "utf8" }).status === 0;
+      return spawnSync("pbcopy", { input: text, encoding: "utf8" }).status === 0;
     }
     if (process.platform === "linux") {
-      if (spawnSync2("xclip", ["-selection", "clipboard"], { input: text, encoding: "utf8" }).status === 0) return true;
-      if (spawnSync2("xsel", ["--clipboard", "--input"], { input: text, encoding: "utf8" }).status === 0) return true;
-      if (spawnSync2("wl-copy", [], { input: text, encoding: "utf8" }).status === 0) return true;
+      if (spawnSync("xclip", ["-selection", "clipboard"], { input: text, encoding: "utf8" }).status === 0) return true;
+      if (spawnSync("xsel", ["--clipboard", "--input"], { input: text, encoding: "utf8" }).status === 0) return true;
+      if (spawnSync("wl-copy", [], { input: text, encoding: "utf8" }).status === 0) return true;
     }
     if (process.platform === "win32") {
-      return spawnSync2("clip", { input: text, encoding: "utf8" }).status === 0;
+      return spawnSync("clip", { input: text, encoding: "utf8" }).status === 0;
     }
   } catch {
   }