march-cli 0.1.0

package/src/cli/tui/ui-theme.mjs

@@ -0,0 +1,148 @@
+// ── SGR constants ────────────────────────────────────────────────────
+const R = "\x1b[0m";
+const B = "\x1b[1m";
+const D = "\x1b[2m";
+
+// Standard 16 colors
+const black = (s) => `\x1b[30m${s}${R}`;
+const red = (s) => `\x1b[31m${s}${R}`;
+const green = (s) => `\x1b[32m${s}${R}`;
+const yellow = (s) => `\x1b[33m${s}${R}`;
+const blue = (s) => `\x1b[34m${s}${R}`;
+const magenta = (s) => `\x1b[35m${s}${R}`;
+const cyan = (s) => `\x1b[36m${s}${R}`;
+const white = (s) => `\x1b[37m${s}${R}`;
+const brightBlack = (s) => `\x1b[90m${s}${R}`;
+const brightRed = (s) => `\x1b[91m${s}${R}`;
+const brightGreen = (s) => `\x1b[92m${s}${R}`;
+const orange = (s) => `\x1b[38;2;245;167;66m${s}${R}`;
+const softGreen = (s) => `\x1b[38;2;127;216;143m${s}${R}`;
+
+// ── Formatters ───────────────────────────────────────────────────────
+const bold = (s) => `${B}${s}${R}`;
+const dim = (s) => `${D}${s}${R}`;
+const inverse = (s) => `\x1b[7m${s}${R}`;
+
+// ── 256-color helpers ────────────────────────────────────────────────
+const fg256 = (n) => (s) => `\x1b[38;5;${n}m${s}${R}`;
+const bg256 = (n) => (s) => `\x1b[48;5;${n}m${s}${R}`;
+
+// ── Semantic tokens ──────────────────────────────────────────────────
+const text = {
+  primary: white,
+  secondary: (s) => fg256(250)(s),   // light gray
+  muted: brightBlack,
+  inverse: black,
+};
+
+const surface = {
+  base: (s) => s,                     // default terminal bg
+  raised: bg256(236),                 // dark gray bg
+  overlay: bg256(238),
+};
+
+const accent = {
+  primary: cyan,
+  success: green,
+  error: red,
+  warning: yellow,
+  info: blue,
+};
+
+const border = {
+  default: brightBlack,
+  focus: cyan,
+};
+
+// ── Component tokens ─────────────────────────────────────────────────
+const diff = {
+  add: green,
+  del: red,
+  ctx: brightBlack,
+  header: bold,
+  gutter: brightBlack,
+};
+
+const tool = {
+  name: brightBlack,
+  args: brightBlack,
+  result: dim,
+  error: red,
+  expand: brightBlack,
+};
+
+const message = {
+  user: bold,
+  assistant: (s) => s,
+  system: brightBlack,
+  separator: brightBlack,
+};
+
+const statusBar = {
+  background: bg256(236),
+  text: fg256(250),
+  accent: cyan,
+};
+
+const shell = {
+  header: bold,
+  divider: fg256(238),
+  prompt: green,
+  scrollInfo: brightBlack,
+};
+
+const spinner = {
+  frame: cyan,
+};
+
+const selectList = {
+  selectedPrefix: cyan,
+  selectedText: white,
+  description: brightBlack,
+  scrollInfo: brightBlack,
+  noMatch: brightBlack,
+};
+
+// ── Editor theme (consumed by pi-tui Editor component) ──────────────
+const EDITOR_THEME = {
+  borderColor: border.default,
+  selectList,
+};
+
+// ── Raw ANSI prefixes (for template literal composition) ─────────────
+const PREFIX = {
+  reset: R,
+  bold: B,
+  dim: D,
+  fg250: "\x1b[38;5;250m",   // header / secondary text
+  fg238: "\x1b[38;5;238m",   // border / divider
+  brightBlack: "\x1b[90m",    // muted text
+  cyan: "\x1b[36m",           // active / accent
+};
+
+// ── Public API ───────────────────────────────────────────────────────
+export {
+  PREFIX,
+  // SGR primitives
+  R, B, D,
+  black, red, green, yellow, blue, magenta, cyan, white,
+  brightBlack, brightRed, brightGreen,
+  orange, softGreen,
+  bold, dim, inverse,
+  fg256, bg256,
+  // Semantic
+  text,
+  surface,
+  accent,
+  border,
+  // Components
+  diff,
+  tool,
+  message,
+  statusBar,
+  shell,
+  spinner,
+  selectList,
+  // Editor
+  EDITOR_THEME,
+};

