rovecode 0.3.3 → 0.4.0-beta.2

package/src/sextant/sextant-repo.ts

@@ -1,140 +0,0 @@
-/** 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

@@ -1,66 +0,0 @@
-/** 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

@@ -1,189 +0,0 @@
-/** 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) };
-  }
-}