mini-coder 0.7.4 → 0.8.1

package/src/tui/complete.ts

@@ -0,0 +1,85 @@
+import { readdirSync, statSync, type Dirent } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+/**
+ * Deliberately bash-unfaithful: no `cdable_vars`, no `~user` expansion (`~`
+ * always means `homedir()`), no `$VAR`, backtick, or history expansion (word
+ * text is always literal), and no shell options — dotfile hiding, byte-exact
+ * matching, and dir-slash behavior below hold unconditionally.
+ */
+
+/**
+ * A word must already carry path syntax to be completed: a leading `~`, a
+ * leading `./` or `../` (or bare `.` / `..`), a leading `/`, or any segment
+ * followed by a slash somewhere in the word. Bare words (`re`, `hello`) return
+ * null without a syscall, so mid-sentence prose never gets hijacked.
+ */
+const PATH_LIKE = /^(?:~|\/|\.{1,2}(?:\/|$)|\w+\/)/;
+
+/** A directory, or a symlink that resolves to one (`statSync` follows). */
+function isDir(path: string, entry: Dirent): boolean {
+  if (entry.isDirectory()) return true;
+  if (!entry.isSymbolicLink()) return false;
+  try {
+    return statSync(join(path, entry.name)).isDirectory();
+  } catch {
+    return false; // broken link completes file-shaped, like bash.
+  }
+}
+
+/**
+ * Completes `word` as a file path, bash-readline-style: the returned word is
+ * the whole feedback, a strict extension of what was typed. Unreadable
+ * locations, paths through files, and nothing longer to add all give null and
+ * the caller leaves the draft alone.
+ */
+export function completePath(word: string, cwd: string): string | null {
+  if (!PATH_LIKE.test(word)) return null;
+
+  // Word = dirPart + prefix, split at the last slash, slash kept with dirPart.
+  const slash = word.lastIndexOf("/");
+  const prefix = word.slice(slash + 1);
+
+  // Resolve dirPart to the directory to list. `~` means homedir() here and
+  // nowhere else: the returned word below reuses the user's shorthand verbatim
+  // (`~/Doc⇥` stays `~/Documents/`), so this resolve only locates the listing.
+  // Concatenate before resolving — `resolve(home, "/x")` would reset to root.
+  let dir: string;
+  if (word.startsWith("~")) dir = resolve(homedir() + word.slice(1, slash));
+  else if (slash === 0) dir = "/";
+  else dir = resolve(cwd, word.slice(0, slash));
+
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null; // vanished, permission, or a file in the path: nothing better.
+  }
+
+  // Bash hides dotfiles unless the prefix itself starts with one (`~/.⇥`
+  // includes hidden entries). A directory completion grows a trailing `/` so
+  // the next Tab descends into it; a symlink to a directory counts as one —
+  // `withFileTypes` reports the link itself, so the target needs one stat.
+  const candidates = entries
+    .filter((entry) => entry.name.startsWith(prefix) && (prefix.startsWith(".") || !entry.name.startsWith(".")))
+    .map((entry) => (isDir(dir, entry) ? `${entry.name}/` : entry.name));
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) {
+    // Worth returning only when it adds something the user did not already
+    // type (`renameTag` typed against the single file match `renameTag` → null).
+    return candidates[0] === prefix ? null : word.slice(0, word.length - prefix.length) + candidates[0];
+  }
+  const shared = candidates.reduce(commonPrefix);
+  // Recombine over the untouched dirPart, so `~/Doc⇥` becomes `~/Documents/`
+  // and never `/home/xonecas/Documents/`; no exact-name short-circuit here.
+  return shared.length > prefix.length ? word.slice(0, word.length - prefix.length) + shared : null;
+}
+
+/** Case-sensitive longest common prefix; commands.ts uses it for command
+ *  completion, completePath for path candidates. */
+export function commonPrefix(a: string, b: string): string {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i++;
+  return a.slice(0, i);
+}

package/src/tui/editor.ts

