@moondeck/station 0.0.1 → 1.0.0

package/lib/git-diff.ts

@@ -0,0 +1,530 @@
+/**
+ * Parse `git diff` unified output into structured per-file patches.
+ *
+ * Input is whatever `git diff <merge-base>` (committed + uncommitted) plus
+ * appended `--no-index` new-file patches for untracked files produce —
+ * multi-file, with headers, mode/rename/binary annotations, and `@@` hunks.
+ * The output is a list of `DiffFile`s the UI can render per-file with
+ * collapse/expand and syntax-highlighted hunks.
+ *
+ * Hand-rolled rather than pulled in as a dep — the unified-diff grammar
+ * is small and the chat-side Markdown renderer already sets the
+ * dependency-free precedent (see components/markdown.tsx).
+ */
+
+import { RUNTIME_AUTHORITY_ENV } from "./runtime-authority";
+import type {
+  TaskEnvironmentExecRequest,
+  TaskEnvironmentExecResult,
+} from "./task-environment/types";
+
+export type DiffStatus =
+  | "added"
+  | "deleted"
+  | "modified"
+  | "renamed"
+  | "copied"
+  | "binary";
+
+export interface DiffLine {
+  /** ' ' for context, '+' for added, '-' for removed. */
+  kind: "ctx" | "add" | "del";
+  /** Line content without the leading marker. */
+  content: string;
+  /** Line number in the old file (1-based) for ctx/del lines. */
+  oldNo?: number;
+  /** Line number in the new file (1-based) for ctx/add lines. */
+  newNo?: number;
+}
+
+export interface DiffHunk {
+  oldStart: number;
+  oldLines: number;
+  newStart: number;
+  newLines: number;
+  /** Raw `@@ ... @@` header text, useful for the section label git
+   *  sometimes includes after the second `@@`. */
+  header: string;
+  lines: DiffLine[];
+}
+
+export interface DiffFile {
+  path: string;
+  /** Set on rename / copy — the source path before the change. */
+  oldPath?: string;
+  status: DiffStatus;
+  /** Best-effort language hint based on the file extension. */
+  language?: string;
+  /** A `Binary files … differ` patch has no hunks. */
+  binary: boolean;
+  hunks: DiffHunk[];
+}
+
+/** How every patch is rendered: no colour, no external diff driver, the
+ *  usual a/ b/ prefixes, paths as they are. */
+const GIT_DIFF_ARGS = "-c core.quotepath=false diff --no-color --no-ext-diff --src-prefix=a/ --dst-prefix=b/";
+
+const NON_INTERACTIVE_GIT_ENV = {
+  GIT_TERMINAL_PROMPT: "0",
+  GCM_INTERACTIVE: "never",
+  GIT_SSH_COMMAND: "ssh -o BatchMode=yes",
+};
+
+/** A diff's bound on what each of a project's producers may give: its
+ *  tracked patches, and its untracked ones. Past it, the project's diff is
+ *  an error, never a partial patch. */
+export const TASK_DIFF_PATCH_BYTES = 8 * 1024 * 1024;
+/** A diff's bound on its whole output, however many projects it has: the
+ *  projects past it are errors. */
+export const TASK_DIFF_OUTPUT_BYTES = 48 * 1024 * 1024;
+/** A diff's bound on the lines it renders, every project of it: each line
+ *  becomes an object, so a valid patch of millions of tiny lines within the
+ *  byte bounds would otherwise cost the runner hundreds of MiB to parse. A
+ *  project that would pass what is left of it is an error, unparsed. */
+export const TASK_DIFF_MAX_LINES = 100_000;
+/** A diff's bound on its result as the runner sends it: JSON-escaped, a
+ *  patch's control bytes take six bytes each, so patches within the byte and
+ *  line bounds could still serialize past the bridge's frame limit (100 MiB)
+ *  and get the runner's connection closed. A project that would pass what is
+ *  left of it is an error, unparsed. */
+export const TASK_DIFF_RESULT_BYTES = 48 * 1024 * 1024;
+/** What each rendered line adds to the result beyond its own text: its
+ *  object, keys and line numbers. */
+export const TASK_DIFF_LINE_RESULT_BYTES = 96;
+/** What each project's entry may take in the result besides its files: its
+ *  id, name, path, base and error, each at its bound and JSON-escaped at
+ *  worst, and their keys. Reserved from the result bound up front. */
+export const TASK_DIFF_REPO_RESULT_BYTES = 16 * 1024;
+/** A project's reported error, and its base, at most: both are the task's
+ *  own (its Git's stderr, its remote's default branch). */
+export const TASK_DIFF_ERROR_CHARS = 1024;
+export const TASK_DIFF_BASE_CHARS = 256;
+/** How long a diff may take, every project of it: it is killed inside its
+ *  runtime past this, everything it started with it. */
+export const TASK_DIFF_TIMEOUT_MS = 300_000;
+/** Cap how many untracked files are rendered as new-file patches, so a
+ *  pathological untracked directory that slips past .gitignore cannot
+ *  turn one diff into thousands of patches. */
+export const MAX_UNTRACKED = 200;
+
+/**
+ * `bounded CMD...` (POSIX sh): runs CMD with its output in `$tmp/out` (at
+ * most `$limit` bytes), its errors in `$tmp/err` (at most 4 KiB) and its
+ * status in `$tmp/status`. Each stream goes through a pipe whose reader
+ * stops at its bound, so a writer past it is stopped (SIGPIPE) and nothing
+ * past it is held, in memory or on disk.
+ */
+export const TASK_DIFF_BOUNDED = [
+  "bounded() {",
+  '  echo 1 >"$tmp/status"',
+  '  { { "$@"; echo "$?" >"$tmp/status"; } 2>&1 1>&3 3>&- | head -c 4096 >"$tmp/err"; } 3>&1 | head -c "$limit" >"$tmp/out"',
+  "}",
+].join("\n");
+
+/**
+ * A task's whole diff, as one POSIX sh run in the task's environment (its
+ * runtime while it runs, a stopped task's sandbox otherwise; never the
+ * host, #cb3j0z): `$1` the bound on each producer's bytes, `$2` the
+ * untracked bound, `$3` the bound on the whole output, then each project's
+ * directory below the working directory. For each project it resolves the
+ * base (the remote's default branch, `origin/HEAD`, else `origin/main`:
+ * never the worktree's upstream, which flips to the pushed task branch and
+ * would hide all committed work), diffs the merge-base against the working
+ * tree (committed + staged + unstaged), and renders each untracked file
+ * (honouring .gitignore) as a new-file patch.
+ *
+ * Whatever runs for it, the task's own config drivers included, is bounded
+ * where it writes: its output at one byte past the bound and its errors at
+ * 4 KiB, each through a pipe that stops the writer once full, so nothing it
+ * produces is held beyond that, in memory or on disk.
+ *
+ * Every value is a line `<kind> <base64>`, so any bytes survive whatever
+ * carries them: `P` a project, then either `E` an error, or `B` its base,
+ * `D` its tracked patches and `U` its untracked ones (or `E`). The whole
+ * output stops at its bound.
+ */
+export const TASK_DIFF_SCRIPT = [
+  "set -u",
+  'each=$1; most=$2; cap=$3; shift 3',
+  'limit=$((each + 1))',
+  'tmp=$(mktemp -d "${TMPDIR:-/tmp}/uai-task-diff.XXXXXX") || exit 70',
+  "trap 'rm -rf \"$tmp\"' EXIT",
+  "root=$(pwd)",
+  'frame() { printf "%s " "$1"; base64 -w0 <"$2"; printf "\\n"; }',
+  'value() { printf "%s" "$2" >"$tmp/value"; frame "$1" "$tmp/value"; }',
+  TASK_DIFF_BOUNDED,
+  'over() { [ "$(wc -c <"$tmp/out")" -gt "$each" ]; }',
+  "untracked() {",
+  '  git ls-files --others --exclude-standard -z 2>/dev/null | head -z -n "$most" \\',
+  `    | xargs -0 -r -n 1 sh -c 'git ${GIT_DIFF_ARGS} --no-index -- /dev/null "$1"; [ $? -le 1 ] || exit 255' untracked`,
+  "}",
+  "projects() {",
+  '  for slug in "$@"; do',
+  '    value P "$slug"',
+  '    if ! cd -- "$root/$slug" 2>/dev/null; then value E "not a project directory: $slug"; continue; fi',
+  "    base=$(git rev-parse --abbrev-ref origin/HEAD 2>/dev/null) || base=",
+  '    [ -n "$base" ] || base=origin/main',
+  '    value B "$base"',
+  '    merge=$(git merge-base "$base" HEAD 2>/dev/null) || merge=',
+  '    [ -n "$merge" ] || merge=$base',
+  `    bounded git ${GIT_DIFF_ARGS} "$merge"`,
+  '    if over; then value E "the diff exceeded $each bytes"',
+  '    elif [ "$(cat "$tmp/status")" != 0 ]; then frame E "$tmp/err"',
+  "    else",
+  '      frame D "$tmp/out"',
+  "      bounded untracked",
+  '      if over; then value E "the untracked files exceeded $each bytes"',
+  '      elif [ "$(cat "$tmp/status")" != 0 ]; then frame E "$tmp/err"',
+  '      else frame U "$tmp/out"; fi',
+  "    fi",
+  '    cd -- "$root"',
+  "  done",
+  "}",
+  'projects "$@" | head -c "$cap"',
+].join("\n");
+
+/**
+ * The one exec of a task's diff of `slugs`, below `workspacePath`: killed
+ * inside the runtime at its deadline, the shell and everything it started
+ * (`timeout` signals their whole group), however the client that started it
+ * ended.
+ */
+export function taskDiffRequest(
+  workspacePath: string,
+  slugs: readonly string[],
+): TaskEnvironmentExecRequest {
+  return {
+    projectEnvProfile: "maintenance",
+    argv: [
+      "/usr/bin/timeout",
+      "--signal=KILL",
+      String(TASK_DIFF_TIMEOUT_MS / 1000),
+      "/bin/sh",
+      "-c",
+      TASK_DIFF_SCRIPT,
+      "uai-task-diff",
+      String(TASK_DIFF_PATCH_BYTES),
+      String(MAX_UNTRACKED),
+      String(TASK_DIFF_OUTPUT_BYTES),
+      ...slugs,
+    ],
+    cwd: workspacePath,
+    env: { ...RUNTIME_AUTHORITY_ENV, ...NON_INTERACTIVE_GIT_ENV },
+    // The client's own bound, past the runtime's.
+    timeoutMs: TASK_DIFF_TIMEOUT_MS + 15_000,
+    // The script stops at its bound; past it, the exec itself is cut.
+    maxOutputBytes: TASK_DIFF_OUTPUT_BYTES + 1024 * 1024,
+  };
+}
+
+/**
+ * The bytes `JSON.stringify(text)` takes, counted without making it: two
+ * for each quote or backslash and for each control character with a short
+ * escape, six for any other control character or lone surrogate, and each
+ * other character's UTF-8 width, plus the quotes around it.
+ */
+export function jsonEscapedBytes(text: string): number {
+  let bytes = 2;
+  for (let index = 0; index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    if (code === 0x22 || code === 0x5c) bytes += 2;
+    else if (code < 0x20) {
+      bytes += code === 0x08 || code === 0x09 || code === 0x0a || code === 0x0c || code === 0x0d ? 2 : 6;
+    } else if (code < 0x80) bytes += 1;
+    else if (code < 0x800) bytes += 2;
+    else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length && (text.charCodeAt(index + 1) & 0xfc00) === 0xdc00) {
+      bytes += 4;
+      index += 1;
+    } else if (code >= 0xd800 && code <= 0xdfff) bytes += 6;
+    else bytes += 3;
+  }
+  return bytes;
+}
+
+/** How many lines `text` holds, counted without parsing it (the last one
+ *  counts without its newline). */
+export function countDiffLines(text: string): number {
+  let lines = 0;
+  let at = text.indexOf("\n");
+  while (at !== -1) {
+    lines += 1;
+    at = text.indexOf("\n", at + 1);
+  }
+  return text.length > 0 && !text.endsWith("\n") ? lines + 1 : lines;
+}
+
+/** One project of a diff's output. */
+export interface TaskDiffProjectOutput {
+  slug: string;
+  base?: string;
+  /** Its tracked patches, then its untracked ones. */
+  patches?: string;
+  tracked?: boolean;
+  untracked?: boolean;
+  error?: string;
+}
+
+/**
+ * The projects of a diff's output (`TASK_DIFF_SCRIPT`), in order. Only whole
+ * lines count: a line the bound cut short is dropped, and its project is
+ * left without the value.
+ */
+export function parseTaskDiffOutput(output: string): TaskDiffProjectOutput[] {
+  const projects: TaskDiffProjectOutput[] = [];
+  const lines = output.split("\n");
+  // The last element follows the last newline: whole only when empty.
+  lines.pop();
+  for (const line of lines) {
+    if (line.length < 2 || line[1] !== " " || !/^[A-Za-z0-9+/]*={0,2}$/.test(line.slice(2))) continue;
+    const value = Buffer.from(line.slice(2), "base64").toString("utf8");
+    const kind = line[0];
+    if (kind === "P") {
+      projects.push({ slug: value });
+      continue;
+    }
+    const project = projects.at(-1);
+    if (!project) continue;
+    if (kind === "B") project.base = value.slice(0, TASK_DIFF_BASE_CHARS);
+    else if (kind === "E") project.error = value.trim().slice(0, TASK_DIFF_ERROR_CHARS) || "the diff failed";
+    else if (kind === "D") {
+      project.patches = value;
+      project.tracked = true;
+    } else if (kind === "U") {
+      if (project.patches && value.length > 0 && !project.patches.endsWith("\n")) project.patches += "\n";
+      project.patches = (project.patches ?? "") + value;
+      project.untracked = true;
+    }
+  }
+  return projects;
+}
+
+/** Why a diff's exec gave nothing to parse: no exit, a failed one, or an
+ *  output past its bound. Null when it can be parsed. */
+export function taskDiffExecFailure(result: TaskEnvironmentExecResult): string | null {
+  if (result.stdoutTruncated || result.stderrTruncated) return "the diff exceeded its output bound";
+  if (result.exitCode === 0) return null;
+  const stderr = Buffer.from(result.stderr).toString("utf8").trim().slice(0, TASK_DIFF_ERROR_CHARS - 64);
+  const outcome =
+    result.exitCode === null
+      ? result.signal
+        ? `was terminated by ${result.signal}`
+        : "did not start"
+      : `exited ${result.exitCode}`;
+  return `the task diff ${outcome}${stderr ? `: ${stderr}` : ""}`;
+}
+
+/**
+ * Parse the output of `git diff` into structured file patches.
+ */
+export function parseGitDiff(text: string): DiffFile[] {
+  if (!text) return [];
+  const lines = text.split("\n");
+  const files: DiffFile[] = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    if (!line.startsWith("diff --git ")) {
+      i += 1;
+      continue;
+    }
+    // Each file section starts with `diff --git a/<path> b/<path>` and
+    // runs to the next `diff --git` line (or EOF).
+    const header = parseDiffGitHeader(line);
+    let path = header.bPath ?? header.aPath ?? "";
+    let oldPath: string | undefined;
+    let status: DiffStatus = "modified";
+    let binary = false;
+    const hunks: DiffHunk[] = [];
+
+    i += 1;
+    while (i < lines.length && !(lines[i] ?? "").startsWith("diff --git ")) {
+      const ln = lines[i] ?? "";
+      if (ln.startsWith("new file mode")) status = "added";
+      else if (ln.startsWith("deleted file mode")) status = "deleted";
+      else if (ln.startsWith("rename from ")) {
+        status = "renamed";
+        oldPath = ln.slice("rename from ".length);
+      } else if (ln.startsWith("rename to ")) {
+        path = ln.slice("rename to ".length);
+      } else if (ln.startsWith("copy from ")) {
+        status = "copied";
+        oldPath = ln.slice("copy from ".length);
+      } else if (ln.startsWith("copy to ")) {
+        path = ln.slice("copy to ".length);
+      } else if (ln.startsWith("Binary files ")) {
+        binary = true;
+        status = status === "modified" ? "binary" : status;
+      } else if (ln.startsWith("--- ")) {
+        const p = stripPathPrefix(ln.slice(4));
+        if (p !== "/dev/null" && status === "modified") oldPath = oldPath ?? p;
+        if (p === "/dev/null") status = "added";
+      } else if (ln.startsWith("+++ ")) {
+        const p = stripPathPrefix(ln.slice(4));
+        if (p !== "/dev/null") path = p;
+        else status = "deleted";
+      } else if (ln.startsWith("@@")) {
+        const { hunk, consumed } = parseHunk(lines, i);
+        if (hunk) hunks.push(hunk);
+        i += consumed;
+        continue;
+      }
+      i += 1;
+    }
+
+    files.push({
+      path,
+      oldPath: oldPath && oldPath !== path ? oldPath : undefined,
+      status,
+      language: languageFor(path),
+      binary,
+      hunks,
+    });
+  }
+
+  return files;
+}
+
+function parseDiffGitHeader(line: string): {
+  aPath?: string;
+  bPath?: string;
+} {
+  // `diff --git a/foo b/foo` — paths may contain spaces if quoted.
+  // Quoted form is `diff --git "a/path with space" "b/path with space"`.
+  // For simplicity (uai paths are well-behaved), greedy match on the
+  // common forms.
+  const m = line.match(
+    /^diff --git (?:"a\/(.*?)"|a\/(\S+)) (?:"b\/(.*?)"|b\/(\S+))$/,
+  );
+  if (!m) return {};
+  const a = m[1] ?? m[2];
+  const b = m[3] ?? m[4];
+  return { aPath: a, bPath: b };
+}
+
+function stripPathPrefix(s: string): string {
+  // `a/foo`, `b/foo`, or `/dev/null`. Quoted form: `"a/foo"`.
+  const t = s.trim().replace(/^"(.*)"$/, "$1");
+  if (t === "/dev/null") return t;
+  if (t.startsWith("a/") || t.startsWith("b/")) return t.slice(2);
+  return t;
+}
+
+function parseHunk(
+  lines: string[],
+  start: number,
+): { hunk: DiffHunk | null; consumed: number } {
+  const headerLine = lines[start] ?? "";
+  // `@@ -<oldStart>,<oldLines> +<newStart>,<newLines> @@ optional label`
+  const m = headerLine.match(
+    /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@ ?(.*)$/,
+  );
+  if (!m) return { hunk: null, consumed: 1 };
+  const oldStart = Number(m[1]);
+  const oldLines = m[2] === undefined ? 1 : Number(m[2]);
+  const newStart = Number(m[3]);
+  const newLines = m[4] === undefined ? 1 : Number(m[4]);
+  const header = m[5] ?? "";
+
+  const out: DiffLine[] = [];
+  let oldNo = oldStart;
+  let newNo = newStart;
+  let i = start + 1;
+  let oldSeen = 0;
+  let newSeen = 0;
+
+  while (i < lines.length) {
+    const ln = lines[i] ?? "";
+    // End conditions: next hunk in the same file, next file, or EOF.
+    if (ln.startsWith("@@") || ln.startsWith("diff --git ")) break;
+    // `` markers — annotate the previous
+    // line by not advancing counters. Just skip.
+    if (ln.startsWith("\\ ")) {
+      i += 1;
+      continue;
+    }
+    const c = ln.charAt(0);
+    if (c === "+") {
+      out.push({ kind: "add", content: ln.slice(1), newNo });
+      newNo += 1;
+      newSeen += 1;
+    } else if (c === "-") {
+      out.push({ kind: "del", content: ln.slice(1), oldNo });
+      oldNo += 1;
+      oldSeen += 1;
+    } else if (c === " " || ln === "") {
+      // Context line. Git emits a space prefix for context; an empty
+      // line in unified diff is still a context line (an empty file
+      // line).
+      out.push({
+        kind: "ctx",
+        content: c === " " ? ln.slice(1) : "",
+        oldNo,
+        newNo,
+      });
+      oldNo += 1;
+      newNo += 1;
+      oldSeen += 1;
+      newSeen += 1;
+    } else {
+      // Anything else — probably the start of metadata for a fresh
+      // file we somehow didn't catch. Bail out so the outer loop can
+      // re-process it.
+      break;
+    }
+    i += 1;
+    // Hunks are self-delimiting by their counts. Once we've consumed
+    // them, stop — anything further belongs to the next section.
+    if (oldSeen >= oldLines && newSeen >= newLines) break;
+  }
+
+  return {
+    hunk: {
+      oldStart,
+      oldLines,
+      newStart,
+      newLines,
+      header,
+      lines: out,
+    },
+    consumed: i - start,
+  };
+}
+
+const LANG_BY_EXT: Record<string, string> = {
+  ts: "typescript",
+  tsx: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  json: "json",
+  md: "markdown",
+  mdx: "markdown",
+  css: "css",
+  scss: "scss",
+  html: "html",
+  yml: "yaml",
+  yaml: "yaml",
+  toml: "toml",
+  py: "python",
+  rb: "ruby",
+  go: "go",
+  rs: "rust",
+  java: "java",
+  c: "c",
+  h: "c",
+  cpp: "cpp",
+  hpp: "cpp",
+  sh: "bash",
+  bash: "bash",
+  sql: "sql",
+  swift: "swift",
+  kt: "kotlin",
+  php: "php",
+};
+
+function languageFor(path: string): string | undefined {
+  const ext = path.includes(".") ? path.split(".").pop()!.toLowerCase() : "";
+  return LANG_BY_EXT[ext];
+}