package/src/cli/ui.mjs

@@ -0,0 +1,299 @@
+import { stdout } from "node:process";
+import { Editor, ProcessTerminal, TUI } from "@earendil-works/pi-tui";
+import { writeSystemClipboardAsync } from "./commands/copy-command.mjs";
+import { buildMarchCommands, MarchAutocompleteProvider } from "./input/autocomplete.mjs";
+import { createJsonUI, createPlainUI } from "./fallback-ui.mjs";
+import { createKeybindingDispatcher } from "./input/keybinding-dispatch.mjs";
+import { OutputBuffer } from "./tui/output-buffer.mjs";
+import { requestToolPermission } from "./tui/permission-request-ui.mjs";
+import { runTuiExternalEditor } from "./tui/editor/external-editor-runner.mjs";
+import { createRetryStatusController } from "./tui/status/retry-status.mjs";
+import { createShellDrawerControls } from "./shell/shell-drawer-controls.mjs";
+import { ShellDrawer } from "./shell/shell-drawer.mjs";
+import { ShellSplitLayout } from "./shell/shell-split-layout.mjs";
+import { createSpinnerStatusController } from "./tui/status/spinner-status.mjs";
+import { showEditorSelectList } from "./tui/select/editor-select-list.mjs";
+import { StatusBar } from "./tui/status/status-bar.mjs";
+import { MainPaneLayout } from "./tui/layout/main-pane-layout.mjs";
+import { SafeRenderBoundary } from "./tui/layout/safe-render-boundary.mjs";
+import { createMouseSelectionController } from "./tui/input/mouse-selection-controller.mjs";
+import { ScreenSelection } from "./tui/selection-screen.mjs";
+import { writeEditDiff } from "./tui/tui-diff-rendering.mjs";
+import { createTuiInputController } from "./tui/tui-input-controller.mjs";
+import { writeMemoryHint } from "./tui/recall-rendering.mjs";
+import { writeToolEnd, writeToolStart } from "./tui/tool-rendering.mjs";
+import { EDITOR_THEME, brightBlack } from "./tui/ui-theme.mjs";
+import { writeTranscriptToOutput } from "../session/transcript.mjs";
+
+export { buildMarchCommands, MarchAutocompleteProvider } from "./input/autocomplete.mjs";
+
+export function createTuiUI({
+  cwd = process.cwd(),
+  keybindings,
+  promptTemplates = [],
+  shellRuntime = null,
+  historyStore = null,
+  terminal = new ProcessTerminal(),
+  writeClipboard = writeSystemClipboardAsync,
+} = {}) {
+  const tui = new TUI(terminal);
+  const output = new OutputBuffer();
+  const shellDrawer = new ShellDrawer({ shellRuntime });
+  const statusBar = new StatusBar();
+  const editor = new Editor(tui, EDITOR_THEME, { paddingX: 1 });
+  const selection = new ScreenSelection();
+  const mainPane = new MainPaneLayout({ output, statusBar, editor, terminal, selection });
+  const shellSplitLayout = new ShellSplitLayout({
+    mainChildren: [mainPane],
+    shellPane: shellDrawer,
+    selection,
+  });
+  const autocomplete = new MarchAutocompleteProvider(buildMarchCommands(promptTemplates), cwd);
+  editor.setAutocompleteProvider(autocomplete);
+  editor.history = historyStore?.load?.() ?? [];
+
+  tui.addChild(new SafeRenderBoundary(shellSplitLayout));
+  tui.setFocus(editor);
+
+  let started = false;
+  let mouseOn = true;
+  let toolsExpanded = false;
+  const activeToolBlocks = [];
+
+  function requestRender() {
+    tui.requestRender();
+  }
+
+  const spinnerStatus = createSpinnerStatusController({ output, requestRender });
+  const retryStatus = createRetryStatusController({ output, requestRender, stopSpinner: spinnerStatus.stop });
+  const shellDrawerControls = createShellDrawerControls({ shellDrawer, output, requestRender });
+  const mouseSelectionController = createMouseSelectionController({ terminal, output, shellDrawer, shellDrawerControls, selection, writeClipboard, requestRender });
+
+  let onEscapeHandler = null, onCtrlCHandler = null, onShiftTabHandler = null;
+  let onCtrlTHandler = null, onCtrlLHandler = null, onPasteImageHandler = null, onToggleModeHandler = null;
+  const keybindingDispatcher = createKeybindingDispatcher({
+    keybindings,
+    handlers: {
+      abort: () => onEscapeHandler?.(),
+      interrupt: () => onCtrlCHandler?.(),
+      toggleMode: () => onToggleModeHandler?.(),
+      cycleThinking: () => onShiftTabHandler?.(),
+      thinkingSelector: () => onCtrlTHandler?.(),
+      modelSelector: () => onCtrlLHandler?.(),
+      externalEditor: () => openExternalEditor(),
+      toggleToolOutput: () => toggleToolOutput(),
+      toggleShellDrawer: () => shellDrawerControls.toggle(),
+      nextShell: () => shellDrawerControls.selectNext(),
+      shellScrollUp: () => shellDrawerControls.scroll(-1),
+      shellScrollDown: () => shellDrawerControls.scroll(1),
+      outputScrollUp: () => { output.scroll(-1); requestRender(); },
+      outputScrollDown: () => { output.scroll(1); requestRender(); },
+      pasteImage: () => onPasteImageHandler?.(),
+    },
+    isAutocompleteOpen: () => editor.isShowingAutocomplete(),
+    hasOverlay: () => tui.hasOverlay(),
+  });
+
+  function ensureStarted() {
+    if (!started) {
+      tui.addInputListener((data) => {
+        const mouseResult = mouseSelectionController.handleMouseInput(data, mouseOn);
+        if (mouseResult) return mouseResult;
+        const copyKeyResult = mouseSelectionController.handleCopyKey(data);
+        if (copyKeyResult) return copyKeyResult;
+        const dispatched = keybindingDispatcher.dispatch(data);
+        if (dispatched) return dispatched;
+        // When output is scrolled up, the next render has fewer lines.
+        // On new input, reset scroll to tail so the editor stays at bottom.
+        if (output.scrollOffset > 0) {
+          output.resetScroll();
+          requestRender();
+        }
+        if (shellDrawer.isInputActive()) {
+          shellDrawer.sendInput(data);
+          requestRender();
+          return { consume: true };
+        }
+      });
+      terminal.write("\x1b[?1049h");
+      terminal.write("\x1b[?1002h\x1b[?1006h");
+      tui.start();
+      started = true;
+    }
+  }
+
+  function openExternalEditor() {
+    runTuiExternalEditor({ terminal, tui, editor, output, requestRender, mouseOn: () => mouseOn });
+  }
+
+  function toggleToolOutput() {
+    toolsExpanded = !toolsExpanded;
+    output.setToolCardsExpanded(toolsExpanded);
+    output.writeln(brightBlack(`● tool output: ${toolsExpanded ? "expanded" : "collapsed"}`));
+    requestRender();
+    return toolsExpanded;
+  }
+
+  function selectList({ items, selectedIndex = 0, maxVisible = 8, ...options }) {
+    ensureStarted();
+    return showEditorSelectList({ tui, editor, items, selectedIndex, maxVisible, requestRender, ...options });
+  }
+
+  function retryStart({ attempt, maxAttempts, delayMs, errorMessage }) {
+    ensureStarted();
+    retryStatus.start({ attempt, maxAttempts, delayMs, errorMessage });
+  }
+
+  function retryEnd({ success, attempt, finalError }) {
+    ensureStarted();
+    retryStatus.end({ success, attempt, finalError });
+  }
+
+  const inputController = createTuiInputController({ editor, requestRender, historyStore });
+
+  return {
+    readline: (_prompt) => {
+      ensureStarted();
+      return inputController.readline();
+    },
+    write: (text) => {
+      ensureStarted();
+      output.write(text);
+      requestRender();
+    },
+    writeln: (text) => {
+      ensureStarted();
+      output.writeln(text);
+      requestRender();
+    },
+    thinkingStart: () => {
+      retryStatus.stop(); output.startThinking(); requestRender();
+    },
+
+    thinkingDelta: (delta) => {
+      output.appendThinking(delta);
+      requestRender();
+    },
+
+    thinkingEnd: (tokens) => {
+      output.endThinking(tokens);
+      requestRender();
+    },
+
+    thinkingBlock: (tokens, content) => {
+      retryStatus.stop(); output.addThinkingBlock(tokens, content); requestRender();
+    },
+
+    toggleLastThinking: () => false,
+
+    toolStart: (name, args) => {
+      ensureStarted(); retryStatus.stop(); spinnerStatus.stop(); activeToolBlocks.push(writeToolStart({ output, name, args })); requestRender();
+    },
+
+    toolEnd: (name, isError, result) => {
+      if (writeToolEnd({ output, name, isError, result, toolsExpanded, toolBlock: activeToolBlocks.pop() })) requestRender();
+    },
+
+    textDelta: (delta) => {
+      ensureStarted(); retryStatus.stop(); spinnerStatus.stop();
+      output.writeMarkdown(delta);
+      requestRender();
+    },
+    assistantReplyEnd: () => {
+      ensureStarted();
+      const changed = output.ensureNewline();
+      if (output.sealCurrentText() || changed) requestRender();
+    },
+    status: (text) => {
+      ensureStarted(); retryStatus.stop(); spinnerStatus.stop(); output.setOverlayStatus([brightBlack(`● ${text}`)]); requestRender();
+    },
+    memoryHint: ({ hints }) => {
+      ensureStarted(); retryStatus.stop(); spinnerStatus.stop(); output.ensureNewline(); writeMemoryHint({ output, hints }); requestRender();
+    },
+
+    clearOutput: () => {
+      ensureStarted(); spinnerStatus.stop(); retryStatus.stop(); output.clear(); requestRender();
+    },
+
+    restoreTranscript: (turns) => {
+      ensureStarted(); spinnerStatus.stop(); retryStatus.stop(); output.clear();
+      writeTranscriptToOutput(output, turns);
+      requestRender();
+    },
+
+    setStatusBar: (text) => {
+      if (statusBar.setText(text)) requestRender();
+    },
+
+    turnStart: () => {
+      ensureStarted();
+    },
+
+    turnEnd: () => {
+      const changed = output.ensureNewline();
+      if (output.sealCurrentText() || changed) requestRender();
+    },
+
+    retryStart,
+    retryEnd,
+
+    editDiff: (path, diffLines) => {
+      ensureStarted();
+      spinnerStatus.stop();
+      writeEditDiff({ output, path, diffLines });
+      requestRender();
+    },
+
+    toggleMouse: () => {
+      if (mouseOn) {
+        terminal.write("\x1b[?1002l\x1b[?1006l");
+        mouseOn = false;
+        return false;
+      } else {
+        terminal.write("\x1b[?1002h\x1b[?1006h");
+        mouseOn = true;
+        return true;
+      }
+    },
+
+    requestPermission: async ({ toolName, params, category }) => {
+      ensureStarted();
+      spinnerStatus.stop();
+      return requestToolPermission({ toolName, params, category, output, selectList, requestRender });
+    },
+
+    setEscapeHandler: (fn) => { onEscapeHandler = fn; },
+    setCtrlCHandler: (fn) => { onCtrlCHandler = fn; },
+    setShiftTabHandler: (fn) => { onShiftTabHandler = fn; },
+    setCtrlTHandler: (fn) => { onCtrlTHandler = fn; },
+    setCtrlLHandler: (fn) => { onCtrlLHandler = fn; },
+    setPasteImageHandler: (fn) => { onPasteImageHandler = fn; },
+    setToggleModeHandler: (fn) => { onToggleModeHandler = fn; },
+
+    selectList,
+    getInputText: () => inputController.getInputText(),
+    insertTextAtCursor: (text) => inputController.insertTextAtCursor(text),
+    insertAttachmentAtCursor: (attachment) => inputController.insertAttachmentAtCursor(attachment),
+    openExternalEditor: () => { openExternalEditor(); },
+    toggleToolOutput,
+    toggleShellDrawer: () => shellDrawerControls.toggle(),
+    requestExit: () => inputController.requestExit(),
+
+    close: async () => {
+      spinnerStatus.stop();
+      retryStatus.stop();
+      if (started) {
+        await terminal.drainInput?.();
+        if (mouseOn) terminal.write("\x1b[?1002l\x1b[?1006l");
+        tui.stop();
+        terminal.write("\x1b[?1049l");
+      }
+    },
+  };
+}
+
+export function createUI({ json, cwd = process.cwd(), keybindings, promptTemplates = [], shellRuntime = null, historyStore = null } = {}) {
+  if (json) return createJsonUI();
+  if (!stdout.isTTY) return createPlainUI();
+  return createTuiUI({ cwd, keybindings, promptTemplates, shellRuntime, historyStore });
+}

