rovecode 0.4.0-beta.2 → 0.4.0

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) };
+  }
+}