march-cli 0.1.0

package/src/cli/commands/model-command.mjs

@@ -0,0 +1,110 @@
+import { getProviderLabel } from "../../provider/presets.mjs";
+import { globalConfigJsonPath, upsertModelSelection } from "../../config/config-json.mjs";
+
+export function parseModelCommand(input) {
+  if (input !== "/model" && !input.startsWith("/model ")) {
+    return { type: "none" };
+  }
+  const arg = input.slice("/model".length).trim();
+  if (!arg) return { type: "select-interactive" };
+  return { type: "error", message: "Use /model without arguments or Ctrl+L to choose a model." };
+}
+
+export async function selectModelByIndex(index, { runner }) {
+  const scopedModels = runner.getScopedModels?.() || [];
+  if (scopedModels.length === 0) return "(no available models - run `march provider --config`)";
+  const selected = scopedModels[index - 1];
+  if (!selected) return `Error: model index out of range: ${index}`;
+  await runner.setModel(selected.model);
+  const name = selected.model.name || selected.model.id;
+  return `Model: ${name} (${selected.model.provider})`;
+}
+
+export function buildModelSelectItems({ current, scopedModels = [] }) {
+  return scopedModels.map(({ model }, index) => ({
+    value: String(index),
+    label: `${getProviderLabel(model.provider)} / ${model.name || model.id}`,
+    description: current && model.id === current.id && model.provider === current.provider ? "current" : model.provider,
+    model,
+  }));
+}
+
+export async function handleModelCommand(parsed, { runner, ui = null, configHomeDir } = {}) {
+  if (parsed.type === "select-interactive") {
+    const scopedModels = runner.getScopedModels?.() || [];
+    if (!ui?.selectList || scopedModels.length === 0) return "Use Ctrl+L to choose a model.";
+    const current = runner.getCurrentModel?.();
+    const selectedIndex = Math.max(0, scopedModels.findIndex(({ model }) =>
+      current && model.id === current.id && model.provider === current.provider
+    ));
+    const item = await ui.selectList({
+      items: buildModelSelectItems({ current, scopedModels }),
+      selectedIndex,
+      width: 72,
+      suppressInitialConfirm: true,
+      searchable: true,
+      getSearchText: modelSelectSearchText,
+    });
+    if (!item) return "Model unchanged.";
+    const model = await runner.setModel(item.model);
+    persistModelSelection(model, { configHomeDir });
+    return `Model: ${model.name || model.id} (${model.provider})`;
+  }
+  if (parsed.type === "select") return selectModelByIndex(parsed.index, { runner });
+  if (parsed.type === "error") return `Error: ${parsed.message}`;
+  return "";
+}
+
+function modelSelectSearchText(item) {
+  const model = item?.model;
+  return `${item?.label ?? ""} ${model?.name ?? ""} ${model?.id ?? ""} ${model?.provider ?? ""}`;
+}
+
+export function persistModelSelection(model, { configHomeDir } = {}) {
+  if (!model?.provider || !model?.id) return null;
+  return upsertModelSelection({
+    path: globalConfigJsonPath(configHomeDir),
+    provider: model.provider,
+    model: model.__isFast ? model.__baseId : model.id,
+    serviceTier: model.__isFast ? "priority" : undefined,
+  });
+}
+
+export function formatModelsList({ current, scopedModels = [] }) {
+  const lines = [];
+  if (current) {
+    lines.push(`Current: ${current.name || current.id} (${current.provider})`);
+  }
+  if (scopedModels.length === 0) {
+    lines.push("(no available models - run `march provider --config`)");
+    return lines;
+  }
+  lines.push(...formatGroupedModels({ current, scopedModels }));
+  lines.push("Use Ctrl+L or /model to choose a model.");
+  return lines;
+}
+
+function formatGroupedModels({ current, scopedModels }) {
+  const groups = new Map();
+  for (const item of scopedModels) {
+    const provider = item.model.provider;
+    if (!groups.has(provider)) groups.set(provider, []);
+    groups.get(provider).push(item);
+  }
+  const lines = [];
+  for (const [provider, items] of [...groups.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    lines.push(`── ${getProviderLabel(provider)} ──`);
+    for (const { model } of items) {
+      const marker = current && model.id === current.id && model.provider === current.provider ? "●" : " ";
+      lines.push(`  ${marker} ${model.name || model.id}`);
+    }
+  }
+  return lines;
+}
+
+export function listModels({ runner }) {
+  return formatModelsList({
+    current: runner.getCurrentModel?.(),
+    scopedModels: runner.getScopedModels?.() || [],
+  });
+}

package/src/cli/commands/paste-image-command.mjs

@@ -0,0 +1,43 @@
+import { readClipboardImage } from "../input/image-clipboard.mjs";
+import { saveImageAttachment } from "../../session/attachments.mjs";
+import { formatAttachmentMarkerForDisplay } from "../../session/attachment-display.mjs";
+
+export function pasteClipboardImage({
+  ui,
+  projectMarchDir,
+  sessionId,
+  readClipboardImageImpl = readClipboardImage,
+  saveImageAttachmentImpl = saveImageAttachment,
+  now = new Date(),
+} = {}) {
+  const image = readClipboardImageImpl();
+  if (!image?.ok) return [`Error: ${image?.message || "failed to read clipboard image"}`];
+
+  let saved;
+  try {
+    saved = saveImageAttachmentImpl({
+      projectMarchDir,
+      sessionId,
+      data: image.data,
+      mimeType: image.mimeType,
+      source: "clipboard",
+      now,
+    });
+  } catch (err) {
+    return [`Error: failed to save clipboard image: ${err.message}`];
+  }
+
+  const marker = `@.march/${saved.relativePath}`;
+  const displayLabel = formatAttachmentMarkerForDisplay(marker);
+  if (typeof ui?.insertAttachmentAtCursor === "function") {
+    ui.insertAttachmentAtCursor({ marker, label: displayLabel });
+  } else {
+    ui?.insertTextAtCursor?.(withLeadingSpace(ui?.getInputText?.() ?? "", marker));
+  }
+  return [`Attached image: ${displayLabel}`];
+}
+
+export function withLeadingSpace(currentText, marker) {
+  if (!String(currentText || "").trim()) return marker;
+  return ` ${marker}`;
+}

package/src/cli/commands/provider-command.mjs

@@ -0,0 +1,55 @@
+import { getProviderLabel } from "../../provider/presets.mjs";
+
+export function parseProviderCommand(input) {
+  if (input !== "/providers" && !input.startsWith("/providers ")) {
+    return { type: "none" };
+  }
+  const arg = input.slice("/providers".length).trim();
+  if (!arg) return { type: "list" };
+  return { type: "error", message: "Provider switching is done by choosing a model with Ctrl+L or /model." };
+}
+
+export function listProviders({ runner }) {
+  const scopedModels = runner.getScopedModels?.() || [];
+  const providers = new Map();
+  for (const { model } of scopedModels) {
+    if (!providers.has(model.provider)) {
+      providers.set(model.provider, {
+        provider: model.provider,
+        modelCount: 0,
+        defaultModel: model.id,
+      });
+    }
+    const entry = providers.get(model.provider);
+    entry.modelCount += 1;
+  }
+  return [...providers.values()].sort((a, b) => a.provider.localeCompare(b.provider));
+}
+
+export function formatProvidersList({ currentProvider, providers = [] }) {
+  if (providers.length === 0) return ["(no providers available)"];
+  return providers.map(({ provider, modelCount }) => {
+    const marker = provider === currentProvider ? "●" : "○";
+    return `${marker} ${provider} (${modelCount} model${modelCount === 1 ? "" : "s"})`;
+  });
+}
+
+export async function handleProviderCommand(parsed, { ui, runner }) {
+  if (parsed.type === "list") {
+    const configured = runner.getConfiguredProviders?.() ?? [];
+    if (configured.length === 0) {
+      return [
+        "Configured providers: (none)",
+        "Run `march provider --config` outside REPL to add credentials.",
+      ].join("\n");
+    }
+    return [
+      "Configured providers:",
+      ...configured.map((provider) => `  ${getProviderLabel(provider)}`),
+      "Use Ctrl+L or /model to choose a model.",
+      "Run `march provider --config` outside REPL to add/update credentials.",
+    ].join("\n");
+  }
+  if (parsed.type === "error") return `Error: ${parsed.message}`;
+  return "";
+}

package/src/cli/commands/status-command.mjs

@@ -0,0 +1,157 @@
+import { spawnSync } from "node:child_process";
+import { MODES, formatModeLabel } from "../input/mode-state.mjs";
+import { accent, text, PREFIX, R } from "../tui/ui-theme.mjs";
+
+export function statusCommand({
+  runner,
+  sessionState,
+  sessionSource = "pi",
+  extensionDiagnostics = [],
+  lifecycleState = null,
+  gitBranch = getGitBranch(runner.engine.cwd),
+}) {
+  return [formatStatusLine({
+    engine: runner.engine,
+    sessionState,
+    sessionStats: runner.getSessionStats?.() ?? null,
+    sessionSource,
+    extensionDiagnostics,
+    lifecycleState,
+    gitBranch,
+  })];
+}
+
+export function statusBarLine({
+  runner,
+  sessionState,
+  sessionSource = "pi",
+  extensionDiagnostics = [],
+  lifecycleState = null,
+  gitBranch = getGitBranch(runner.engine.cwd),
+  mode = MODES.DO,
+  contextTokens = null,
+  activity = null,
+}) {
+  return formatStatusBarLine({
+    engine: runner.engine,
+    sessionState,
+    sessionStats: runner.getSessionStats?.() ?? null,
+    sessionSource,
+    extensionDiagnostics,
+    lifecycleState,
+    gitBranch,
+    mode,
+    contextTokens,
+    activity,
+  });
+}
+
+export function formatStatusLine({
+  engine,
+  sessionState,
+  sessionStats = null,
+  sessionSource = "pi",
+  extensionDiagnostics = [],
+  lifecycleState = null,
+  gitBranch = null,
+}) {
+  const statsSessionId = sessionStats?.sessionId ?? sessionState?.sessionId ?? "unknown";
+  const tokens = sessionStats?.tokens
+    ? `${sessionStats.tokens.input ?? 0}in/${sessionStats.tokens.output ?? 0}out`
+    : "n/a";
+  const parts = [
+    `git:${gitBranch || "none"}`,
+    `session:${statsSessionId}`,
+    `source:${sessionSource}`,
+  ];
+  if (engine.sessionName) parts.push(`name:${engine.sessionName}`);
+  parts.push(
+    `model:${engine.modelId}`,
+    `provider:${engine.provider}`,
+    `thinking:${engine.thinkingLevel ?? "unknown"}`,
+    `tokens:${tokens}`,
+    `ext:${formatExtensionDiagnosticSummary(extensionDiagnostics, lifecycleState)}`,
+  );
+  return parts.join("  ");
+}
+
+export function formatStatusBarLine({
+  engine,
+  mode = MODES.DO,
+  contextTokens = null,
+  activity = null,
+}) {
+  const model = engine.modelId || "model?";
+  const thinking = engine.thinkingLevel || "thinking?";
+
+  const C = PREFIX; // foreground-only color prefixes (no reset)
+  const DIM = C.brightBlack;
+  const OK = "\x1b[32m";  // green, no reset
+  const WARN = "\x1b[33m"; // yellow, no reset
+  const modeSegment = `${mode === MODES.DISCUSS ? WARN : OK}${formatModeLabel(mode)}`;
+  const runtime = `${C.cyan}${model}${DIM}·${thinking}`;
+  const segments = [modeSegment, runtime];
+  const activityText = formatActivitySegment(activity);
+  if (activityText) segments.push(`${C.fg250}${activityText}`);
+  const compactTokens = formatCompactTokenCount(contextTokens);
+  if (compactTokens) segments.push(`${C.fg250}${compactTokens}`);
+
+  const inner = segments.join(` ${DIM}|${C.fg250} `);
+  return `${inner}${R}`;
+}
+
+function formatActivitySegment(activity) {
+  if (!activity) return "";
+  const label = String(activity.label ?? "").trim();
+  const frame = String(activity.frame ?? "").trim();
+  return [frame, label].filter(Boolean).join(" ");
+}
+
+export function formatCompactTokenCount(tokens) {
+  const value = Number(tokens);
+  if (!Number.isFinite(value) || value <= 0) return "";
+  if (value < 1000) return String(Math.ceil(value));
+  if (value < 1000000) return `${formatOneDecimal(value / 1000)}K`;
+  return `${formatOneDecimal(value / 1000000)}M`;
+}
+
+export function formatExtensionDiagnosticSummary(extensionDiagnostics = [], lifecycleState = null) {
+  const diagnostics = [...extensionDiagnostics, ...(lifecycleState?.diagnostics ?? [])];
+  if (diagnostics.length === 0) return "ok";
+  const counts = new Map();
+  for (const diagnostic of diagnostics) {
+    const type = diagnostic?.type ?? "info";
+    counts.set(type, (counts.get(type) ?? 0) + 1);
+  }
+  return [...counts.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([type, count]) => `${count}${type}`)
+    .join(",");
+}
+
+export function getGitBranch(cwd) {
+  const branch = runGit(cwd, ["branch", "--show-current"]);
+  if (branch) return branch;
+  return runGit(cwd, ["rev-parse", "--short", "HEAD"]);
+}
+
+export function shortSessionId(sessionId) {
+  const value = String(sessionId || "unknown");
+  if (value === "unknown" || value.length <= 8) return value;
+  return value.slice(0, 8);
+}
+
+function runGit(cwd, args) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    windowsHide: true,
+  });
+  if (result.status !== 0) return null;
+  return result.stdout.trim() || null;
+}
+
+function formatOneDecimal(value) {
+  const rounded = Math.round(value * 10) / 10;
+  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+}

