rovecode 0.3.2

package/src/sextant/sextant-repo.ts

@@ -0,0 +1,140 @@
+/** Sextant repo watcher (port #44 fix wave): the renderer's git + fs work — the files-panel scan (full
+ *  after a mutating tool, porcelain-only while idle), the post-edit diff and the /diff view — scheduled
+ *  OFF the frame loop (a setTimeout(0) from the tick, never inside a painter) and run ASYNC through the
+ *  git-status.ts `…Async` forms (child processes; results applied on completion + a repaint), so a
+ *  200 ms `git status` on a large repo never freezes the spinner, the pet or the keys. One scan is in
+ *  flight at a time: a request that arrives meanwhile runs on the first tick after it settles; stop()
+ *  drops every pending timer and ignores results that land afterwards. Extracted from
+ *  sextant-renderer.ts (ADR-002 line budget); the renderer owns the state, this class only writes
+ *  s.files / s.repo.branch / s.code.diff and the tool row's landed counts. */
+
+import type { GitRunnerAsync } from "./git-status.ts";
+import { setFiles } from "./model.ts";
+import type { HashlineOp } from "./sextant-diff-base.ts";
+import { fileDiffAsync, headDiffAsync, scanRepoAsync, statusOnlyAsync, type HeadDiff } from "./sextant-files.ts";
+import type { SextantState, ToolRow } from "./types.ts";
+
+/** while idle, the porcelain statuses are re-read at most this often */
+export const IDLE_SCAN_MS = 5000;
+
+export interface RepoWatcherDeps {
+  state: SextantState;
+  clock: () => number;
+  git: GitRunnerAsync;
+  /** request a repaint (the frame loop's markDirty) */
+  dirty: () => void;
+}
+
+export class RepoWatcher {
+  private wanted: "full" | "status" | null;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private readonly deferred = new Set<ReturnType<typeof setTimeout>>();
+  private inFlight = false;
+  private lastScanAt = -Infinity;
+  private hasGit = false;
+  private stopped = false;
+  /** aborts the git children of a scan in flight when stop() is called (git-status.ts runner signal) */
+  private readonly ac = new AbortController();
+  /** the scan in flight, so stop() can wait for its children to be GONE, not merely killed */
+  private live: Promise<void> | null = null;
+
+  /** `scan` false disables the repo scan entirely (pure unit tests) */
+  constructor(private readonly d: RepoWatcherDeps, scan: boolean) { this.wanted = scan ? "full" : null; }
+
+  /** a mutating tool (edit / write / remove / run) landed: list + statuses + branch again — repos only,
+   *  but while the first scan is still in flight the answer is unknown, so the request is kept */
+  afterMutation(): void { if (this.wanted !== null || this.hasGit || this.inFlight) this.wanted = "full"; }
+  /** attach() re-pointed the cwd: a fresh full scan unless scanning is off */
+  afterAttach(): void { if (this.wanted !== null || this.lastScanAt !== -Infinity) this.wanted = "full"; }
+  /** a scan is running in the background (tests) */
+  get scanning(): boolean { return this.inFlight; }
+
+  /** First file snapshot under the intro, before revealing an apparently empty files panel.
+   *  This is called off the paint path. stop() owns/drains the same promise on cancellation. */
+  prepare(): Promise<void> {
+    if (this.stopped) return Promise.resolve();
+    if (this.timer) { clearTimeout(this.timer); this.timer = null; }
+    if (!this.live) this.live = this.scan();
+    return this.live;
+  }
+
+  /** from the frame loop's tick: arm the idle poll, then schedule whatever is wanted (once) */
+  onTick(now: number, running: boolean): void {
+    if (this.wanted === null && this.hasGit && !running && now - this.lastScanAt >= IDLE_SCAN_MS) this.wanted = "status";
+    if (this.wanted !== null && !this.inFlight && !this.timer && !this.stopped) this.timer = setTimeout(() => { this.timer = null; this.live = this.scan(); }, 0);
+  }
+
+  /** only reached through onTick's timer, which is armed when no scan is in flight */
+  private async scan(): Promise<void> {
+    if (this.stopped || this.wanted === null) return;
+    const kind = this.wanted, s = this.d.state;
+    this.wanted = null; this.lastScanAt = this.d.clock(); this.inFlight = true;
+    // every git child of this scan is bound to the watcher's abort signal: stop() kills them and the
+    // runner settles only when they are gone, so `live` resolving means "no child holds the cwd"
+    const git: GitRunnerAsync = (a, c) => this.d.git(a, c, this.ac.signal);
+    try {
+      if (kind === "full") {
+        const snap = await scanRepoAsync(s.cwd, git);
+        if (this.stopped) return;
+        setFiles(s, snap.paths, snap.statuses); s.repo.branch = snap.branch; this.hasGit = snap.git;
+      } else {
+        const st = await statusOnlyAsync(s.cwd, git);
+        if (this.stopped) return;
+        if (st) setFiles(s, s.files.paths, st);
+      }
+      this.d.dirty();
+    } finally { this.inFlight = false; }
+  }
+
+  /** The #41 diffFor seam, deferred and async: the hunks for the file an edit/write just changed →
+   *  s.code.diff + the diff view. `before` = the pre-edit content captured at approval (undefined when
+   *  the call was not gated), `ops` = the edit's hashline ops (the base is rebuilt from them when
+   *  nothing was captured). The row's `+a −b` is overwritten only by an edit-only diff — a HEAD base
+   *  is cumulative, so the row keeps the reducer's args-derived counts and the view says `vs HEAD`. */
+  scheduleDiff(row: ToolRow, file: string, before: string | null | undefined, ops: readonly HashlineOp[]): void {
+    this.defer(async () => {
+      const d = await fileDiffAsync(this.d.state.cwd, file, before, this.d.git, ops);
+      if (this.stopped || !d) return;
+      if (d.base !== "head") { row.add = d.add; row.del = d.del; }
+      this.show(file, d, true);
+    });
+  }
+
+  /** the /diff view (⌃d, /diff, ←/→ into diff mode): HEAD vs disk for the file, flagged as such; the
+   *  mode is already diff (keys.ts wrote it before the hook fired) and is not forced back if the user
+   *  moved on while git ran */
+  loadDiff(file: string): void {
+    this.defer(async () => {
+      const d = await headDiffAsync(this.d.state.cwd, file, this.d.git);
+      if (this.stopped) return;
+      if (d) this.show(file, d, false); else { this.d.state.code.diff = null; this.d.dirty(); }
+    });
+  }
+
+  private show(file: string, d: HeadDiff, flip: boolean): void {
+    const s = this.d.state;
+    s.code.diff = { file, hunks: d.hunks, add: d.add, del: d.del, ...(d.base ? { base: d.base } : {}) };
+    if (flip) s.code.mode = "diff";
+    this.d.dirty();
+  }
+
+  private defer(work: () => Promise<void>): void {
+    if (this.stopped) return;
+    const t = setTimeout(() => { this.deferred.delete(t); if (!this.stopped) void work(); }, 0);
+    this.deferred.add(t);
+  }
+
+  /** clear every pending timer, KILL the git children of a scan in flight (their results are dropped),
+   *  and resolve once those children are gone — the caller can then remove the cwd. Idempotent: a second
+   *  stop() returns the same settled promise. Before this, stop() only dropped results and left the child
+   *  running; on Windows a live `git status` holds the directory and every tui-sextant test's quit()
+   *  failed at rmSync with EBUSY, a different test each run. */
+  stop(): Promise<void> {
+    this.stopped = true;
+    if (this.timer) { clearTimeout(this.timer); this.timer = null; }
+    for (const t of this.deferred) clearTimeout(t);
+    this.deferred.clear();
+    this.ac.abort();
+    return this.live ?? Promise.resolve();
+  }
+}

