march-cli 0.1.0

package/src/cli/tui/status/retry-status.mjs

@@ -0,0 +1,72 @@
+import { yellow, brightBlack, red } from "../ui-theme.mjs";
+
+export function formatRetryWaitMessage({ attempt, maxAttempts, remainingMs }) {
+  const seconds = Math.ceil(Math.max(0, remainingMs) / 1000);
+  return `Retrying (${attempt}/${maxAttempts}) in ${seconds}s... Esc to cancel`;
+}
+
+export function formatRetryStartLine(errorMessage) {
+  return yellow(`● retrying after error: ${String(errorMessage || "Unknown error").slice(0, 160)}`);
+}
+
+export function formatRetryEndLine({ success, attempt, finalError }) {
+  const attempts = `after ${attempt} attempt${attempt === 1 ? "" : "s"}`;
+  if (success) return brightBlack(`● retry recovered ${attempts}`);
+  return red(`● retry stopped ${attempts}${finalError ? `: ${finalError}` : ""}`);
+}
+
+export function createRetryStatusController({
+  output,
+  requestRender,
+  stopSpinner,
+  setIntervalImpl = setInterval,
+  clearIntervalImpl = clearInterval,
+  now = () => Date.now(),
+}) {
+  let retryTimer = null;
+  let retrySpinnerActive = false;
+
+  function stop() {
+    if (retryTimer) {
+      clearIntervalImpl(retryTimer);
+      retryTimer = null;
+    }
+    if (retrySpinnerActive) {
+      output.setSpinner(false, "");
+      retrySpinnerActive = false;
+    }
+  }
+
+  function start({ attempt, maxAttempts, delayMs, errorMessage }) {
+    stopSpinner();
+    stop();
+    const startedAt = now();
+    const message = () => formatRetryWaitMessage({
+      attempt,
+      maxAttempts,
+      remainingMs: delayMs - (now() - startedAt),
+    });
+    writeStatusLine(output, formatRetryStartLine(errorMessage));
+    output.setSpinner(true, message());
+    retrySpinnerActive = true;
+    retryTimer = setIntervalImpl(() => {
+      output.setSpinner(true, message());
+      output.tick();
+      requestRender();
+    }, 250);
+    requestRender();
+  }
+
+  function end({ success, attempt, finalError }) {
+    stop();
+    writeStatusLine(output, formatRetryEndLine({ success, attempt, finalError }));
+    requestRender();
+  }
+
+  return { start, end, stop };
+}
+
+function writeStatusLine(output, line) {
+  if (typeof output.setOverlayStatus === "function") output.setOverlayStatus([line]);
+  else output.writeln(line);
+}

package/src/cli/tui/status/spinner-status.mjs

@@ -0,0 +1,42 @@
+const DEFAULT_SPINNER_INTERVAL = 80;
+
+export function createSpinnerStatusController({
+  output,
+  requestRender,
+  intervalMs = DEFAULT_SPINNER_INTERVAL,
+  setIntervalImpl = setInterval,
+  clearIntervalImpl = clearInterval,
+} = {}) {
+  let timer = null;
+  let spinning = false;
+
+  function start(text) {
+    spinning = true;
+    output.setSpinner(true, text);
+    if (!timer) {
+      timer = setIntervalImpl(() => {
+        output.tick();
+        requestRender();
+      }, intervalMs);
+    }
+    requestRender();
+  }
+
+  function stop() {
+    if (!spinning && !timer) return false;
+    if (timer) {
+      clearIntervalImpl(timer);
+      timer = null;
+    }
+    spinning = false;
+    output.setSpinner(false, "");
+    requestRender();
+    return true;
+  }
+
+  return {
+    start,
+    stop,
+    isRunning: () => spinning,
+  };
+}

package/src/cli/tui/status/status-bar.mjs