package/src/cli/commands/thinking-command.mjs

@@ -0,0 +1,80 @@
+import { formatSelectorList } from "../selector-list.mjs";
+
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+
+export function parseThinkingCommand(input) {
+  if (input !== "/thinking" && !input.startsWith("/thinking ")) {
+    return { type: "none" };
+  }
+  const arg = input.slice("/thinking".length).trim();
+  if (!arg) return { type: "select-interactive" };
+  if (arg === "list") return { type: "list" };
+  const index = Number(arg);
+  if (Number.isInteger(index) && index > 0) return { type: "select", index };
+  if (THINKING_LEVELS.includes(arg)) return { type: "set", level: arg };
+  return {
+    type: "error",
+    message: `Usage: /thinking [list|index|${THINKING_LEVELS.join("|")}]`,
+  };
+}
+
+export function formatThinkingLevels(levels, current) {
+  const available = Array.isArray(levels) && levels.length > 0 ? levels : THINKING_LEVELS;
+  return formatSelectorList({
+    items: available,
+    currentIndex: available.indexOf(current),
+    instruction: "Use /thinking <index> to select.",
+  });
+}
+
+export function buildThinkingSelectItems(levels, current) {
+  const available = Array.isArray(levels) && levels.length > 0 ? levels : THINKING_LEVELS;
+  return available.map((level, index) => ({
+    value: String(index),
+    label: level,
+    description: level === current ? "current" : "",
+    level,
+  }));
+}
+
+export function selectThinkingByIndex(index, { runner }) {
+  const levels = runner.getAvailableThinkingLevels?.() || THINKING_LEVELS;
+  const level = levels[index - 1];
+  if (!level) return `Error: thinking index out of range: ${index}`;
+  return `thinking: ${runner.setThinkingLevel(level)}`;
+}
+
+export async function handleThinkingCommand(parsed, { runner, ui = null } = {}) {
+  if (parsed.type === "select-interactive") {
+    if (ui?.selectList) return [await selectThinkingInteractively({ runner, ui })];
+    return ["Use /thinking list or run in TUI to choose a thinking level."];
+  }
+  if (parsed.type === "list") {
+    return formatThinkingLevels(
+      runner.getAvailableThinkingLevels?.(),
+      runner.getThinkingLevel?.(),
+    );
+  }
+  if (parsed.type === "select") return [selectThinkingByIndex(parsed.index, { runner })];
+  if (parsed.type === "set") {
+    const level = runner.setThinkingLevel(parsed.level);
+    return [`thinking: ${level}`];
+  }
+  if (parsed.type === "error") return [`Error: ${parsed.message}`];
+  return [];
+}
+
+async function selectThinkingInteractively({ runner, ui }) {
+  const levels = runner.getAvailableThinkingLevels?.() || THINKING_LEVELS;
+  if (levels.length === 0) return "thinking: no available levels";
+  const current = runner.getThinkingLevel?.();
+  const selectedIndex = Math.max(0, levels.indexOf(current));
+  const item = await ui.selectList({
+    items: buildThinkingSelectItems(levels, current),
+    selectedIndex,
+    width: 48,
+    suppressInitialConfirm: true,
+  });
+  if (!item) return "thinking: unchanged";
+  return `thinking: ${runner.setThinkingLevel(item.level)}`;
+}