package/src/config/config-json.mjs

@@ -0,0 +1,73 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export function globalConfigJsonPath(homeDir = homedir()) {
+  return join(homeDir, ".march", "config.json");
+}
+
+export function readConfigJson(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+export function writeConfigJson(path, data) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+export function upsertProviderProfile({ path = globalConfigJsonPath(), id, type, auth }) {
+  const config = readConfigJson(path);
+  const providers = config.providers && typeof config.providers === "object" && !Array.isArray(config.providers)
+    ? config.providers
+    : {};
+  providers[id] = {
+    ...(providers[id] ?? {}),
+    type,
+    auth,
+  };
+  config.providers = providers;
+  delete config.provider;
+  delete config.model;
+  writeConfigJson(path, config);
+  return config;
+}
+
+export function upsertModelSelection({ path = globalConfigJsonPath(), provider, model, serviceTier }) {
+  const config = readConfigJson(path);
+  config.provider = provider;
+  config.model = model;
+  if (serviceTier) {
+    config.serviceTier = serviceTier;
+  } else {
+    delete config.serviceTier;
+  }
+  writeConfigJson(path, config);
+  return config;
+}
+
+export function upsertWebSearchProvider({ path = globalConfigJsonPath(), id, apiKey }) {
+  const config = readConfigJson(path);
+  const webSearch = config.webSearch && typeof config.webSearch === "object" && !Array.isArray(config.webSearch)
+    ? config.webSearch
+    : {};
+  const providers = webSearch.providers && typeof webSearch.providers === "object" && !Array.isArray(webSearch.providers)
+    ? webSearch.providers
+    : {};
+  providers[id] = {
+    ...(providers[id] ?? {}),
+    apiKey,
+  };
+  config.webSearch = {
+    ...webSearch,
+    provider: id,
+    providers,
+  };
+  writeConfigJson(path, config);
+  return config;
+}

package/src/config/dotenv.mjs

@@ -0,0 +1,20 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function loadDotEnv(cwd, { homeDir = homedir(), sourceDir = dirname(dirname(fileURLToPath(import.meta.url))) } = {}) {
+  for (const dir of [cwd, join(homeDir, ".march"), sourceDir]) {
+    const path = join(dir, ".env");
+    if (!existsSync(path)) continue;
+    for (const line of readFileSync(path, "utf-8").split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq < 1) continue;
+      const key = trimmed.slice(0, eq).trim();
+      const val = trimmed.slice(eq + 1).trim();
+      if (!process.env[key]) process.env[key] = val;
+    }
+  }
+}