@@ -0,0 +1,320 @@
+import { displayWidth, expandTabs, wrapLine, type Key } from "./term.ts";
+
+const TAB = 4;
+const DEFAULT_WIDTH = 80;
+
+function codePoints(line: string): string[] {
+  return Array.from(line);
+}
+
+function isSpace(ch: string): boolean {
+  return /\s/u.test(ch);
+}
+
+/** First code point index of the word before `col`; shared by all word motion. */
+function wordStart(cps: string[], col: number): number {
+  let i = col;
+  while (i > 0 && isSpace(cps[i - 1])) i--;
+  while (i > 0 && !isSpace(cps[i - 1])) i--;
+  return i;
+}
+
+/** Code point index one past the word at or after `col`. */
+function wordEnd(cps: string[], col: number): number {
+  let i = col;
+  while (i < cps.length && isSpace(cps[i])) i++;
+  while (i < cps.length && !isSpace(cps[i])) i++;
+  return i;
+}
+
+interface EditorRender {
+  rows: string[];
+  cursorRow: number;
+  cursorCol: number;
+}
+
+export class Editor {
+  private lines: string[] = [""];
+  private row = 0;
+  private col = 0;
+  private scroll = 0;
+  private width = DEFAULT_WIDTH;
+  private masked = false;
+
+  text(): string {
+    return this.lines.join("\n");
+  }
+
+  /** Renders each character as `*` without changing the underlying text. */
+  setMasked(masked: boolean): void {
+    this.masked = masked;
+  }
+
+  private display(line: string): string {
+    return this.masked ? "*".repeat(codePoints(line).length) : line;
+  }
+
+  clear(): void {
+    this.lines = [""];
+    this.row = 0;
+    this.col = 0;
+    this.scroll = 0;
+  }
+
+  setText(text: string): void {
+    this.lines = text.split("\n");
+    this.row = this.lines.length - 1;
+    this.col = codePoints(this.lines[this.row]).length;
+    this.scroll = 0;
+  }
+
+  handle(key: Key): "submit" | "changed" | "none" {
+    switch (key.type) {
+      case "submit":
+        return "submit";
+      case "newline":
+        this.insert("\n");
+        return "changed";
+      case "text":
+        this.insert(key.text);
+        return "changed";
+      case "backspace":
+        this.backspace();
+        return "changed";
+      case "delete":
+        this.deleteForward();
+        return "changed";
+      case "wordBack":
+        this.wordBack();
+        return "changed";
+      case "left":
+        this.left();
+        return "changed";
+      case "right":
+        this.right();
+        return "changed";
+      case "wordLeft":
+        this.wordLeft();
+        return "changed";
+      case "wordRight":
+        this.wordRight();
+        return "changed";
+      case "up":
+        this.up();
+        return "changed";
+      case "down":
+        this.down();
+        return "changed";
+      case "home":
+        this.col = 0;
+        return "changed";
+      case "end":
+        this.col = codePoints(this.lines[this.row]).length;
+        return "changed";
+      case "docStart":
+        this.row = 0;
+        this.col = 0;
+        return "changed";
+      case "docEnd":
+        this.row = this.lines.length - 1;
+        this.col = codePoints(this.lines[this.row]).length;
+        return "changed";
+      default:
+        return "none";
+    }
+  }
+
+  /** Clipped to `maxRows`, scrolled only as far as the caret requires. */
+  render(width: number, maxRows: number): EditorRender {
+    this.width = Math.max(1, width);
+    const rows: string[] = [];
+    let cursorRow = 0;
+    let cursorCol = 0;
+    for (let line = 0; line < this.lines.length; line++) {
+      const chunks = wrapLine(expandTabs(this.display(this.lines[line]), TAB), this.width);
+      if (line === this.row) {
+        const caret = this.caret();
+        cursorRow = rows.length + caret.row;
+        cursorCol = caret.col;
+      }
+      rows.push(...chunks);
+    }
+    const view = Math.max(1, maxRows);
+    if (cursorRow < this.scroll) this.scroll = cursorRow;
+    else if (cursorRow >= this.scroll + view) this.scroll = cursorRow - view + 1;
+    this.scroll = Math.min(Math.max(this.scroll, 0), Math.max(0, rows.length - view));
+    return {
+      rows: rows.slice(this.scroll, this.scroll + view),
+      cursorRow: cursorRow - this.scroll,
+      cursorCol,
+    };
+  }
+
+  /** The caret's display row within its logical line, and its cell column. */
+  private caret(): { row: number; col: number } {
+    const line = this.display(this.lines[this.row]);
+    const chunks = wrapLine(expandTabs(line, TAB), this.width);
+    const cell = this.cells(line)[this.col];
+    const row = Math.floor(cell / this.width);
+    if (row >= chunks.length) return { row: chunks.length - 1, col: displayWidth(chunks[chunks.length - 1]) };
+    return { row, col: cell - row * this.width };
+  }
+
+  /** Display column of every code point boundary in `line`, tabs expanded. */
+  private cells(line: string): number[] {
+    const out = [0];
+    let col = 0;
+    for (const ch of codePoints(line)) {
+      col += ch === "\t" ? TAB - (col % TAB) : displayWidth(ch);
+      out.push(col);
+    }
+    return out;
+  }
+
+  /** The caret column nearest `cell`, never past the end of the line. */
+  private colAtCell(line: string, cell: number): number {
+    const cells = this.cells(line);
+    let i = cells.length - 1;
+    while (i > 0 && cells[i] > cell) i--;
+    return i;
+  }
+
+  private insert(text: string): void {
+    const parts = text.split("\n");
+    const current = codePoints(this.lines[this.row]);
+    const before = current.slice(0, this.col).join("");
+    const after = current.slice(this.col).join("");
+    if (parts.length === 1) {
+      this.lines[this.row] = before + parts[0] + after;
+      this.col += codePoints(parts[0]).length;
+      return;
+    }
+    const head = before + parts[0];
+    const tail = parts[parts.length - 1] + after;
+    this.lines.splice(this.row, 1, head, ...parts.slice(1, -1), tail);
+    this.row += parts.length - 1;
+    this.col = codePoints(parts[parts.length - 1]).length;
+  }
+
+  private backspace(): void {
+    if (this.col > 0) {
+      const current = codePoints(this.lines[this.row]);
+      this.lines[this.row] = current.slice(0, this.col - 1).join("") + current.slice(this.col).join("");
+      this.col--;
+      return;
+    }
+    if (this.row > 0) {
+      const previous = codePoints(this.lines[this.row - 1]).length;
+      this.lines[this.row - 1] += this.lines[this.row];
+      this.lines.splice(this.row, 1);
+      this.row--;
+      this.col = previous;
+    }
+  }
+
+  private deleteForward(): void {
+    const current = codePoints(this.lines[this.row]);
+    if (this.col < current.length) {
+      this.lines[this.row] = current.slice(0, this.col).join("") + current.slice(this.col + 1).join("");
+      return;
+    }
+    if (this.row < this.lines.length - 1) {
+      this.lines[this.row] += this.lines[this.row + 1];
+      this.lines.splice(this.row + 1, 1);
+    }
+  }
+
+  private left(): void {
+    if (this.col > 0) this.col--;
+    else if (this.row > 0) {
+      this.row--;
+      this.col = codePoints(this.lines[this.row]).length;
+    }
+  }
+
+  private right(): void {
+    if (this.col < codePoints(this.lines[this.row]).length) this.col++;
+    else if (this.row < this.lines.length - 1) {
+      this.row++;
+      this.col = 0;
+    }
+  }
+
+  /** One display row, so the caret crosses the wrapped rows of a long line. */
+  private up(): void {
+    const line = this.lines[this.row];
+    const caret = this.caret();
+    if (caret.row > 0) {
+      this.col = this.colAtCell(line, this.cells(line)[this.col] - this.width);
+      return;
+    }
+    if (this.row === 0) return;
+    this.row--;
+    const previous = this.lines[this.row];
+    const lastRow = wrapLine(expandTabs(previous, TAB), this.width).length - 1;
+    this.col = this.colAtCell(previous, lastRow * this.width + caret.col);
+  }
+
+  private down(): void {
+    const line = this.lines[this.row];
+    const caret = this.caret();
+    if (caret.row < wrapLine(expandTabs(line, TAB), this.width).length - 1) {
+      this.col = this.colAtCell(line, this.cells(line)[this.col] + this.width);
+      return;
+    }
+    if (this.row === this.lines.length - 1) return;
+    this.row++;
+    this.col = this.colAtCell(this.lines[this.row], caret.col);
+  }
+
+  private wordLeft(): void {
+    const cps = codePoints(this.lines[this.row]);
+    const start = wordStart(cps, this.col);
+    if (start !== this.col) {
+      this.col = start;
+      return;
+    }
+    if (this.row === 0) return;
+    this.row--;
+    const previous = codePoints(this.lines[this.row]);
+    this.col = wordStart(previous, previous.length);
+  }
+
+  private wordRight(): void {
+    const cps = codePoints(this.lines[this.row]);
+    const end = wordEnd(cps, this.col);
+    if (end !== this.col) {
+      this.col = end;
+      return;
+    }
+    if (this.row === this.lines.length - 1) return;
+    this.row++;
+    this.col = wordEnd(codePoints(this.lines[this.row]), 0);
+  }
+
+  private wordBack(): void {
+    const current = codePoints(this.lines[this.row]);
+    const start = wordStart(current, this.col);
+    this.lines[this.row] = current.slice(0, start).join("") + current.slice(this.col).join("");
+    this.col = start;
+  }
+
+  /**
+   * Applies `step` to the word ending at the caret, replacing it; false when
+   * there is no word before the caret. Whitespace is `isSpace` (Unicode `\s`),
+   * so a path word may carry `/`, `~`, `.`, `$` — no path-specific separator
+   * set. No completion-undo: bash's TAB-_ restore is out; the user backspaces
+   * or re-types instead, with Esc and the editor's own keys as recovery.
+   */
+  completeWord(step: (word: string) => string | null): boolean {
+    const current = codePoints(this.lines[this.row]);
+    const start = wordStart(current, this.col);
+    if (start === this.col || isSpace(current[this.col - 1])) return false;
+    const word = current.slice(start, this.col).join("");
+    const completed = step(word);
+    if (completed === null) return false;
+    this.lines[this.row] = current.slice(0, start).join("") + completed + current.slice(this.col).join("");
+    this.col = start + codePoints(completed).length;
+    return true;
+  }
+}