package/src/cli/fallback-ui.mjs

@@ -0,0 +1,156 @@
+import { stdout } from "node:process";
+import { extractToolOutput } from "./tool-output.mjs";
+import { formatMemoryHintLines } from "./tui/recall-rendering.mjs";
+import { formatToolStartLine } from "./tui/tool-rendering.mjs";
+import { brightBlack, dim, red, green, yellow } from "./tui/ui-theme.mjs";
+
+export function createJsonUI() {
+  let thinkingBuf = "";
+  return {
+    readline: () => Promise.resolve(""),
+    write: () => {},
+    writeln: (text) => {
+      stdout.write(text + "\n");
+    },
+    thinkingStart: () => { thinkingBuf = ""; },
+    thinkingDelta: (delta) => { thinkingBuf += delta; },
+    thinkingEnd: (tokens) => {
+      stdout.write(JSON.stringify({ type: "thinking", tokens, content: thinkingBuf }) + "\n");
+      thinkingBuf = "";
+    },
+    thinkingBlock: (tokens, content) => {
+      stdout.write(JSON.stringify({ type: "thinking", tokens, content }) + "\n");
+    },
+    toggleLastThinking: () => {},
+    toolStart: (name, args) => {
+      stdout.write(JSON.stringify({ type: "tool_start", name, args }) + "\n");
+    },
+    toolEnd: (name, isError, result) => {
+      stdout.write(JSON.stringify({ type: "tool_end", name, isError, output: extractToolOutput(result) }) + "\n");
+    },
+    textDelta: (delta) => {
+      stdout.write(delta);
+    },
+    status: () => {},
+    memoryHint: () => {},
+    clearOutput: () => {},
+    restoreTranscript: () => {},
+    setStatusBar: () => {},
+    turnStart: () => {},
+    assistantReplyEnd: () => {},
+    turnEnd: () => {},
+    retryStart: (event) => {
+      stdout.write(JSON.stringify({ type: "retry_start", ...event }) + "\n");
+    },
+    retryEnd: (event) => {
+      stdout.write(JSON.stringify({ type: "retry_end", ...event }) + "\n");
+    },
+    editDiff: (path, diffLines) => {
+      stdout.write(JSON.stringify({ type: "edit_diff", path, diff: diffLines }) + "\n");
+    },
+    requestPermission: async () => true,
+    setEscapeHandler: () => {},
+    setCtrlCHandler: () => {},
+    setShiftTabHandler: () => {},
+    setCtrlTHandler: () => {},
+    setCtrlLHandler: () => {},
+    setPasteImageHandler: () => {},
+    getInputText: () => "",
+    insertTextAtCursor: () => {},
+    openExternalEditor: () => {},
+    toggleMouse: () => false,
+    toggleToolOutput: () => false,
+    requestExit: () => {},
+    close: () => {},
+  };
+}
+
+export function createPlainUI() {
+  let thinkingBuf = "";
+  let needsNewline = false;
+  const writeText = (text) => {
+    stdout.write(text);
+    needsNewline = text.length > 0 && !text.endsWith("\n");
+  };
+  const ensureNewline = () => {
+    if (needsNewline) stdout.write("\n");
+    needsNewline = false;
+  };
+  return {
+    readline: (_prompt) => Promise.resolve(""),
+    write: writeText,
+    writeln: (text) => { stdout.write(text + "\n"); needsNewline = false; },
+    thinkingStart: () => { thinkingBuf = ""; },
+    thinkingDelta: (delta) => { thinkingBuf += delta; },
+    thinkingEnd: (tokens) => {
+      stdout.write(`\n${brightBlack(`--- thinking (${tokens} tokens) ---`)}\n`);
+      stdout.write(`${brightBlack(thinkingBuf)}\n`);
+      stdout.write(`${brightBlack("--- end thinking ---")}\n\n`);
+      thinkingBuf = "";
+      needsNewline = false;
+    },
+    thinkingBlock: (tokens, content) => {
+      stdout.write(`\n${brightBlack(`--- thinking (${tokens} tokens) ---`)}\n`);
+      stdout.write(`${brightBlack(content)}\n`);
+      stdout.write(`${brightBlack("--- end thinking ---")}\n\n`);
+      needsNewline = false;
+    },
+    toggleLastThinking: () => {},
+    toolStart: (name, args) => {
+      stdout.write(`${dim(`  ${formatToolStartLine(name, args)}`)}\n`);
+    },
+    toolEnd: (name, isError, result) => {
+      const out = extractToolOutput(result);
+      if (isError) {
+        stdout.write(`${red(`  ◆ ${name} failed`)}\n`);
+        if (out) stdout.write(`${red(`    ${out.slice(0, 200)}`)}\n`);
+      } else if (out) {
+        stdout.write(`${dim(`    ${out.split("\n")[0].slice(0, 200)}`)}\n`);
+      }
+      needsNewline = false;
+    },
+    textDelta: writeText,
+    status: (text) => { ensureNewline(); stdout.write(`${brightBlack(`● ${text}`)}\n`); },
+    memoryHint: ({ hints }) => {
+      ensureNewline();
+      for (const line of formatMemoryHintLines(hints)) stdout.write(`${brightBlack(line)}\n`);
+    },
+    clearOutput: () => {},
+    restoreTranscript: () => {},
+    setStatusBar: () => {},
+    turnStart: () => {},
+    assistantReplyEnd: ensureNewline,
+    turnEnd: ensureNewline,
+    retryStart: ({ attempt, maxAttempts, delayMs, errorMessage }) => {
+      ensureNewline();
+      stdout.write(`${yellow(`● retrying (${attempt}/${maxAttempts}) in ${Math.ceil(delayMs / 1000)}s: ${errorMessage || "Unknown error"}`)}\n`);
+    },
+    retryEnd: ({ success, attempt, finalError }) => {
+      ensureNewline();
+      const status = success ? "recovered" : "stopped";
+      stdout.write(`${brightBlack(`● retry ${status} after ${attempt} attempt${attempt === 1 ? "" : "s"}${finalError ? `: ${finalError}` : ""}`)}\n`);
+    },
+    editDiff: (path, diffLines) => {
+      stdout.write(`\n${dim(`  ± ${path}`)}\n`);
+      for (const d of diffLines) {
+        if (d.type === "del") stdout.write(`${red(`    - ${d.text}`)}\n`);
+        else if (d.type === "add") stdout.write(`${green(`    + ${d.text}`)}\n`);
+        else stdout.write(`${dim(`      ${d.text}`)}\n`);
+      }
+    },
+    requestPermission: async () => true,
+    setEscapeHandler: () => {},
+    setCtrlCHandler: () => {},
+    setShiftTabHandler: () => {},
+    setCtrlTHandler: () => {},
+    setCtrlLHandler: () => {},
+    setPasteImageHandler: () => {},
+    getInputText: () => "",
+    insertTextAtCursor: () => {},
+    openExternalEditor: () => {},
+    toggleMouse: () => false,
+    toggleToolOutput: () => false,
+    requestExit: () => {},
+    close: () => {},
+  };
+}

package/src/cli/input/attachment-tokens.mjs

@@ -0,0 +1,20 @@
+export function resolveAttachmentTokens(text, tokens) {
+  let resolved = text;
+  for (const [token, marker] of tokens) {
+    resolved = resolved.split(token).join(marker);
+  }
+  return resolved;
+}
+
+export function uniqueAttachmentToken(label, tokens) {
+  if (!tokens.has(label)) return label;
+  for (let i = 2; ; i++) {
+    const candidate = label.replace(/\]$/, ` ${i}]`);
+    if (!tokens.has(candidate)) return candidate;
+  }
+}
+
+export function withLeadingSpace(currentText, text) {
+  if (!String(currentText || "").trim()) return text;
+  return ` ${text}`;
+}