@@ -0,0 +1,88 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { statusBar, R } from "../ui-theme.mjs";
+
+const ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+const DEFAULT_STATUS_TEXT = "March";
+
+export class StatusBar {
+  constructor(text = DEFAULT_STATUS_TEXT) {
+    this.text = normalizeStatusText(text);
+  }
+
+  setText(text) {
+    const next = normalizeStatusText(text);
+    if (next === this.text) return false;
+    this.text = next;
+    return true;
+  }
+
+  invalidate() {}
+
+  render(width) {
+    if (width <= 0) return [""];
+    const text = fitStatusText(this.text, width);
+    const padded = padToWidth(text, width);
+    // If text already has ANSI coloring, only apply background
+    if (hasAnsi(padded)) {
+      return [statusBar.background(`${padded}${R}`)];
+    }
+    return [statusBar.background(statusBar.text(padded))];
+  }
+}
+
+function hasAnsi(text) {
+  return ANSI_RE.test(text);
+}
+
+export function normalizeStatusText(text) {
+  const normalized = String(text || DEFAULT_STATUS_TEXT).replace(/\s+/g, " ").trim();
+  return normalized || DEFAULT_STATUS_TEXT;
+}
+
+export function padToWidth(text, width) {
+  const plainWidth = visibleWidth(stripAnsi(text));
+  const padding = Math.max(0, width - plainWidth);
+  return text + " ".repeat(padding);
+}
+
+export function fitStatusText(text, width) {
+  const normalized = normalizeStatusText(text);
+  if (visibleWidth(stripAnsi(normalized)) <= width) return normalized;
+
+  const segments = normalized.split(" | ");
+  if (segments.length < 2) return clipToWidth(normalized, width);
+
+  const tail = segments.at(-1);
+  const separator = " | ";
+  const tailWidth = visibleWidth(stripAnsi(tail));
+  const separatorWidth = visibleWidth(separator);
+  if (tailWidth + separatorWidth >= width) return clipToWidth(tail, width);
+
+  const headWidth = width - tailWidth - separatorWidth;
+  const head = clipToWidth(segments.slice(0, -1).join(separator), headWidth);
+  return `${head}${separator}${tail}`;
+}
+
+export function clipToWidth(text, width) {
+  // For ANSI-containing text, build output character by character and measure plain width
+  let output = "";
+  let plainWidth = 0;
+  let inAnsi = false;
+  for (const ch of Array.from(String(text || ""))) {
+    if (ch === "\x1b") inAnsi = true;
+    if (inAnsi) {
+      output += ch;
+      if (/[@-~]/.test(ch)) inAnsi = false;
+      continue;
+    }
+    const charWidth = visibleWidth(ch);
+    if (plainWidth + charWidth > width) break;
+    output += ch;
+    plainWidth += charWidth;
+  }
+  return output;
+}
+
+function stripAnsi(text) {
+  return String(text ?? "").replace(ANSI_RE, "");
+}

package/src/cli/tui/syntax/highlighting.mjs

