march-cli 0.1.8 → 0.1.10

package/src/lsp/typescript-project-resolver.mjs

@@ -0,0 +1,186 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+
+const CONFIG_RE = /^(?:tsconfig(?:\..+)?|jsconfig)\.json$/;
+const DEFAULT_EXCLUDES = ["node_modules", "bower_components", "jspm_packages"];
+const MATCH_EXTENSIONS = [".ts", ".tsx", ".d.ts", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"];
+
+export function resolveTypeScriptProjectRoot({ filePath, workspaceRoot }) {
+  const configs = findTypeScriptConfigs(dirname(filePath), workspaceRoot);
+  if (configs.length === 0) return null;
+
+  const included = configs.find((config) => configIncludesFile(config, filePath));
+  return dirname(included ?? configs[0]);
+}
+
+function findTypeScriptConfigs(start, stop) {
+  const configs = [];
+  let dir = resolve(start);
+  const boundary = resolve(stop);
+  for (;;) {
+    configs.push(...configFilesIn(dir));
+    if (dir === boundary || dirname(dir) === dir) return configs;
+    dir = dirname(dir);
+  }
+}
+
+function configFilesIn(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && CONFIG_RE.test(entry.name))
+    .map((entry) => entry.name)
+    .sort(configSort)
+    .map((name) => join(dir, name));
+}
+
+function configSort(a, b) {
+  return configRank(a) - configRank(b) || a.localeCompare(b);
+}
+
+function configRank(name) {
+  if (name === "tsconfig.json") return 0;
+  if (name === "jsconfig.json") return 1;
+  return 2;
+}
+
+function configIncludesFile(configPath, filePath) {
+  const config = readConfigChain(configPath);
+  if (!config) return false;
+
+  const exclude = config.exclude ?? DEFAULT_EXCLUDES.map((pattern) => ({ base: dirname(configPath), pattern }));
+  if (exclude.some(({ base, pattern }) => matchesPatternFromBase(filePath, base, pattern))) return false;
+
+  if (config.files) {
+    return config.files.some(({ base, pattern }) => normalizePath(relative(base, filePath)) === normalizePath(pattern));
+  }
+
+  if (config.include) {
+    return config.include.some(({ base, pattern }) => matchesPatternFromBase(filePath, base, pattern));
+  }
+
+  const file = normalizePath(relative(dirname(configPath), filePath));
+  return !isOutside(file) && MATCH_EXTENSIONS.some((ext) => file.endsWith(ext));
+}
+
+function readConfigChain(path, seen = new Set()) {
+  if (seen.has(path)) return null;
+  seen.add(path);
+
+  const raw = readConfig(path);
+  if (!raw) return null;
+  const base = resolveExtends(path, raw.extends, seen);
+  return {
+    files: patternList(raw.files, dirname(path)) ?? base?.files ?? null,
+    include: patternList(raw.include, dirname(path)) ?? base?.include ?? null,
+    exclude: patternList(raw.exclude, dirname(path)) ?? base?.exclude ?? null,
+  };
+}
+
+function resolveExtends(configPath, value, seen) {
+  if (typeof value !== "string" || !value.startsWith(".")) return null;
+  const resolved = resolve(dirname(configPath), value.endsWith(".json") ? value : `${value}.json`);
+  return existsSync(resolved) ? readConfigChain(resolved, seen) : null;
+}
+
+function readConfig(path) {
+  try {
+    return JSON.parse(stripJsonComments(readFileSync(path, "utf8")));
+  } catch {
+    return null;
+  }
+}
+
+function patternList(value, base) {
+  const items = arrayOfStrings(value);
+  return items ? items.map((pattern) => ({ base, pattern })) : null;
+}
+
+function arrayOfStrings(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : null;
+}
+
+function isOutside(path) {
+  return path === ".." || path.startsWith("../") || path.includes(":");
+}
+
+function matchesPatternFromBase(filePath, base, pattern) {
+  const file = normalizePath(relative(base, filePath));
+  return !isOutside(file) && matchesConfigPattern(file, pattern);
+}
+
+function matchesConfigPattern(file, pattern) {
+  const normalized = normalizePath(pattern);
+  if (!normalized.includes("*") && file === normalized) return true;
+  const glob = normalized.includes("*") ? normalized : `${trimSlash(normalized)}/**/*`;
+  return globToRegExp(glob).test(file);
+}
+
+function globToRegExp(glob) {
+  let source = "^";
+  for (let i = 0; i < glob.length; i += 1) {
+    const char = glob[i];
+    if (char === "*") {
+      if (glob[i + 1] === "*") {
+        i += 1;
+        if (glob[i + 1] === "/") {
+          i += 1;
+          source += "(?:.*/)?";
+        } else {
+          source += ".*";
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegExp(char);
+    }
+  }
+  return new RegExp(`${source}$`);
+}
+
+function trimSlash(path) {
+  return path.replace(/\/+$/, "");
+}
+
+function normalizePath(path) {
+  return path.replaceAll("\\", "/");
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+}
+
+function stripJsonComments(source) {
+  let out = "";
+  let inString = false;
+  let quote = "";
+  for (let i = 0; i < source.length; i += 1) {
+    const char = source[i];
+    const next = source[i + 1];
+    if (inString) {
+      out += char;
+      if (char === "\\") {
+        out += next ?? "";
+        i += 1;
+      } else if (char === quote) {
+        inString = false;
+      }
+    } else if (char === '"' || char === "'") {
+      inString = true;
+      quote = char;
+      out += char;
+    } else if (char === "/" && next === "/") {
+      while (i < source.length && source[i] !== "\n") i += 1;
+      out += "\n";
+    } else if (char === "/" && next === "*") {
+      i += 2;
+      while (i < source.length && !(source[i] === "*" && source[i + 1] === "/")) i += 1;
+      i += 1;
+    } else {
+      out += char;
+    }
+  }
+  return out.replace(/,\s*([}\]])/g, "$1");
+}

