march-cli 0.1.0

package/src/main.mjs

@@ -0,0 +1,294 @@
+import { homedir } from "node:os";
+import { join, resolve, basename, relative } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { parseCliArgs, showHelp } from "./cli/args.mjs";
+import { createUI } from "./cli/ui.mjs";
+import { createPermissionController, MODE } from "./cli/permissions.mjs";
+import { loadKeybindings } from "./cli/input/keybindings.mjs";
+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 { createStatusLineUpdater } from "./cli/status-line-updater.mjs";
+import { wireTuiHandlers } from "./cli/tui/tui-handlers.mjs";
+import { createMarchAuthStorage } from "./auth/storage.mjs";
+import { runLoginCommand } from "./auth/login-command.mjs";
+import { createRunner } from "./agent/runner.mjs";
+import { createCliShellRuntime } from "./shell/cli-runtime.mjs";
+import { MarkdownMemoryStore } from "./memory/markdown-store.mjs";
+import { createMarkdownMemoryTools } from "./memory/markdown-tools.mjs";
+import { loadDotEnv } from "./config/dotenv.mjs";
+import { loadConfig } from "./config/loader.mjs";
+import { discoverProjectExtensionPaths } from "./extensions/discovery.mjs";
+import { loadProjectLifecycleHookManifests } from "./extensions/lifecycle-manifest.mjs";
+import { resolvePiSessionManager } from "./session/pi-manager.mjs";
+import { loadOrCreateProjectId, resumeStartupSession } from "./cli/startup/startup-session.mjs";
+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 { runProviderConfigCommand } from "./provider/config-command.mjs";
+import { runWebSearchConfigCommand } from "./web/config-command.mjs";
+import { createDesktopTurnNotifier } from "./notification/desktop-notifier.mjs";
+import { registerSuperGrokOAuthProvider } from "./supergrok/oauth-provider.mjs";
+
+export async function run(argv) {
+  const cwd = process.cwd();
+  loadDotEnv(cwd);
+  registerSuperGrokOAuthProvider();
+
+  const args = parseCliArgs(argv);
+
+  if (args.help) {
+    showHelp();
+    return 0;
+  }
+
+  if (args.command?.name === "login") {
+    try {
+      return await runLoginCommand({
+        providerId: args.command.args[0] ?? args.provider,
+      });
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}\n`);
+      return 1;
+    }
+  }
+
+  if (args.command?.name === "provider" || args.command?.name === "websearch") {
+    const command = args.command.name === "provider" ? runProviderConfigCommand : runWebSearchConfigCommand;
+    if (args.providerConfig) return await command({ homeDir: homedir() });
+    process.stderr.write(`Usage: march ${args.command.name} --config\n`);
+    return 1;
+  }
+
+  const stateRoot = join(homedir(), ".march");
+  if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
+
+  // Load config (CLI args override config file values)
+  const config = loadConfig(cwd);
+  const provider = args.provider ?? config.provider ?? null;
+  const serviceTier = config.serviceTier ?? null;
+  const model = args.model ?? config.model ?? null;
+  const extensionPaths = [
+    ...discoverProjectExtensionPaths(cwd),
+    ...args.extensions.map((extensionPath) => resolve(cwd, extensionPath)),
+  ];
+  const lifecycleManifests = loadProjectLifecycleHookManifests(cwd);
+  const keybindingConfig = loadKeybindings(cwd);
+  const promptTemplateConfig = loadPromptTemplates(cwd);
+  const authConfig = createMarchAuthStorage({ provider: provider ?? "deepseek", providers: config.providers, cwd });
+
+  if (!authConfig.hasAuth) {
+    process.stderr.write("Error: no providers configured. Run: march provider --config\n");
+    return 1;
+  }
+
+  const projectMarchDir = resolve(cwd, ".march");
+  if (!existsSync(projectMarchDir)) mkdirSync(projectMarchDir, { recursive: true });
+  const inputHistoryStore = createInputHistoryStore({ path: join(projectMarchDir, "input-history.json") });
+  const modeState = createModeState();
+  const namespace = loadOrCreateProjectId(projectMarchDir);
+  const memoryRoot = resolveMemoryRoot(config.memoryRoot, stateRoot);
+  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
+  const mcpInit = await initializeMcp({ projectDir: cwd });
+  const { clientManager: mcpClientManager, mcpTools, mcpInjections } = mcpInit;
+  for (const { server, error } of mcpInit.errors) {
+    if (args.json) {
+      // errors will be surfaced in diagnostics via runner status
+    } else {
+      process.stderr.write(`[mcp] ${server}: ${error}\n`);
+    }
+  }
+
+  const webTools = createWebToolsFromConfig(config);
+  const turnNotifier = createDesktopTurnNotifier({
+    enabled: Boolean(config.notifications?.turnEnd),
+  });
+
+  // Permission controller
+  const permissionMode = args.permissionMode ?? MODE.BYPASS;
+  const permissionController = createPermissionController({ mode: permissionMode });
+
+  // Session persistence — always pi mode
+  const usePiSessions = true;
+  const usePiRuntimeHost = true;
+  const sessionSource = "pi";
+  const sessionsRoot = join(projectMarchDir, "sessions");
+  const sessionState = {
+    sessionId: args.resume ?? Date.now().toString(36),
+    sessionDir: null,
+  };
+  sessionState.sessionDir = join(sessionsRoot, sessionState.sessionId);
+  const contextDumpRoot = resolve(projectMarchDir, "context-dumps", sessionState.sessionId);
+  const modelContextDumper = createModelContextDumper({
+    enabled: args.dumpContext,
+    rootDir: contextDumpRoot,
+  });
+
+  const ui = createUI({
+    json: args.json,
+    cwd,
+    keybindings: keybindingConfig.keybindings,
+    promptTemplates: promptTemplateConfig.templates,
+    shellRuntime,
+    historyStore: inputHistoryStore,
+  });
+
+  // Esc to abort current turn
+  let turnRunning = false;
+  let refreshStatusBar = null;
+
+  const runner = await createRunner({
+    cwd,
+    modelId: model,
+    provider,
+    serviceTier,
+
+    providers: config.providers,
+    stateRoot,
+    ui,
+    memoryStore,
+    memoryTools,
+    shellRuntime,
+    mcpTools,
+    mcpInjections,
+    mcpClientManager,
+    webTools,
+    namespace,
+    projectMarchDir,
+    extensionPaths,
+    sessionManager: resolvePiSessionManager({
+      cwd,
+      projectMarchDir,
+      enabled: usePiSessions,
+    }),
+    useRuntimeHost: usePiRuntimeHost,
+    syncPiSidecar: usePiSessions || usePiRuntimeHost,
+    lifecycleHooks: lifecycleManifests.hooks,
+    lifecycleDiagnostics: lifecycleManifests.diagnostics,
+    authStorage: authConfig.authStorage,
+    maxTurns: config.maxTurns ?? undefined,
+    trimBatch: config.trimBatch ?? undefined,
+    permissionController,
+    modelContextDumper,
+    turnNotifier,
+    onModelPayload: ({ estimatedTokens }) => {
+      refreshStatusBar?.({ contextTokens: estimatedTokens });
+    },
+  });
+
+  refreshStatusBar = createStatusLineUpdater({
+    ui,
+    runner,
+    sessionState,
+    sessionSource,
+    getMode: () => modeState.get(),
+  });
+  refreshStatusBar();
+
+  wireTuiHandlers({
+    ui,
+    runner,
+    sessionState,
+    projectMarchDir,
+    refreshStatusBar,
+    isTurnRunning: () => turnRunning,
+    modeState,
+  });
+
+  // Resume session
+  const startupResume = await resumeStartupSession({
+    resumeId: args.resume,
+    runner,
+    sessionState,
+    projectMarchDir,
+    ui,
+  });
+  refreshStatusBar();
+
+  // Single-shot mode
+  if (args.prompt) {
+    turnRunning = true;
+    try {
+      await runSingleShotPrompt({
+        prompt: args.prompt,
+        runner,
+        memoryStore,
+        currentProject,
+        ui,
+        sessionState,
+        refreshStatusBar,
+        modeState,
+      });
+    } finally {
+      turnRunning = false;
+      await closeMarchRuntime({ runner, memoryStore, ui, blankLine: true });
+    }
+    return 0;
+  }
+
+  const dumpContextPath = args.dumpContext ? relative(cwd, contextDumpRoot) : null;
+  if (startupResume.transcriptTurns?.length > 0) ui.restoreTranscript?.(startupResume.transcriptTurns);
+  for (const line of formatStartupBanner({ cwd, modelId: runner.engine.modelId, thinkingLevel: runner.engine.thinkingLevel, mode: modeState.get(), dumpContextPath })) ui.writeln(line);
+  try {
+    await runInteractiveRepl({
+      cwd,
+      args,
+      ui,
+      runner,
+      memoryStore,
+      currentProject,
+      sessionState,
+      sessionsRoot,
+      projectMarchDir,
+      sessionSource,
+      extensionPaths,
+      keybindingConfig,
+      promptTemplateConfig,
+      renderStartupBanner: () => formatStartupBanner({ cwd, modelId: runner.engine.modelId, thinkingLevel: runner.engine.thinkingLevel, mode: modeState.get(), dumpContextPath }),
+      refreshStatusBar,
+      setTurnRunning: (value) => { turnRunning = value; },
+      modeState,
+    });
+  } finally {
+    await closeMarchRuntime({ runner, memoryStore, ui });
+  }
+  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);
+  return resolve(stateRoot, "March Memories");
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) process.exitCode = await run(process.argv.slice(2));

package/src/mcp/client.mjs

@@ -0,0 +1,195 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import { detectTransport } from "./config.mjs";
+
+const DEFAULT_TIMEOUT = 30_000;
+
+export class McpClientManager {
+  constructor() {
+    this._clients = new Map();       // name -> { client, transport, config, status, tools }
+    this._abortController = new AbortController();
+  }
+
+  // ── Connection ─────────────────────────────────────────────────────
+
+  async connect(name, config) {
+    if (this._clients.has(name)) {
+      await this.disconnect(name);
+    }
+
+    const transportType = detectTransport(config);
+    const transport = transportType === "stdio"
+      ? this._createStdioTransport(config)
+      : await this._createHttpTransport(config);
+
+    const client = new Client(
+      { name: "march", version: "0.1.0" },
+      { capabilities: { tools: {} } },
+    );
+
+    try {
+      await client.connect(transport, { timeout: config.timeout ?? DEFAULT_TIMEOUT });
+    } catch (err) {
+      transport.close?.();
+      throw new Error(`Failed to connect to MCP server "${name}": ${err.message}`);
+    }
+
+    this._clients.set(name, {
+      client,
+      transport,
+      config,
+      status: "connected",
+      tools: [],
+    });
+
+    return client;
+  }
+
+  async disconnect(name) {
+    const entry = this._clients.get(name);
+    if (!entry) return;
+    try {
+      await entry.client.close();
+    } catch {
+      // best-effort
+    }
+    try {
+      entry.transport.close?.();
+    } catch {
+      // best-effort
+    }
+    this._clients.delete(name);
+  }
+
+  async disconnectAll() {
+    const names = [...this._clients.keys()];
+    await Promise.all(names.map((n) => this.disconnect(n)));
+  }
+
+  // ── Transport factories ────────────────────────────────────────────
+
+  _createStdioTransport(config) {
+    return new StdioClientTransport({
+      command: config.command,
+      args: config.args ?? [],
+      env: config.env ?? {},
+    });
+  }
+
+  async _createHttpTransport(config) {
+    // Try streamable HTTP first, SSE as fallback
+    try {
+      const transport = new StreamableHTTPClientTransport(new URL(config.url), {
+        requestInit: config.headers ? { headers: config.headers } : undefined,
+      });
+      return transport;
+    } catch {
+      const transport = new SSEClientTransport(new URL(config.url), {
+        requestInit: config.headers ? { headers: config.headers } : undefined,
+      });
+      return transport;
+    }
+  }
+
+  // ── Tool discovery ─────────────────────────────────────────────────
+
+  async discoverTools(name) {
+    const entry = this._clients.get(name);
+    if (!entry) throw new Error(`MCP server "${name}" not connected`);
+
+    try {
+      const result = await entry.client.listTools();
+      entry.tools = result.tools ?? [];
+      return entry.tools;
+    } catch (err) {
+      entry.status = "failed";
+      throw new Error(`Failed to list tools from "${name}": ${err.message}`);
+    }
+  }
+
+  getTools(name) {
+    const entry = this._clients.get(name);
+    return entry?.tools ?? [];
+  }
+
+  getAllTools() {
+    const all = [];
+    for (const [name, entry] of this._clients) {
+      for (const tool of entry.tools) {
+        all.push({ server: name, tool });
+      }
+    }
+    return all;
+  }
+
+  // ── Tool call ──────────────────────────────────────────────────────
+
+  async callTool(serverName, toolName, args, timeout) {
+    const entry = this._clients.get(serverName);
+    if (!entry) throw new Error(`MCP server "${serverName}" not connected`);
+
+    try {
+      const result = await entry.client.callTool(
+        { name: toolName, arguments: args ?? {} },
+        CallToolResultSchema,
+        { resetTimeoutOnProgress: true, timeout: timeout ?? entry.config.timeout ?? DEFAULT_TIMEOUT },
+      );
+
+      // Flatten content into a readable text block
+      return this._formatResult(result);
+    } catch (err) {
+      throw new Error(`MCP tool "${serverName}/${toolName}" failed: ${err.message}`);
+    }
+  }
+
+  _formatResult(result) {
+    const parts = [];
+    for (const item of result.content ?? []) {
+      if (item.type === "text") {
+        parts.push(item.text);
+      } else if (item.type === "image") {
+        parts.push(`[image: ${item.mimeType ?? "unknown"} (${item.data?.length ?? 0} bytes)]`);
+      } else if (item.type === "resource") {
+        parts.push(`[resource: ${item.resource?.uri ?? item.resource?.text ?? "unknown"}]`);
+      } else {
+        parts.push(JSON.stringify(item));
+      }
+    }
+    return {
+      content: parts.join("\n"),
+      details: { serverName, isError: result.isError },
+    };
+  }
+
+  // ── Status ─────────────────────────────────────────────────────────
+
+  getStatus(name) {
+    const entry = this._clients.get(name);
+    if (!entry) return { status: "disconnected" };
+    return {
+      status: entry.status,
+      toolCount: entry.tools.length,
+      transport: detectTransport(entry.config),
+    };
+  }
+
+  getAllStatuses() {
+    const result = {};
+    for (const [name] of this._clients) {
+      result[name] = this.getStatus(name);
+    }
+    return result;
+  }
+
+  isConnected(name) {
+    const entry = this._clients.get(name);
+    return entry?.status === "connected";
+  }
+
+  serverNames() {
+    return [...this._clients.keys()];
+  }
+}

package/src/mcp/config.mjs

@@ -0,0 +1,130 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+
+/**
+ * Load MCP server configurations from .march/mcp.json (project) and
+ * ~/.march/mcp.json (user). Project config takes precedence over user config
+ * for servers with the same name.
+ *
+ * Config format (standard MCP):
+ * {
+ *   "mcpServers": {
+ *     "server-name": {
+ *       "command": "npx",          // stdio transport
+ *       "args": ["-y", "server"],
+ *       "env": { "KEY": "value" }, // optional
+ *       "instructions": "..."       // optional prompt injection
+ *     }
+ *   }
+ * }
+ *
+ * Remote servers use "url" instead of "command"/"args".
+ */
+export function loadMcpConfig(projectDir) {
+  const servers = new Map();
+
+  // User-level config (lower priority)
+  const userPath = join(homedir(), ".march", "mcp.json");
+  if (existsSync(userPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(userPath, "utf-8"));
+      for (const [name, cfg] of Object.entries(raw.mcpServers ?? {})) {
+        servers.set(name, { ...cfg, _scope: "user" });
+      }
+    } catch (err) {
+      console.error(`[mcp] Failed to parse ${userPath}: ${err.message}`);
+    }
+  }
+
+  // Project-level config (higher priority — overrides user)
+  const projectPath = join(projectDir, ".march", "mcp.json");
+  if (existsSync(projectPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(projectPath, "utf-8"));
+      for (const [name, cfg] of Object.entries(raw.mcpServers ?? {})) {
+        servers.set(name, { ...cfg, _scope: "project" });
+      }
+    } catch (err) {
+      console.error(`[mcp] Failed to parse ${projectPath}: ${err.message}`);
+    }
+  }
+
+  return servers;
+}
+
+/**
+ * Walk up from startDir to find all .march/mcp.json files (hierarchical merge).
+ * Closest to startDir wins. Stops at root or when git root boundary is hit.
+ */
+export function loadMcpConfigHierarchical(startDir) {
+  const chain = [];
+  let dir = startDir;
+  const root = dirname(dir) === dir ? dir : null;
+
+  while (dir && dir !== root) {
+    const cfgPath = join(dir, ".march", "mcp.json");
+    if (existsSync(cfgPath)) {
+      try {
+        chain.unshift(JSON.parse(readFileSync(cfgPath, "utf-8")));
+      } catch (err) {
+        console.error(`[mcp] Failed to parse ${cfgPath}: ${err.message}`);
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // User-level as base
+  const userPath = join(homedir(), ".march", "mcp.json");
+  if (existsSync(userPath)) {
+    try {
+      chain.unshift(JSON.parse(readFileSync(userPath, "utf-8")));
+    } catch (err) {
+      console.error(`[mcp] Failed to parse ${userPath}: ${err.message}`);
+    }
+  }
+
+  // Merge: later entries override earlier
+  const servers = new Map();
+  for (const cfg of chain) {
+    for (const [name, serverCfg] of Object.entries(cfg.mcpServers ?? {})) {
+      servers.set(name, serverCfg);
+    }
+  }
+
+  return servers;
+}
+
+/**
+ * Determine transport type from server config.
+ * Returns "stdio" if config has "command", "http" if it has "url".
+ */
+export function detectTransport(config) {
+  if (config.command) return "stdio";
+  if (config.url) return "http";
+  return "stdio"; // default
+}
+
+/**
+ * Build a display name for a server.
+ */
+export function serverDisplayName(name, config) {
+  const source = config._scope ?? "unknown";
+  return `${name} [${detectTransport(config)} · ${source}]`;
+}
+
+/**
+ * Validate server config returns human-readable errors, or null if valid.
+ */
+export function validateMcpConfig(name, config) {
+  const transport = detectTransport(config);
+  if (transport === "stdio" && !config.command) {
+    return `Server "${name}": stdio transport requires "command"`;
+  }
+  if (transport === "http" && !config.url) {
+    return `Server "${name}": http transport requires "url"`;
+  }
+  return null;
+}

package/src/mcp/index.mjs

@@ -0,0 +1,48 @@
+export { loadMcpConfig, loadMcpConfigHierarchical, detectTransport, validateMcpConfig, serverDisplayName } from "./config.mjs";
+export { McpClientManager } from "./client.mjs";
+export { buildMcpToolName, parseMcpToolName, convertMcpTool, convertAllMcpTools } from "./tools.mjs";
+
+/**
+ * Initialize MCP: load config, connect to servers, discover tools.
+ * Returns { clientManager, mcpTools, mcpInjections, errors }.
+ */
+export async function initializeMcp({ projectDir }) {
+  const { loadMcpConfig } = await import("./config.mjs");
+  const { McpClientManager } = await import("./client.mjs");
+  const { convertAllMcpTools } = await import("./tools.mjs");
+
+  const servers = loadMcpConfig(projectDir);
+  if (servers.size === 0) {
+    return { clientManager: null, mcpTools: [], mcpInjections: [], errors: [] };
+  }
+
+  const clientManager = new McpClientManager();
+  const errors = [];
+  const mcpInjections = [];
+
+  for (const [name, config] of servers) {
+    if (config.enabled === false) continue;
+    try {
+      await clientManager.connect(name, config);
+      await clientManager.discoverTools(name);
+      const injection = buildMcpInstructionsInjection(name, config);
+      if (injection) mcpInjections.push(injection);
+    } catch (err) {
+      errors.push({ server: name, error: err.message });
+    }
+  }
+
+  const mcpTools = convertAllMcpTools(clientManager);
+  return { clientManager, mcpTools, mcpInjections, errors };
+}
+
+export function buildMcpInstructionsInjection(serverName, config) {
+  if (typeof config?.instructions !== "string") return null;
+  const content = config.instructions.trim();
+  if (!content) return null;
+  return {
+    type: "mcp_server",
+    source: serverName,
+    content,
+  };
+}