march-cli 0.1.34 → 0.1.36

package/src/cli/slash-commands.mjs

@@ -1,25 +1,10 @@
-import { listExtensionPathsCommand } from "./commands/extensions-command.mjs";
-import { handleExportCommand, parseExportCommand } from "./commands/export-command.mjs";
-import { handleModelCommand, listModels, parseModelCommand } from "./commands/model-command.mjs";
-import { formatHotkeysPanel } from "./repl-commands.mjs";
-import { copyLastAssistantMessage } from "./commands/copy-command.mjs";
-import { handleSessionSourceCommand } from "./session/session-source-command.mjs";
-import { statusCommand } from "./commands/status-command.mjs";
-import { handleThinkingCommand, parseThinkingCommand } from "./commands/thinking-command.mjs";
-import { formatPromptTemplateLines } from "./input/prompt-templates.mjs";
-import { handleSettingsCommand, parseSettingsCommand } from "../config/settings-command.mjs";
-import { handleSessionNameCommand, parseSessionNameCommand } from "./session/session-name-command.mjs";
-import { handleShellCommand, parseShellCommand } from "./shell/shell-command.mjs";
-import { handleProviderCommand, parseProviderCommand } from "./commands/provider-command.mjs";
-import { handleModeCommand, parseModeCommand } from "./commands/mode-command.mjs";
-import { formatHelpLines } from "./commands/help-command.mjs";
+import { runSlashCommand } from "./commands/registry/slash-command-registry.mjs";
 