@@ -0,0 +1,277 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Language, Parser, Query } from "web-tree-sitter";
+import { R } from "../ui-theme.mjs";
+import {
+  CONSTANTS,
+  KEYWORDS,
+  LANG_ALIASES,
+  LANGUAGES,
+  NUMBER_TYPES,
+  OPERATORS,
+  PROPERTY_TYPES,
+  PUNCTUATION,
+  SCOPE_PRIORITY,
+  SCOPE_STYLE,
+  STRING_TYPES,
+  TYPE_TYPES,
+} from "./languages.mjs";
+
+const RESOURCE_DIR = join(dirname(fileURLToPath(import.meta.url)), "tree-sitter");
+const ENCODER = new TextEncoder();
+
+let initPromise;
+let initialized = false;
+const parsers = new Map();
+const queries = new Map();
+const highlightCache = new Map();
+
+export function initializeTreeSitterHighlighting() {
+  if (initPromise) return initPromise;
+  initPromise = initializeParsers();
+  return initPromise;
+}
+
+export function isTreeSitterHighlightingReady() {
+  return initialized;
+}
+
+export function normalizeLanguage(langOrPath = "") {
+  const raw = String(langOrPath ?? "").trim().toLowerCase();
+  if (!raw) return "";
+  const direct = LANG_ALIASES.get(raw);
+  if (direct) return direct;
+  const ext = raw.match(/\.([a-z0-9]+)$/)?.[1];
+  return ext ? (LANG_ALIASES.get(ext) ?? "") : "";
+}
+
+export function highlightCodeLines(code, langOrPath = "", options = {}) {
+  const text = String(code ?? "");
+  const lang = normalizeLanguage(langOrPath);
+  const key = `${lang}\0${options.bg ?? ""}\0${text}`;
+  const cached = highlightCache.get(key);
+  if (cached) return cached;
+
+  const runs = treeSitterRuns(text, lang) ?? fallbackRuns(text, lang);
+  const rendered = renderRunsByLine(text, runs, options);
+  if (highlightCache.size > 200) highlightCache.clear();
+  highlightCache.set(key, rendered);
+  return rendered;
+}
+
+export function highlightCodeLine(line, langOrPath = "", options = {}) {
+  return highlightCodeLines(String(line ?? ""), langOrPath, options)[0] ?? "";
+}
+
+async function initializeParsers() {
+  try {
+    await Parser.init();
+    for (const [lang, config] of Object.entries(LANGUAGES)) {
+      const language = await Language.load(join(RESOURCE_DIR, config.file));
+      const parser = new Parser();
+      parser.setLanguage(language);
+      parsers.set(lang, parser);
+      const query = loadHighlightQuery(language, config.query);
+      if (query) queries.set(lang, query);
+    }
+    initialized = true;
+    highlightCache.clear();
+  } catch {
+    initialized = false;
+  }
+}
+
+function treeSitterRuns(text, lang) {
+  const parser = parsers.get(lang);
+  if (!initialized || !parser || !text) return null;
+  try {
+    const tree = parser.parse(text);
+    const byteToIndex = buildByteToIndex(text);
+    const scopes = Array.from({ length: text.length }, () => ({ scope: "default", priority: 0 }));
+    const query = queries.get(lang);
+    if (query) applyQueryScopes(query, tree.rootNode, byteToIndex, scopes);
+    collectNodeScopes(tree.rootNode, byteToIndex, scopes);
+    return scopesToRuns(text, scopes);
+  } catch {
+    return null;
+  }
+}
+
+function loadHighlightQuery(language, queryFile) {
+  if (!queryFile) return null;
+  const path = join(RESOURCE_DIR, queryFile);
+  if (!existsSync(path)) return null;
+  try {
+    return new Query(language, readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function applyQueryScopes(query, rootNode, byteToIndex, scopes) {
+  for (const capture of query.captures(rootNode)) {
+    const scope = captureScope(capture.name);
+    if (!scope) continue;
+    applyScope(scopes, byteToIndex[capture.node.startIndex] ?? 0, byteToIndex[capture.node.endIndex] ?? scopes.length, scope);
+  }
+}
+
+function captureScope(name) {
+  const value = String(name ?? "").toLowerCase();
+  if (!value) return null;
+  if (value.includes("comment")) return "comment";
+  if (value.includes("string") || value.includes("escape") || value.includes("regex")) return "string";
+  if (value.includes("number") || value.includes("float") || value.includes("boolean") || value.includes("constant")) return "constant";
+  if (value.includes("keyword") || value.includes("conditional") || value.includes("repeat") || value.includes("include")) return "keyword";
+  if (value.includes("function") || value.includes("method") || value.includes("constructor")) return "function";
+  if (value.includes("type") || value.includes("class") || value.includes("namespace") || value.includes("module")) return "type";
+  if (value.includes("property") || value.includes("field")) return "property";
+  if (value.includes("attribute") || value.includes("annotation")) return "attribute";
+  if (value.includes("operator")) return "operator";
+  if (value.includes("punctuation") || value.includes("delimiter") || value.includes("bracket")) return "punctuation";
+  if (value.includes("tag")) return "tag";
+  if (value.includes("variable") || value.includes("parameter")) return "variable";
+  return null;
+}
+
+function collectNodeScopes(node, byteToIndex, scopes) {
+  const scope = classifyNode(node);
+  if (scope) applyScope(scopes, byteToIndex[node.startIndex] ?? 0, byteToIndex[node.endIndex] ?? scopes.length, scope);
+  for (const child of node.children ?? []) collectNodeScopes(child, byteToIndex, scopes);
+}
+
+function classifyNode(node) {
+  const type = node.type;
+  if (type === "comment") return "comment";
+  if (STRING_TYPES.has(type)) return "string";
+  if (type === "raw_string_literal" || type === "interpreted_string_literal" || type === "char_literal") return "string";
+  if (NUMBER_TYPES.has(type)) return "number";
+  if (type === "integer_literal" || type === "float_literal" || type === "decimal_integer_literal") return "number";
+  if (TYPE_TYPES.has(type)) return "type";
+  if (type === "type_identifier" || type === "scoped_type_identifier") return "type";
+  if (PROPERTY_TYPES.has(type)) return "property";
+  if (type === "field_identifier" || type === "property_name") return "property";
+  if (type === "tag_name") return "tag";
+  if (type === "attribute_name") return "attribute";
+  if (type === "regex_pattern") return "string";
+  if (type === "identifier") return classifyIdentifier(node);
+  if (type === "jsx_identifier") return "type";
+  if (type === "null" || type === "true" || type === "false") return "constant";
+  if (!node.isNamed) {
+    if (KEYWORDS.has(type)) return "keyword";
+    if (CONSTANTS.has(type)) return "constant";
+    if (OPERATORS.has(type)) return "operator";
+    if (PUNCTUATION.has(type)) return "punctuation";
+  }
+  return null;
+}
+
+function classifyIdentifier(node) {
+  const text = node.text;
+  if (KEYWORDS.has(text)) return "keyword";
+  if (CONSTANTS.has(text)) return "constant";
+
+  const parent = node.parent;
+  const field = childFieldName(parent, node);
+  if (field === "name" && /function|method|declaration/.test(parent?.type ?? "")) return "function";
+  if (field === "name" && /class|interface|type_alias|enum/.test(parent?.type ?? "")) return "type";
+  if (field === "function" && parent?.type === "call_expression") return "function";
+  if (field === "property") return "property";
+  if (parent?.type === "member_expression" || parent?.type === "subscript_expression") return "property";
+  if (/type|heritage|implements/.test(parent?.type ?? "")) return "type";
+  return "variable";
+}
+
+function childFieldName(parent, child) {
+  if (!parent) return "";
+  const children = parent.children ?? [];
+  for (let i = 0; i < children.length; i++) {
+    if (children[i].equals?.(child)) return parent.fieldNameForChild(i) ?? "";
+  }
+  return "";
+}
+
+function applyScope(scopes, start, end, scope) {
+  const priority = SCOPE_PRIORITY[scope] ?? 0;
+  for (let i = Math.max(0, start); i < Math.min(scopes.length, end); i++) {
+    if (priority >= scopes[i].priority) scopes[i] = { scope, priority };
+  }
+}
+
+function scopesToRuns(text, scopes) {
+  const runs = [];
+  for (let i = 0; i < text.length;) {
+    const scope = scopes[i]?.scope ?? "default";
+    let end = i + 1;
+    while (end < text.length && (scopes[end]?.scope ?? "default") === scope) end++;
+    runs.push({ text: text.slice(i, end), scope });
+    i = end;
+  }
+  return runs;
+}
+
+function fallbackRuns(text, lang) {
+  const pattern = fallbackPattern(lang);
+  if (!pattern) return [{ text, scope: "default" }];
+  const runs = [];
+  let index = 0;
+  for (const match of text.matchAll(pattern)) {
+    if (match.index > index) runs.push({ text: text.slice(index, match.index), scope: "default" });
+    runs.push({ text: match[0], scope: fallbackScope(match[0]) });
+    index = match.index + match[0].length;
+  }
+  if (index < text.length) runs.push({ text: text.slice(index), scope: "default" });
+  return runs;
+}
+
+function fallbackPattern(lang) {
+  if (["javascript", "typescript", "jsx", "tsx"].includes(lang)) {
+    return /\/\/.*|\/\*[\s\S]*?\*\/|"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|`(?:\\.|[^`])*`|\b(?:async|await|break|case|catch|class|const|continue|default|else|export|for|from|function|if|import|interface|let|new|null|return|throw|try|type|undefined|while)\b|\b\d+(?:\.\d+)?\b/g;
+  }
+  if (lang === "json") return /"(?:\\.|[^"])*"|\b(?:true|false|null)\b|\b\d+(?:\.\d+)?\b/g;
+  return /#.*|"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|\b(?:cd|cp|echo|exit|git|grep|ls|mkdir|mv|npm|node|pnpm|rm|yarn)\b|\b\d+(?:\.\d+)?\b/g;
+}
+
+function fallbackScope(token) {
+  if (token.startsWith("//") || token.startsWith("#") || token.startsWith("/*")) return "comment";
+  if (/^["'`]/.test(token)) return "string";
+  if (/^\d/.test(token)) return "number";
+  if (CONSTANTS.has(token)) return "constant";
+  return "keyword";
+}
+
+function renderRunsByLine(source, runs, options) {
+  const lines = [""];
+  for (const run of runs.length ? runs : [{ text: source, scope: "default" }]) {
+    const parts = run.text.split("\n");
+    for (let i = 0; i < parts.length; i++) {
+      if (i > 0) lines.push("");
+      if (parts[i]) lines[lines.length - 1] += styleSyntax(parts[i], run.scope, options.bg);
+    }
+  }
+  return lines;
+}
+
+export function styleSyntax(text, scope = "default", bg = "") {
+  const codes = [SCOPE_STYLE[scope] ?? SCOPE_STYLE.default];
+  if (bg) codes.push(bg);
+  return `\x1b[${codes.join(";")}m${text}${R}`;
+}
+
+function buildByteToIndex(text) {
+  const map = [];
+  let byte = 0;
+  for (let index = 0; index < text.length;) {
+    const codePoint = text.codePointAt(index);
+    const char = String.fromCodePoint(codePoint);
+    const bytes = ENCODER.encode(char).length;
+    for (let i = 0; i < bytes; i++) map[byte + i] = index;
+    byte += bytes;
+    index += char.length;
+  }
+  map[byte] = text.length;
+  return map;
+}
+
+void initializeTreeSitterHighlighting();

package/src/cli/tui/syntax/languages.mjs

@@ -0,0 +1,91 @@
+export const LANGUAGES = {
+  bash: { file: "tree-sitter-bash.wasm", query: "bash.highlights.scm" },
+  c: { file: "tree-sitter-c.wasm", query: "c.highlights.scm" },
+  cpp: { file: "tree-sitter-cpp.wasm", query: "cpp.highlights.scm" },
+  csharp: { file: "tree-sitter-c-sharp.wasm", query: "csharp.highlights.scm" },
+  css: { file: "tree-sitter-css.wasm", query: "css.highlights.scm" },
+  diff: { file: "tree-sitter-diff.wasm", query: "diff.highlights.scm" },
+  go: { file: "tree-sitter-go.wasm", query: "go.highlights.scm" },
+  html: { file: "tree-sitter-html.wasm", query: "html.highlights.scm" },
+  java: { file: "tree-sitter-java.wasm", query: "java.highlights.scm" },
+  javascript: { file: "tree-sitter-typescript.wasm", query: "typescript.highlights.scm" },
+  json: { file: "tree-sitter-json.wasm", query: "json.highlights.scm" },
+  php: { file: "tree-sitter-php.wasm", query: "php.highlights.scm" },
+  python: { file: "tree-sitter-python.wasm", query: "python.highlights.scm" },
+  ruby: { file: "tree-sitter-ruby.wasm", query: "ruby.highlights.scm" },
+  rust: { file: "tree-sitter-rust.wasm", query: "rust.highlights.scm" },
+  toml: { file: "tree-sitter-toml.wasm", query: "toml.highlights.scm" },
+  tsx: { file: "tree-sitter-tsx.wasm", query: "tsx.highlights.scm" },
+  typescript: { file: "tree-sitter-typescript.wasm", query: "typescript.highlights.scm" },
+  yaml: { file: "tree-sitter-yaml.wasm", query: "yaml.highlights.scm" },
+};
+
+export const LANG_ALIASES = new Map([
+  ["bash", "bash"], ["c", "c"], ["cc", "cpp"], ["cjs", "javascript"], ["cpp", "cpp"],
+  ["cs", "csharp"], ["css", "css"], ["cts", "typescript"], ["csharp", "csharp"], ["cxx", "cpp"],
+  ["diff", "diff"], ["go", "go"], ["h", "c"], ["hh", "cpp"], ["htm", "html"], ["html", "html"],
+  ["hpp", "cpp"], ["hxx", "cpp"], ["java", "java"], ["javascript", "javascript"], ["js", "javascript"],
+  ["json", "json"], ["jsonc", "json"], ["jsx", "jsx"], ["mjs", "javascript"], ["mts", "typescript"],
+  ["patch", "diff"], ["php", "php"], ["py", "python"], ["python", "python"], ["rb", "ruby"],
+  ["rs", "rust"], ["ruby", "ruby"], ["rust", "rust"], ["sh", "bash"], ["toml", "toml"],
+  ["ts", "typescript"], ["tsx", "tsx"], ["typescript", "typescript"], ["yaml", "yaml"], ["yml", "yaml"],
+  ["zsh", "bash"],
+]);
+
+export const SCOPE_STYLE = {
+  default: "38;2;127;216;143",
+  comment: "2;90",
+  string: "38;2;127;216;143",
+  number: "36",
+  constant: "36",
+  keyword: "38;2;245;167;66",
+  function: "38;5;117",
+  type: "38;5;141",
+  property: "38;5;116",
+  operator: "38;5;250",
+  punctuation: "38;5;245",
+  variable: "38;5;250",
+  tag: "38;5;203",
+  attribute: "38;5;179",
+};
+
+export const SCOPE_PRIORITY = {
+  default: 0,
+  punctuation: 1,
+  operator: 2,
+  variable: 3,
+  property: 4,
+  attribute: 4,
+  type: 5,
+  function: 6,
+  keyword: 7,
+  constant: 8,
+  number: 9,
+  string: 10,
+  comment: 11,
+  tag: 12,
+};
+
+export const KEYWORDS = new Set([
+  "abstract", "as", "async", "await", "break", "case", "catch", "class", "const", "continue",
+  "debugger", "declare", "default", "delete", "do", "else", "enum", "export", "extends", "finally",
+  "for", "from", "function", "get", "if", "implements", "import", "in", "infer", "instanceof",
+  "interface", "keyof", "let", "module", "namespace", "new", "of", "private", "protected", "public",
+  "readonly", "return", "satisfies", "set", "static", "switch", "throw", "try", "type", "typeof",
+  "var", "void", "while", "with", "yield",
+]);
+
+export const CONSTANTS = new Set(["false", "null", "super", "this", "true", "undefined"]);
+export const OPERATORS = new Set([
+  "+", "-", "*", "/", "%", "=", "==", "===", "!=", "!==", "<", "<=", ">", ">=", "=>",
+  "&&", "||", "!", "?", "??", "|", "&", "^", "~", ":",
+]);
+export const PUNCTUATION = new Set(["(", ")", "[", "]", "{", "}", ".", ",", ";"]);
+export const STRING_TYPES = new Set(["string", "string_fragment", "template_string", "regex", "escape_sequence"]);
+export const NUMBER_TYPES = new Set(["number", "number_fragment"]);
+export const TYPE_TYPES = new Set(["type_identifier", "predefined_type", "primitive_type", "type_annotation"]);
+export const PROPERTY_TYPES = new Set([
+  "property_identifier",
+  "shorthand_property_identifier",
+  "shorthand_property_identifier_pattern",
+]);