package/src/sextant/theme.ts

@@ -0,0 +1,66 @@
+/** ported from the user's sextant v0.4.0 prototype, src/app.js lines 16-37 (THEMES, buildTheme, st) + term.js (rgb, mix, hex) */
+/* Palettes and their derived mixes for the sextant surface. Pure: no I/O, no clock. The derived
+   values are byte-for-byte the prototype's (same mix() arithmetic); sextant-theme.test.ts pins
+   every number for all three palettes. */
+
+import { THEME_ORDER, type Style, type Theme, type ThemeName } from "./types.ts";
+
+export { THEME_ORDER };
+
+/** a palette as authored: "#rrggbb" strings plus the human label */
+export interface Palette {
+  label: string;
+  bg: string; bg2: string; fg: string; fg2: string; muted: string; dim: string;
+  rule: string; rule2: string; accent: string; accent2: string;
+  ok: string; err: string; warn: string; info: string; str: string; ty: string;
+}
+
+export const THEMES: Readonly<Record<ThemeName, Palette>> = {
+  night: { label: "Gece + nane", bg: "#0b0e12", bg2: "#11161c", fg: "#e6edf3", fg2: "#aab4bf", muted: "#7d8590", dim: "#4b545e", rule: "#2a323b", rule2: "#3a4550", accent: "#3ddbb9", accent2: "#9af2df", ok: "#3fb950", err: "#f0605d", warn: "#e3b341", info: "#79c0ff", str: "#9ee7d6", ty: "#b6c2ce" },
+  ember: { label: "Mürekkep + kor", bg: "#0f0c0b", bg2: "#171210", fg: "#f2eae2", fg2: "#c9bcb0", muted: "#8c817a", dim: "#554c46", rule: "#332b27", rule2: "#463a34", accent: "#ff7a45", accent2: "#ffb08a", ok: "#6cc783", err: "#ef5a5a", warn: "#f4b942", info: "#8fb8e8", str: "#ffb38a", ty: "#cdbfb3" },
+  contrast: { label: "Saf kontrast", bg: "#000000", bg2: "#0b0b0b", fg: "#ffffff", fg2: "#d4d4d4", muted: "#8a8a8a", dim: "#4c4c4c", rule: "#3a3a3a", rule2: "#4a4a4a", accent: "#ffffff", accent2: "#ffffff", ok: "#4ade80", err: "#f87171", warn: "#fbbf24", info: "#93c5fd", str: "#d4d4d4", ty: "#bdbdbd" },
+};
+
+/** "#rrggbb" → packed 0xRRGGBB */
+export const rgb = (h: string): number => parseInt(h.slice(1), 16);
+
+/** per-channel linear blend of two packed colors, rounded (term.js mix — the derived-color arithmetic) */
+export function mix(c1: number, c2: number, t: number): number {
+  const r = Math.round(((c1 >> 16) & 255) + ((((c2 >> 16) & 255) - ((c1 >> 16) & 255)) * t));
+  const g = Math.round(((c1 >> 8) & 255) + ((((c2 >> 8) & 255) - ((c1 >> 8) & 255)) * t));
+  const b = Math.round((c1 & 255) + (((c2 & 255) - (c1 & 255)) * t));
+  return (r << 16) | (g << 8) | b;
+}
+
+/** packed color → "#rrggbb" */
+export const hex = (c: number): string => "#" + (c >>> 0).toString(16).padStart(6, "0");
+
+export function isThemeName(name: string): name is ThemeName {
+  return Object.hasOwn(THEMES, name);
+}
+
+/** palette → packed ints + derived mixes; an unknown name falls back to "night" (prototype behavior) */
+export function buildTheme(name: string): Theme {
+  const n: ThemeName = isThemeName(name) ? name : "night";
+  const t = THEMES[n];
+  const bg = rgb(t.bg), fg = rgb(t.fg), fg2 = rgb(t.fg2), accent = rgb(t.accent), ok = rgb(t.ok), err = rgb(t.err);
+  return {
+    name: n,
+    label: t.label,
+    bg, bg2: rgb(t.bg2), fg, fg2, muted: rgb(t.muted), dim: rgb(t.dim),
+    rule: rgb(t.rule), rule2: rgb(t.rule2), accent, accent2: rgb(t.accent2),
+    ok, err, warn: rgb(t.warn), info: rgb(t.info), str: rgb(t.str), ty: rgb(t.ty),
+    hlBg: mix(bg, accent, 0.12),
+    addBg: mix(bg, ok, 0.15),
+    delBg: mix(bg, err, 0.15),
+    selBg: mix(bg, fg, 0.08),
+    accentDim: mix(bg, accent, 0.45),
+    okDim: mix(bg, ok, 0.55),
+    mixDim: mix(bg, fg2, 0.55),
+    frame: mix(bg, fg, 0.28),
+    frameDim: mix(bg, fg, 0.17),
+  };
+}
+
+/** style literal: fg, optional bg (-1 = keep the cell's), attribute bits (ATTR) */
+export const st = (fg: number, bg = -1, a = 0): Style => ({ fg, bg, a });