-export async function handleSlashCommand(trimmed, {
-  ui,
-  runner,
-  sessionState,
-  sessionsRoot,
-  projectMarchDir,
+export async function handleSlashCommand(trimmed, options) {
+  return runSlashCommand(trimmed, normalizeSlashCommandOptions(options));
+}
+
+function normalizeSlashCommandOptions({
   sessionSource = "pi",
   extensionPaths = [],
   keybindings,
@@ -30,170 +15,19 @@ export async function handleSlashCommand(trimmed, {
   renderStartupBanner = null,
   settingsHomeDir,
   configHomeDir = settingsHomeDir,
-  writeClipboard,
+  ...rest
 }) {
-  if (trimmed === "/exit" || trimmed === "/quit") {
-    await handleSessionSourceCommand("/save", { ui, runner, sessionState, sessionSource });
-    return { handled: true, exit: true };
-  }
-
-  if (trimmed === "/new") {
-    if (!runner.canSwitchPiSession?.()) {
-      ui.writeln("Error: pi runtime host is not enabled");
-      return { handled: true };
-    }
-    let refreshContextTokens = false;
-    try {
-      const result = await runner.startNewSession();
-      if (result?.cancelled) {
-        ui.writeln("New session cancelled");
-      } else {
-        refreshContextTokens = true;
-        ui.clearOutput?.();
-        const bannerLines = typeof renderStartupBanner === "function" ? renderStartupBanner() : [];
-        if (bannerLines.length > 0) {
-          for (const line of bannerLines) ui.writeln(line);
-        } else {
-          ui.writeln(`Started new session: ${result.sessionId}`);
-        }
-      }
-    } catch (err) {
-      ui.writeln(`Error: ${err.message}`);
-    }
-    return { handled: true, refreshContextTokens };
-  }
-
-  if (trimmed === "/help") {
-    for (const line of formatHelpLines()) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const modeCommand = parseModeCommand(trimmed);
-  if (modeCommand.type !== "none") {
-    for (const line of handleModeCommand(modeCommand, { modeState })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/hotkeys") {
-    for (const line of formatHotkeysPanel(keybindings, keybindingDiagnostics)) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/templates") {
-    for (const line of formatPromptTemplateLines(promptTemplates, promptTemplateDiagnostics)) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const exportCommand = parseExportCommand(trimmed);
-  if (exportCommand.type !== "none") {
-    for (const line of await handleExportCommand(exportCommand, { runner, sessionState, sessionSource, projectMarchDir })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const settingsCommand = parseSettingsCommand(trimmed);
-  if (settingsCommand.type !== "none") {
-    for (const line of handleSettingsCommand(settingsCommand, { cwd: runner.engine.cwd, homeDir: settingsHomeDir })) {
-      ui.writeln(line);
-    }
-    return { handled: true };
-  }
-
-  if (trimmed === "/extensions") {
-    for (const line of listExtensionPathsCommand(
-      extensionPaths,
-      runner.getExtensionDiagnostics?.(),
-      runner.getExtensionLifecycleState?.(),
-    )) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const thinkingCommand = parseThinkingCommand(trimmed);
-  if (thinkingCommand.type !== "none") {
-    for (const line of await handleThinkingCommand(thinkingCommand, { runner, ui })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/status") {
-    for (const line of statusCommand({
-      runner,
-      sessionState,
-      sessionSource,
-      extensionDiagnostics: runner.getExtensionDiagnostics?.() ?? [],
-      lifecycleState: runner.getExtensionLifecycleState?.() ?? null,
-    })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/notify") {
-    const result = await runner.notifyTest?.();
-    ui.writeln(formatNotificationResult(result));
-    return { handled: true };
-  }
-
-  const shellCommand = parseShellCommand(trimmed);
-  if (shellCommand.type !== "none") {
-    for (const line of handleShellCommand(shellCommand, { shellRuntime: runner.shellRuntime })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const nameCommand = parseSessionNameCommand(trimmed);
-  if (nameCommand.type !== "none") {
-    for (const line of handleSessionNameCommand(nameCommand, { runner, sessionState, sessionSource })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/copy") {
-    for (const line of copyLastAssistantMessage({ engine: runner.engine, writeClipboard })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/mouse") {
-    ui.writeln("Mouse selection is always enabled.");
-    return { handled: true };
-  }
-
-  const sessionSourceCommand = await handleSessionSourceCommand(trimmed, {
-    ui,
-    runner,
-    sessionState,
-    sessionsRoot,
-    projectMarchDir,
+  return {
+    ...rest,
     sessionSource,
-  });
-  if (sessionSourceCommand.handled) return sessionSourceCommand;
-
-  const providerCommand = parseProviderCommand(trimmed);
-  if (providerCommand.type !== "none") {
-    try {
-      ui.writeln(await handleProviderCommand(providerCommand, { ui, runner }));
-    } catch (err) {
-      ui.writeln(`Error: ${err.message}`);
-    }
-    return { handled: true };
-  }
-
-  const modelCommand = parseModelCommand(trimmed);
-  if (modelCommand.type !== "none") {
-    try {
-      ui.writeln(await handleModelCommand(modelCommand, { runner, ui, configHomeDir }));
-    } catch (err) {
-      ui.writeln(`Error: ${err.message}`);
-    }
-    return { handled: true };
-  }
-
-  if (trimmed === "/models") {
-    for (const line of listModels({ runner })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  return { handled: false };
-}
-
-function formatNotificationResult(result) {
-  if (!result) return "notification: unavailable";
-  const channels = (result.results ?? [])
-    .map((entry) => `${entry.channel}:${entry.ok ? "ok" : entry.reason ?? "failed"}`)
-    .join(", ");
-  return `notification: ${result.ok ? "ok" : result.reason ?? "failed"}${channels ? ` (${channels})` : ""}`;
+    extensionPaths,
+    keybindings,
+    keybindingDiagnostics,
+    promptTemplates,
+    promptTemplateDiagnostics,
+    modeState,
+    renderStartupBanner,
+    settingsHomeDir,
+    configHomeDir,
+  };
 }

package/src/cli/startup/app-runtime.mjs

@@ -0,0 +1,201 @@
+import { basename, join, resolve } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import { createUI } from "../ui.mjs";
+import { createPermissionController, MODE } from "../permissions.mjs";
+import { loadKeybindings } from "../input/keybindings.mjs";
+import { createInputHistoryStore } from "../input/history-store.mjs";
+import { createModeState } from "../input/mode-state.mjs";
+import { loadPromptTemplates } from "../input/prompt-templates.mjs";
+import { createStatusLineUpdater } from "../status-line-updater.mjs";
+import { wireTuiHandlers } from "../tui/tui-handlers.mjs";
+import { createMarchAuthStorage } from "../../auth/storage.mjs";
+import { createRuntimeRunner } from "./create-runtime-runner.mjs";
+import { createCliShellRuntime } from "../../shell/cli-runtime.mjs";
+import { MarkdownMemoryStore } from "../../memory/markdown-store.mjs";
+import { createMarkdownMemoryTools } from "../../memory/markdown-tools.mjs";
+import { discoverProjectExtensionPaths } from "../../extensions/discovery.mjs";
+import { loadProjectLifecycleHookManifests } from "../../extensions/lifecycle-manifest.mjs";
+import { loadOrCreateProjectId, resumeStartupSession } from "./startup-session.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 { defaultProfilePaths, ensureProfileFiles } from "../../context/profiles.mjs";
+import { createDesktopTurnNotifier } from "../../notification/desktop-notifier.mjs";
+import { normalizeRemoteMemorySources } from "../../memory/remote/config.mjs";
+import { resolveMemoryRoot } from "../../memory/root.mjs";
+import { ensureBrowserDaemon } from "../../browser/client/lifecycle.mjs";
+
+export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot, useRuntimeProcess } = {}) {
+  if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
+  await ensureBrowserDaemon({ stateRoot }).catch(() => {});
+
+  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;
+  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 { ok: false, code: 1, logger };
+  }
+
+  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 profilePaths = defaultProfilePaths();
+  ensureProfileFiles(profilePaths);
+  const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
+  const remoteMemorySources = normalizeRemoteMemorySources(config);
+  const memoryTools = createMarkdownMemoryTools(memoryStore, { remoteSources: remoteMemorySources });
+  const currentProject = basename(cwd);
+  const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
+
+  const mcpInit = useRuntimeProcess
+    ? { clientManager: null, mcpTools: [], mcpInjections: [], errors: [] }
+    : await initializeMcp({ projectDir: cwd });
+  for (const { server, error } of mcpInit.errors) {
+    if (!args.json) process.stderr.write(`[mcp] ${server}: ${error}\n`);
+  }
+
+  const webTools = createWebToolsFromConfig(config);
+  const turnNotifier = createDesktopTurnNotifier({ enabled: Boolean(config.notifications?.turnEnd), config: config.notifications });
+  const permissionMode = args.permissionMode ?? MODE.BYPASS;
+  const permissionController = createPermissionController({ mode: permissionMode });
+  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,
+  });
+
+  let turnRunning = false;
+  let refreshStatusBar = null;
+  const runnerOptions = {
+    cwd,
+    modelId: model,
+    provider,
+    serviceTier,
+    providers: config.providers,
+    config,
+    stateRoot,
+    memoryRoot,
+    profilePaths,
+    namespace,
+    projectMarchDir,
+    extensionPaths,
+    permissionMode,
+    shellRuntime: Boolean(shellRuntime),
+    lifecycleHooks: lifecycleManifests.hooks,
+    lifecycleDiagnostics: lifecycleManifests.diagnostics,
+    modelContextDumper: { enabled: args.dumpContext, rootDir: contextDumpRoot },
+    remoteMemorySources,
+  };
+
+  let runner;
+  try {
+    runner = await createRuntimeRunner({
+      useRuntimeProcess, runnerOptions, ui, memoryStore, memoryTools, shellRuntime,
+      mcpTools: mcpInit.mcpTools, mcpInjections: mcpInit.mcpInjections, mcpClientManager: mcpInit.clientManager, webTools,
+      usePiSessions, usePiRuntimeHost, authStorage: authConfig.authStorage,
+      permissionController, modelContextDumper, turnNotifier, logger,
+      refreshStatusBar: (...args) => refreshStatusBar?.(...args),
+    });
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}\n`);
+    logger.error("runtime.start_failed", { error: err });
+    memoryStore.close?.();
+    return { ok: false, code: 1, logger };
+  }
+
+  refreshStatusBar = createStatusLineUpdater({
+    ui,
+    runner,
+    sessionState,
+    sessionSource,
+    getMode: () => modeState.get(),
+  });
+  const initialContextTokens = typeof runner.estimateContextTokens === "function"
+    ? await runner.estimateContextTokens("")
+    : null;
+  refreshStatusBar(initialContextTokens ? { contextTokens: initialContextTokens } : undefined);
+
+  wireTuiHandlers({
+    ui,
+    runner,
+    sessionState,
+    projectMarchDir,
+    refreshStatusBar,
+    isTurnRunning: () => turnRunning,
+    modeState,
+  });
+
+  const startupResume = await resumeStartupSession({
+    resumeId: args.resume,
+    runner,
+    sessionState,
+    projectMarchDir,
+    ui,
+  });
+  refreshStatusBar();
+
+  return {
+    ok: true,
+    args,
+    cwd,
+    ui,
+    runner,
+    memoryStore,
+    currentProject,
+    sessionState,
+    sessionsRoot,
+    projectMarchDir,
+    sessionSource,
+    extensionPaths,
+    keybindingConfig,
+    promptTemplateConfig,
+    startupResume,
+    contextDumpRoot,
+    logger,
+    modeState,
+    refreshStatusBar,
+    setTurnRunning(value) { turnRunning = value; },
+  };
+}

package/src/cli/startup/configured-command.mjs

@@ -1,5 +1,6 @@
 import { runBrowserCommand } from "../../browser/cli/command.mjs";
 import { runGatewayCommand } from "../../gateway/command.mjs";
+import { runWebUiCommand } from "../../web-ui/command.mjs";
 
 export async function runConfiguredCliCommand(args, { config, cwd, stateRoot }) {
   if (args.command?.name === "browser") {
@@ -13,5 +14,13 @@ export async function runConfiguredCliCommand(args, { config, cwd, stateRoot })
   if (args.command?.name === "gateway" && args.command.args?.[0] !== "run") {
     return { handled: true, code: await runGatewayCommand(args, { config, cwd }) };
   }
+  if (args.command?.name === "web") {
+    try {
+      return { handled: true, code: await runWebUiCommand(args, { config, cwd, stateRoot }) };
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}\n`);
+      return { handled: true, code: 1 };
+    }
+  }
   return { handled: false, code: null };
 }

package/src/cli/startup/early-command.mjs

@@ -0,0 +1,29 @@
+import { homedir } from "node:os";
+import { runLoginCommand } from "../../auth/login-command.mjs";
+import { runProviderCommand } from "../../provider/command.mjs";
+import { runWebSearchConfigCommand } from "../../web/config-command.mjs";
+import { runMemoryCommand } from "../../memory/command.mjs";
+import { resolveMemoryRoot } from "../../memory/root.mjs";
+import { runConfiguredCliCommand } from "./configured-command.mjs";
+
+export async function runEarlyCliCommand(args, { config, cwd, stateRoot }) {
+  if (args.command?.name === "login") {
+    try {
+      return { handled: true, code: await runLoginCommand({ providerId: args.command.args[0] ?? args.provider }) };
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}\n`);
+      return { handled: true, code: 1 };
+    }
+  }
+  if (args.command?.name === "provider") return { handled: true, code: await runProviderCommand(args) };
+  if (args.command?.name === "websearch") {
+    if (args.providerConfig) return { handled: true, code: await runWebSearchConfigCommand({ homeDir: homedir() }) };
+    process.stderr.write("Usage: march websearch --config\n");
+    return { handled: true, code: 1 };
+  }
+  if (args.command?.name === "memory") {
+    args.memoryRoot = resolveMemoryRoot(config.memoryRoot, stateRoot);
+    return { handled: true, code: await runMemoryCommand(args, { homeDir: homedir() }) };
+  }
+  return await runConfiguredCliCommand(args, { config, cwd, stateRoot });
+}

package/src/cli/turn/turn-input-preparer.mjs

@@ -0,0 +1,41 @@
+import { appendModeReminder } from "../input/mode-state.mjs";
+import { inverse } from "../tui/ui-theme.mjs";
+import { formatRecallHints } from "../../memory/markdown-store.mjs";
+import { formatMessageAttachmentsForDisplay } from "../../session/attachment-display.mjs";
+import { formatShellHints } from "../../shell/hints.mjs";
+
+export function prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState = null }) {
+  memoryStore.beginTurn();
+  const engine = runner.engine ?? {};
+  const carryoverAlreadyRendered = engine.hasRenderedPendingAssistantRecallHints?.() ?? false;
+  const carryoverRecallHints = engine.takePendingAssistantRecallHints?.() ?? [];
+  const userRecallHints = memoryStore.recallForUser(prompt, {
+    currentProject,
+    excludedIds: engine.getRecentRecallMemoryIds?.() ?? [],
+  });
+  const modePrompt = appendModeReminder(prompt, modeState?.get?.());
+  const fullPrompt = appendPromptBlocks(
+    modePrompt,
+    formatRecallHints("user", userRecallHints),
+    formatRecallHints("assistant", carryoverRecallHints),
+    formatShellHints(runner.shellRuntime),
+  );
+
+  return {
+    fullPrompt,
+    userMessage: prompt,
+    runOptions: { userRecallHints, currentProject },
+    displayMessage: formatUserDisplayMessage(prompt),
+    userRecallHints,
+    carryoverRecallHints,
+    shouldRenderCarryoverRecall: carryoverRecallHints.length > 0 && !carryoverAlreadyRendered,
+  };
+}
+
+export function formatUserDisplayMessage(prompt) {
+  return `${inverse(" USER ")} ${formatMessageAttachmentsForDisplay(prompt)}`;
+}
+
+function appendPromptBlocks(prompt, ...blocks) {
+  return [prompt, ...blocks.filter(Boolean)].join("\n\n");
+}

package/src/context/system-core/base.md

@@ -103,6 +103,11 @@ The user primarily asks for software engineering work: fixing bugs, adding behav
 - Use memory_save() to create memories or update whole metadata fields on an existing memory. Before creating a new memory, first search/open related memories and merge updates into an existing memory when they share the same topic, project, or decision thread; prefer modifying the existing memory file over creating a scattered new one. Tags are the primary retrieval key for future recall. Prefer lowercase-kebab-case tags like 'march-cli', 'tooling', 'permissions'.
 - When learning multiple related external workflows or skills, maintain memory as an evolving domain library: start with the specific source name when only one item exists, then rename and rewrite the memory title/description as the scope grows; merge new related learnings into the same memory, preserving each source's unique traits while distilling reusable principles.
 - Distinguish "migrating a Skill to memory" from "learning a Skill": migration preserves the complete Skill folder under memory_root/skills/ and creates a memory entry as its index; that memory should describe what the Skill is for and reference the copied Skill folder path so future recall knows how to use it. Learning only reads and internalizes the Skill's methods, scenarios, and principles into ordinary memory without copying source files. Infer the action from the user's wording, and ask when ambiguous.
+- Do not proactively modify the agent profile. Update `agent.md` only when the user explicitly asks to change persistent agent behavior.
+- Proactively maintain the user profile when stable, reusable user preferences, working style, goals, or identity signals appear in conversation.
+- For user profile updates, distinguish explicit facts from inferred preferences. Write explicit facts directly; write inferred items as preferences or tendencies, and avoid overstating confidence.
+- Do not store transient task details, sensitive information, or one-off opinions in the user profile. Use memory for project-specific reusable knowledge and current conversation for short-lived context.
+- When a user profile update is non-obvious or potentially sensitive, ask before writing; otherwise update it as part of normal task completion and mention it briefly in the final summary.
 - Unlike recall blocks, this system-core center is always visible in every model call. Only update the center for instructions that must always be followed; use memory for contextual, project-specific, or recall-dependent knowledge.
 - If execution takes a meaningful detour, create or update a memory after the task. A detour means the initial plan or assumption failed, multiple approaches were tried, and the final successful path contains reusable project knowledge. Record the failed assumption, what was tried, and the successful approach. Prefer updating an existing related memory over creating a new one.
 </memory_system>