package/src/tui/highlight.ts

@@ -0,0 +1,189 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import Parser from "tree-sitter";
+import JavaScript from "tree-sitter-javascript";
+import TypeScript from "tree-sitter-typescript";
+import Markdown from "@tree-sitter-grammars/tree-sitter-markdown";
+import { HEADINGS, INLINE_CODE, NORMAL_BG, NORMAL_FG, STYLES, channels, sgrPlain, type Style } from "./theme.ts";
+
+/**
+ * Syntax highlighting for committed scrollback, once, over the whole block.
+ * Grammar queries ship with the grammar packages and are consumed as data, so
+ * a capture name is the only thing that reaches the palette. The colours come
+ * from the TokyoNight `night` palette in `theme.ts`, mapped the way
+ * `folke/tokyonight.nvim` maps capture names to highlight groups. Truecolor only.
+ */
+
+function styleFor(capture: string): Style | undefined {
+  for (let name = capture; ; name = name.slice(0, name.lastIndexOf("."))) {
+    const style = STYLES[name];
+    if (style !== undefined) return style;
+    if (!name.includes(".")) return undefined;
+  }
+}
+
+const require = createRequire(import.meta.url);
+
+/** A grammar package keeps its queries next to its sources. */
+function querySource(pkg: string, ...path: string[]): string {
+  return readFileSync(join(dirname(require.resolve(`${pkg}/package.json`)), ...path), "utf8");
+}
+
+interface Syntax {
+  parser: Parser;
+  query: Parser.Query;
+}
+
+function syntax(language: Parser.Language, ...sources: string[]): Syntax {
+  const parser = new Parser();
+  parser.setLanguage(language);
+  return { parser, query: new Parser.Query(language, sources.join("\n")) };
+}
+
+const JS_QUERIES = querySource("tree-sitter-javascript", "queries", "highlights.scm");
+const TS_QUERIES = querySource("tree-sitter-typescript", "queries", "highlights.scm");
+
+const JAVASCRIPT = syntax(JavaScript, JS_QUERIES);
+/** TypeScript's own query only covers what it adds to JavaScript. */
+const TYPESCRIPT = syntax(TypeScript.typescript, JS_QUERIES, TS_QUERIES);
+const TSX = syntax(TypeScript.tsx, JS_QUERIES, TS_QUERIES);
+
+/** Fence info string to grammar, for the languages we carry. */
+const CODE: Record<string, Syntax | undefined> = {
+  js: JAVASCRIPT,
+  javascript: JAVASCRIPT,
+  jsx: JAVASCRIPT,
+  ts: TYPESCRIPT,
+  typescript: TYPESCRIPT,
+  tsx: TSX,
+};
+
+const MARKDOWN = syntax(
+  Markdown,
+  querySource("@tree-sitter-grammars/tree-sitter-markdown", "tree-sitter-markdown", "queries", "highlights.scm"),
+);
+const MARKDOWN_INLINE = syntax(
+  Markdown.inline,
+  querySource(
+    "@tree-sitter-grammars/tree-sitter-markdown",
+    "tree-sitter-markdown-inline",
+    "queries",
+    "highlights.scm",
+  ),
+);
+
+/** One styled range of a line, in byte offsets into that line. */
+interface Span {
+  start: number;
+  end: number;
+  style: Style;
+}
+
+function spansOf(syntax: Syntax, node: Parser.SyntaxNode, offset = 0): Span[] {
+  const spans: Span[] = [];
+  for (const capture of syntax.query.captures(node)) {
+    const style = styleFor(capture.name);
+    if (style === undefined) continue;
+    spans.push({ start: offset + capture.node.startIndex, end: offset + capture.node.endIndex, style });
+  }
+  return spans;
+}
+
+function parse(syntax: Syntax, text: string): Parser.SyntaxNode {
+  return syntax.parser.parse(text).rootNode;
+}
+
+/**
+ * A style's own attributes, with the defaults spelled out: a span that names no
+ * color must not inherit the color of the span or token before it, and the
+ * fallback is the palette's `Normal`, never the terminal's own pair.
+ */
+function sgr(style: Style): string {
+  let out = "\x1b[";
+  if (style.bold) out += "1;";
+  if (style.italic) out += "3;";
+  if (style.underline) out += "4;";
+  out += `38;2;${channels(style.fg ?? NORMAL_FG)};48;2;${channels(style.bg ?? NORMAL_BG)}m`;
+  return out;
+}
+
+/**
+ * Wraps every span in its color. Spans nest, so the innermost one wins; text
+ * outside any span falls back to `Normal`. The trailing close restores the same
+ * pair, so a span may cross a line break and the last line still ends plain —
+ * and no cell is ever left to the terminal. Because each row is painted on its
+ * own, a span that outlives a line break re-asserts itself on the next line.
+ */
+function paint(text: string, spans: Span[]): string {
+  const events: { at: number; open: boolean; span: Span }[] = [];
+  for (const span of spans) {
+    if (span.end <= span.start) continue;
+    events.push({ at: span.start, open: true, span }, { at: span.end, open: false, span });
+  }
+  events.sort((a, b) => a.at - b.at || Number(a.open) - Number(b.open));
+
+  const active: Span[] = [];
+  let out = "";
+  let plain = true;
+  let at = 0;
+  const emit = (end: number): void => {
+    if (end <= at) return;
+    const style = active.length === 0 ? undefined : active[active.length - 1].style;
+    if (style === undefined) {
+      if (!plain) out += sgrPlain();
+      plain = true;
+    } else {
+      out += sgr(style);
+      plain = false;
+    }
+    const chunk = text.slice(at, end);
+    out += style === undefined ? chunk : chunk.replace(/\n/g, `\n${sgr(style)}`);
+    at = end;
+  };
+  for (const event of events) {
+    emit(event.at);
+    if (event.open) active.push(event.span);
+    else active.splice(active.indexOf(event.span), 1);
+  }
+  emit(text.length);
+  return plain ? out : `${out}${sgrPlain()}`;
+}
+
+/**
+ * Colors one committed block of Markdown. Inline markup is a separate grammar,
+ * run over the ranges the block grammar hands over, as its injections do.
+ */
+export function highlightMarkdown(text: string): string {
+  const root = parse(MARKDOWN, text);
+  let spans = spansOf(MARKDOWN, root);
+  // Two things the grammar's queries predate: a whole heading is colored by its
+  // level, and inline code carries a background. Both replace what covers them.
+  for (const inline of root.descendantsOfType("inline")) {
+    const inlineRoot = parse(MARKDOWN_INLINE, inline.text);
+    spans.push(...spansOf(MARKDOWN_INLINE, inlineRoot, inline.startIndex));
+    for (const code of inlineRoot.descendantsOfType("code_span")) {
+      spans = recolor(spans, code, INLINE_CODE, inline.startIndex);
+    }
+  }
+  for (const heading of root.descendantsOfType(["atx_heading", "setext_heading"])) {
+    const marker = heading.namedChildren.find((child) => /^(atx|setext)_h/.test(child.type))?.type;
+    const level = marker === undefined ? 1 : Number(marker.replace(/\D/g, ""));
+    spans = recolor(spans, heading, HEADINGS[Math.min(level, HEADINGS.length) - 1]);
+  }
+  return paint(text, spans);
+}
+
+/** Replaces every span inside `node` with one span covering the whole node. */
+function recolor(spans: Span[], node: Parser.SyntaxNode, style: Style, offset = 0): Span[] {
+  const start = offset + node.startIndex;
+  const end = offset + node.endIndex;
+  const kept = spans.filter((span) => span.start < start || span.end > end);
+  return [...kept, { start, end, style }];
+}
+
+/** Colors a fenced code block's body, by its fence info string. */
+export function highlightCode(info: string, text: string): string {
+  const grammar = CODE[info.trim().toLowerCase()];
+  return grammar === undefined ? text : paint(text, spansOf(grammar, parse(grammar, text)));
+}