package/src/config/features.mjs

@@ -0,0 +1,75 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const DEFAULTS = Object.freeze({
+  "experimental.mcp": true,
+  "experimental.web_search": true,
+  "experimental.web_fetch": true,
+  "experimental.shell": true,
+  "experimental.permissions": true,
+  "ui.markdown_rendering": false,
+  "ui.tool_expand_per_card": false,
+  "agent.plan_mode": false,
+  "agent.sub_agents": false,
+  "agent.background_tasks": false,
+  "agent.auto_retry": true,
+});
+
+/**
+ * Load feature flags from ~/.march/features.toml.
+ * Returns a frozen object with all known flags resolved to booleans.
+ * Unknown keys in the file are ignored.
+ *
+ * TOML format (subset):
+ *   # comment
+ *   [section]
+ *   key = true
+ *   key = false
+ */
+export function loadFeatureFlags({
+  homeDir = homedir(),
+  readFileSyncImpl = readFileSync,
+  existsSyncImpl = existsSync,
+} = {}) {
+  const path = join(homeDir, ".march", "features.toml");
+  const overrides = loadToml(path, { readFileSyncImpl, existsSyncImpl });
+  const resolved = { ...DEFAULTS };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (key in resolved) resolved[key] = Boolean(value);
+  }
+  return Object.freeze(resolved);
+}
+
+export function isEnabled(flags, flag) {
+  return Boolean(flags?.[flag]);
+}
+
+// ── Minimal TOML subset parser (sections, booleans, comments) ──
+function loadToml(path, { readFileSyncImpl, existsSyncImpl }) {
+  if (!existsSyncImpl(path)) return {};
+  const src = readFileSyncImpl(path, "utf8");
+  const result = {};
+  let section = "";
+  for (const raw of src.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+
+    // [section]
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      section = sectionMatch[1].trim() + ".";
+      continue;
+    }
+
+    // key = value
+    const eq = line.indexOf("=");
+    if (eq < 1) continue;
+    const key = (section + line.slice(0, eq).trim());
+    const value = line.slice(eq + 1).trim();
+    if (value === "true") result[key] = true;
+    else if (value === "false") result[key] = false;
+    // ignore non-boolean values
+  }
+  return result;
+}