package/src/main.mjs

@@ -10,6 +10,7 @@ import { createInputHistoryStore } from "./cli/input/history-store.mjs";
 import { createModeState } from "./cli/input/mode-state.mjs";
 import { loadPromptTemplates } from "./cli/input/prompt-templates.mjs";
 import { runInteractiveRepl, runSingleShotPrompt } from "./cli/repl-loop.mjs";
+import { closeMarchRuntime } from "./cli/startup/runtime-close.mjs";
 import { createStatusLineUpdater } from "./cli/status-line-updater.mjs";
 import { wireTuiHandlers } from "./cli/tui/tui-handlers.mjs";
 import { createMarchAuthStorage } from "./auth/storage.mjs";
@@ -28,6 +29,7 @@ import { formatStartupBanner } from "./cli/startup/startup-banner.mjs";
 import { initializeMcp } from "./mcp/index.mjs";
 import { createWebToolsFromConfig } from "./web/tools.mjs";
 import { createModelContextDumper } from "./debug/model-context-dumper.mjs";
+import { createLogger, installProcessLogHandlers } from "./debug/logger.mjs";
 import { defaultCenterMemoryPath } from "./context/center-memory.mjs";
 import { runProviderConfigCommand } from "./provider/config-command.mjs";
 import { runWebSearchConfigCommand } from "./web/config-command.mjs";
@@ -68,6 +70,15 @@ export async function run(argv) {
 
   const stateRoot = join(homedir(), ".march");
   if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
+  const logger = createLogger({ logDir: join(stateRoot, "logs") });
+  installProcessLogHandlers(logger);
+  logger.event("process.start", {
+    cwd,
+    argv,
+    version: process.version,
+    platform: process.platform,
+    logPath: logger.path,
+  });
 
   const provider = args.provider ?? config.provider ?? null;
   const serviceTier = config.serviceTier ?? null;
@@ -96,7 +107,6 @@ export async function run(argv) {
   const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
   const memoryTools = createMarkdownMemoryTools(memoryStore);
   const currentProject = basename(cwd);
-
   const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
 
   // MCP: connect to configured MCP servers
@@ -182,9 +192,11 @@ export async function run(argv) {
     authStorage: authConfig.authStorage,
     maxTurns: config.maxTurns ?? undefined,
     trimBatch: config.trimBatch ?? undefined,
+    hostedTools: config.hostedTools,
     permissionController,
     modelContextDumper,
     turnNotifier,
+    logger,
     onModelPayload: ({ estimatedTokens }) => {
       refreshStatusBar?.({ contextTokens: estimatedTokens });
     },
@@ -235,8 +247,9 @@ export async function run(argv) {
       });
     } finally {
       turnRunning = false;
-      await closeMarchRuntime({ runner, memoryStore, ui, blankLine: true });
+      await closeMarchRuntime({ runner, memoryStore, ui, logger, blankLine: true });
     }
+    logger.event("process.exit", { code: 0 });
     return 0;
   }
 