package/src/sextant/tool-rows.ts

@@ -0,0 +1,189 @@
+/** Sextant tool rows (port #41): RunEvent tool name + args → the compact row's verb/label, the
+ *  activity it drives and the code-panel target; tool output → the row's trailing detail. Ported
+ *  from the user's sextant v0.4.0 app.js scenario verbs (read/edit/write/remove/run/search) — here
+ *  derived from rovecode's real tools (coding/hashline.ts, coding/files.ts, tools/webfetch.ts, tools/task.ts). */
+
+import { isAbsolute, relative } from "node:path";
+import type { ActivityState } from "./types.ts";
+
+export interface CallDesc {
+  /** "read" | "edit" | "write" | "remove" | "run" | "search" | "fetch" | "task" | "other" */
+  verb: string;
+  label: string;
+  /** cwd-relative posix path for file tools, else null */
+  path: string | null;
+  /** mark the file touched (diamond spinner) + open the tree to it */
+  touch: boolean;
+  state: ActivityState;
+  activity: string;
+  /** 1-based highlight range for the code panel (read window / edit anchors) */
+  hl: [number, number] | null;
+  add: number;
+  del: number;
+  cmd: string | null;
+}
+
+export interface CallEnd {
+  detail?: string;
+  add?: number;
+  del?: number;
+  /** bash: output lines (exit= header stripped) */
+  runLines?: string[];
+  /** bash: the `exit=N` header's code (absent when the output carries none) */
+  exitCode?: number;
+  /** glob/grep: result lines */
+  searchLines?: string[];
+}
+
+const LABEL_MAX = 48;
+const DETAIL_MAX = 80;
+const SEARCH_LINES_MAX = 500;
+const TEST_CMD = /\b(tests?|vitest|jest|pytest|mocha|spec)\b/i;
+
+const rec = (v: unknown): Record<string, unknown> => (v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : {});
+const str = (v: unknown): string => (typeof v === "string" ? v : "");
+const num = (v: unknown): number | undefined => (typeof v === "number" && Number.isFinite(v) && v > 0 ? Math.floor(v) : undefined);
+
+/** Surrogate-safe clip with an ellipsis (code points, one cell each). */
+export function clipText(s: string, max: number): string {
+  const cps = [...s];
+  return cps.length <= max ? s : cps.slice(0, Math.max(0, max - 1)).join("") + "…";
+}
+/** First non-empty line, whitespace collapsed, clipped. */
+export function firstLine(s: string, max = DETAIL_MAX): string {
+  const line = s.split(/\r?\n/).find((l) => l.trim().length > 0) ?? "";
+  return clipText(line.replace(/\s+/g, " ").trim(), max);
+}
+function lastLine(s: string, max = DETAIL_MAX): string {
+  const lines = s.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  return clipText((lines[lines.length - 1] ?? "").replace(/\s+/g, " ").trim(), max);
+}
+
+/** cwd-relative posix path: absolute paths under cwd become relative, others stay absolute
+ *  (posix separators either way — never a `..` escape, never derived across drives). */
+export function relPath(cwd: string, p: string): string {
+  if (!p) return "";
+  let r = p;
+  if (isAbsolute(p)) {
+    const rel = relative(cwd, p);
+    r = rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : p;
+  } else if (WIN_ABS.test(p)) {
+    // a drive-letter path on a POSIX host (a session replayed from Windows, a model that writes them):
+    // node's path module does not know it is absolute, so relativize by prefix, case-insensitively
+    const P = posixly(p), C = posixly(cwd).replace(/\/+$/, "");
+    if (C && P.toLowerCase().startsWith(C.toLowerCase() + "/")) r = P.slice(C.length + 1);
+  }
+  return posixly(r).replace(/^\.\/+/, "");
+}
+const WIN_ABS = /^[A-Za-z]:[\\/]/;
+const posixly = (s: string): string => s.replace(/\\/g, "/");
+export const baseName = (p: string): string => p.slice(p.lastIndexOf("/") + 1) || p;
+
+function hostOf(url: string): string {
+  try { return new URL(url).host || clipText(url, LABEL_MAX); } catch { return clipText(url, LABEL_MAX) || "url"; }
+}
+const cmdHead = (cmd: string): string => clipText(cmd.replace(/\s+/g, " ").trim(), LABEL_MAX);
+
+const file = (verb: string, cwd: string, a: Record<string, unknown>, state: ActivityState, word: string, extra: Partial<CallDesc> = {}): CallDesc => {
+  const path = relPath(cwd, str(a.path));
+  const base = baseName(path) || "file";
+  return { verb, label: base, path: path || null, touch: true, state, activity: `${word} ${base}`, hl: null, add: 0, del: 0, cmd: null, ...extra };
+};
+
+/** What a starting tool call means for the surface. */
+export function describeCall(tool: string, args: unknown, cwd: string): CallDesc {
+  const a = rec(args);
+  switch (tool) {
+    case "read": {
+      const off = num(a.offset), lim = num(a.limit);
+      const hl: [number, number] | null = off !== undefined || lim !== undefined ? [off ?? 1, (off ?? 1) + (lim ?? 2000) - 1] : null;
+      return file("read", cwd, a, "READING", "reading", { hl });
+    }
+    case "edit": {
+      const edits = Array.isArray(a.edits) ? a.edits : [];
+      let add = 0, lo = Infinity, hi = -Infinity;
+      for (const e of edits) {
+        const r = rec(e);
+        const n = Array.isArray(r.newLines) ? r.newLines.length : 0;
+        add += n;
+        const line = num(r.anchorLine);
+        if (line !== undefined) { lo = Math.min(lo, line); hi = Math.max(hi, line + Math.max(0, n - 1)); }
+      }
+      return file("edit", cwd, a, "EDITING", "editing", { add, del: edits.length, hl: lo <= hi ? [lo, hi] : null });
+    }
+    case "write": {
+      const content = str(a.content);
+      return file("write", cwd, a, "EDITING", "writing", { add: content ? content.split(/\r?\n/).length : 0 });
+    }
+    case "remove": case "rm": case "delete": case "unlink":
+      return file("remove", cwd, a, "EDITING", "removing");
+    case "bash": case "shell": case "run": {
+      const cmd = str(a.command) || str(a.cmd);
+      const head = cmdHead(cmd) || "command";
+      const testing = TEST_CMD.test(cmd);
+      return { verb: "run", label: head, path: null, touch: false, state: testing ? "TESTING" : "RUNNING", activity: testing ? "running tests" : `running ${head}`, hl: null, add: 0, del: 0, cmd };
+    }
+    case "glob": case "grep": {
+      const q = clipText(str(a.pattern), LABEL_MAX) || tool;
+      return { verb: "search", label: q, path: null, touch: false, state: "READING", activity: `searching ${q}`, hl: null, add: 0, del: 0, cmd: null };
+    }
+    case "ls": {
+      const p = relPath(cwd, str(a.path)) || ".";
+      return { verb: "other", label: p, path: null, touch: false, state: "READING", activity: `listing ${p}`, hl: null, add: 0, del: 0, cmd: null };
+    }
+    case "web_fetch": {
+      const host = hostOf(str(a.url));
+      return { verb: "fetch", label: host, path: null, touch: false, state: "READING", activity: `fetching ${host}`, hl: null, add: 0, del: 0, cmd: null };
+    }
+    case "task": {
+      const label = clipText(str(a.label) || str(a.agent) || "task", LABEL_MAX);
+      return { verb: "task", label, path: null, touch: false, state: "DELEGATING", activity: `delegating ${label}`, hl: null, add: 0, del: 0, cmd: null };
+    }
+    case "ask_user":
+      return { verb: "other", label: clipText(firstLine(str(a.question), LABEL_MAX) || "question", LABEL_MAX), path: null, touch: false, state: "WAITING", activity: "waiting for you", hl: null, add: 0, del: 0, cmd: null };
+    case "todo_write": case "todo_read":
+      return { verb: "other", label: "todos", path: null, touch: false, state: "THINKING", activity: "planning", hl: null, add: 0, del: 0, cmd: null };
+    default:
+      return { verb: "other", label: clipText(tool, LABEL_MAX), path: null, touch: false, state: "RUNNING", activity: `running ${tool}`, hl: null, add: 0, del: 0, cmd: null };
+  }
+}
+
+/** Lines of the read window from the footer `(showing lines X-Y of Z)`, else the anchored-line count. */
+function readLineCount(output: string): number {
+  const m = /\(showing lines (\d+)-(\d+) of (\d+)\)/.exec(output);
+  if (m) { const a = Number(m[1]), b = Number(m[2]); return b >= a && a > 0 ? b - a + 1 : 0; }
+  return output.split(/\r?\n/).filter((l) => /^\d+#/.test(l)).length;
+}
+
+/** a rejection's ` at <abs path>:<line>` locator (coding/hashline.ts describeEditFailure): the row's label
+ *  already names the file and the locator alone can fill the 80-cell detail, so the reason and the
+ *  "line N now reads …" tail take its place */
+const dropLocator = (s: string): string => s.replace(/ at \S.*?:\d+(?=\s|$)/, "");
+
+/** The row's trailing detail (and panel payloads) when a tool call ends. A command's output is
+ *  parsed whether it passed or failed (a red test run is exactly when the run panel matters);
+ *  every other failed call reports its first output line — a file tool's without the path locator. */
+export function summarizeEnd(desc: Pick<CallDesc, "verb">, tool: string, ok: boolean, output: string): CallEnd {
+  if (desc.verb === "run") {
+    const m = /^exit=(-?\d+)\r?\n?/.exec(output);
+    const text = m ? output.slice(m[0].length) : output;
+    const lines = text.split(/\r?\n/);
+    while (lines.length && lines[lines.length - 1]!.trim() === "") lines.pop();
+    const last = lastLine(text);
+    return { detail: last || (m ? `exit ${m[1]}` : ""), runLines: lines, ...(m ? { exitCode: Number(m[1]) } : {}) };
+  }
+  if (!ok) return { detail: firstLine(desc.verb === "edit" || desc.verb === "write" ? dropLocator(output) : output) };
+  switch (desc.verb) {
+    case "read": return { detail: `${readLineCount(output)} lines` };
+    case "edit": return {};
+    case "write": { const m = /\((\d+) bytes/.exec(output); return m ? { detail: `${m[1]} bytes` } : {}; }
+    case "remove": return {};
+    case "search": {
+      const lines = output.split(/\r?\n/).filter((l) => l.trim().length > 0);
+      const hits = lines.filter((l) => !l.startsWith("(")).length;
+      return { detail: `${hits} ${tool === "glob" ? (hits === 1 ? "file" : "files") : (hits === 1 ? "match" : "matches")}`, searchLines: lines.slice(0, SEARCH_LINES_MAX) };
+    }
+    case "fetch": return { detail: `${output.length} chars` };
+    default: return { detail: firstLine(output) };
+  }
+}