@@ -264,32 +277,12 @@ export async function run(argv) {
       modeState,
     });
   } finally {
-    await closeMarchRuntime({ runner, memoryStore, ui });
+    await closeMarchRuntime({ runner, memoryStore, ui, logger });
   }
+  logger.event("process.exit", { code: 0 });
   return 0;
 }
 
-async function closeMarchRuntime({ runner, memoryStore, ui, blankLine = false }) {
-  let firstError = null;
-  try {
-    await runner.dispose();
-  } catch (err) {
-    firstError ??= err;
-  }
-  try {
-    memoryStore.close();
-  } catch (err) {
-    firstError ??= err;
-  }
-  try {
-    if (blankLine) ui.writeln("");
-    await ui.close();
-  } catch (err) {
-    firstError ??= err;
-  }
-  if (firstError) throw firstError;
-}
-
 function resolveMemoryRoot(configured, stateRoot) {
   if (configured) return resolve(String(configured));
   if (process.env.MARCH_MEMORY_ROOT) return resolve(process.env.MARCH_MEMORY_ROOT);

package/src/platform/spawn-command.mjs

@@ -0,0 +1,27 @@
+import { spawn } from "node:child_process";
+
+export function spawnCommand(command, args = [], options = {}) {
+  const resolved = resolveSpawnCommand(command, args);
+  return spawn(resolved.command, resolved.args, { ...options, ...resolved.options });
+}
+
+export function resolveSpawnCommand(command, args = []) {
+  if (process.platform !== "win32" || !isWindowsScriptCommand(command)) {
+    return { command, args };
+  }
+  // Node can fail to spawn .cmd/.bat directly on Windows; cmd.exe runs them reliably.
+  return {
+    command: "cmd.exe",
+    args: ["/d", "/s", "/c", `"${[quoteCmdArg(command), ...args.map(quoteCmdArg)].join(" ")}"`],
+    options: { windowsVerbatimArguments: true },
+  };
+}
+
+function isWindowsScriptCommand(command) {
+  const lower = command.toLowerCase();
+  return lower.endsWith(".cmd") || lower.endsWith(".bat");
+}
+
+function quoteCmdArg(value) {
+  return /[\s&()^|<>"%]/.test(value) ? `"${value.replaceAll('"', '""')}"` : value;
+}

package/src/provider/hosted-tools.mjs

@@ -0,0 +1,111 @@
+const OPENAI_PROVIDERS = new Set(["openai"]);
+const OPENAI_CODEX_PROVIDERS = new Set(["openai-codex"]);
+const AZURE_OPENAI_PROVIDERS = new Set(["azure-openai-responses"]);
+const ANTHROPIC_PROVIDERS = new Set(["anthropic"]);
+const GOOGLE_PROVIDERS = new Set(["google", "google-vertex"]);
+const XAI_PROVIDERS = new Set(["xai", "supergrok-oauth", "xai-oauth"]);
+
+export function injectHostedTools(payload, model, config = {}) {
+  const capabilities = resolveHostedToolCapabilities(model).filter((tool) => isToolEnabled(tool, config));
+  if (capabilities.length === 0) return payload;
+  return injectPayloadHostedTools(payload, capabilities);
+}
+
+export function resolveHostedTools(model, config = {}) {
+  return resolveHostedToolCapabilities(model).filter((tool) => isToolEnabled(tool, config)).map(createHostedTool);
+}
+
+export function resolveHostedToolCapabilities(model) {
+  if (!model || typeof model !== "object") return [];
+  if (OPENAI_PROVIDERS.has(model.provider) && isOpenAiResponsesApi(model.api)) return ["openai.webSearch"];
+  if (OPENAI_CODEX_PROVIDERS.has(model.provider) && model.api === "openai-codex-responses") {
+    return ["openaiCodex.webSearch"];
+  }
+  if (AZURE_OPENAI_PROVIDERS.has(model.provider) && model.api === "azure-openai-responses") {
+    return ["azureOpenai.webSearch"];
+  }
+  if (ANTHROPIC_PROVIDERS.has(model.provider) && model.api === "anthropic-messages") return ["anthropic.webSearch"];
+  if (GOOGLE_PROVIDERS.has(model.provider) && isGoogleApi(model.api)) return ["google.webSearch"];
+  if (XAI_PROVIDERS.has(model.provider) && model.api === "openai-responses") return ["xai.webSearch", "xai.xSearch"];
+  return [];
+}
+
+function isToolEnabled(tool, config) {
+  const [provider, name] = tool.split(".");
+  const value = config?.[provider]?.[name] ?? "auto";
+  return value !== false;
+}
+
+function createHostedTool(tool) {
+  if (tool === "openai.webSearch" || tool === "azureOpenai.webSearch") return { type: "web_search_preview" };
+  if (tool === "openaiCodex.webSearch") return { type: "web_search" };
+  if (tool === "anthropic.webSearch") return { type: "web_search_20250305", name: "web_search" };
+  if (tool === "google.webSearch") return { googleSearch: {} };
+  if (tool === "xai.webSearch") return { type: "web_search", enable_image_understanding: true };
+  if (tool === "xai.xSearch") {
+    return { type: "x_search", enable_image_understanding: true, enable_video_understanding: true };
+  }
+  throw new Error(`Unsupported hosted tool capability: ${tool}`);
+}
+
+function isOpenAiResponsesApi(api) {
+  return api === "openai-responses";
+}
+
+function isGoogleApi(api) {
+  return api === "google-generative-ai" || api === "google-vertex";
+}
+
+function injectPayloadHostedTools(payload, capabilities) {
+  if (!payload || typeof payload !== "object") return payload;
+  if (payload.body && typeof payload.body === "object") {
+    return { ...payload, body: injectPayloadHostedTools(payload.body, capabilities) };
+  }
+  if (typeof payload.body === "string") return injectStringBodyHostedTools(payload, capabilities);
+  return capabilities.reduce((next, capability) => injectPayloadHostedTool(next, capability), payload);
+}
+
+function injectPayloadHostedTool(payload, capability) {
+  if (capability.startsWith("google.")) return appendGoogleTool(payload, createHostedTool(capability));
+  return appendTopLevelTool(payload, createHostedTool(capability));
+}
+
+function injectStringBodyHostedTools(payload, capabilities) {
+  try {
+    const body = JSON.parse(payload.body);
+    return { ...payload, body: JSON.stringify(injectPayloadHostedTools(body, capabilities)) };
+  } catch {
+    return payload;
+  }
+}
+
+function appendTopLevelTool(payload, tool) {
+  if (!Array.isArray(payload.tools)) return { ...payload, tools: [tool] };
+  return { ...payload, tools: mergeTools(payload.tools, [tool], getToolKey) };
+}
+
+function appendGoogleTool(payload, tool) {
+  const config = payload.config && typeof payload.config === "object" ? payload.config : {};
+  const tools = Array.isArray(config.tools) ? config.tools : [];
+  return {
+    ...payload,
+    config: {
+      ...config,
+      tools: mergeTools(tools, [tool], getGoogleToolKey),
+    },
+  };
+}
+
+function mergeTools(existing, added, keyForTool) {
+  const keys = new Set(existing.map(keyForTool).filter(Boolean));
+  return [...existing, ...added.filter((tool) => !keys.has(keyForTool(tool)))];
+}
+
+function getToolKey(tool) {
+  return tool?.type ?? tool?.name;
+}
+
+function getGoogleToolKey(tool) {
+  if (tool?.googleSearch) return "googleSearch";
+  return tool?.functionDeclarations ? "functionDeclarations" : getToolKey(tool);
+}

package/src/web/tools.mjs

@@ -6,8 +6,8 @@ import { fetchWebPage } from "./fetch.mjs";
 
 export function createWebTools({ tavilyKey, braveKey } = {}) {
   const webSearchTool = defineTool({
-    name: "web_search",
-    label: "Web Search",
+    name: "external_web_search",
+    label: "External Web Search",
     description:
       "Search the web for current information on any topic. " +
       "Requires TAVILY_API_KEY or BRAVE_API_KEY; if neither is configured, use web_fetch when you already know the URL. " +