@coldtea/abide 0.0.1

package/src/lib/replayCodex.ts

@@ -0,0 +1,130 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { postToolUseInputSchema } from "@coldtea/abide-schema";
+import { MAX_TASK_CHARS } from "./constants.js";
+import type { ReplaySession, ReplayTurn } from "./replay.js";
+
+/** One rollout file per session, one JSON object per line. An `apply_patch` call carries the same patch text the live hook receives. */
+export const codexSessionsDir = (): string => path.join(homedir(), ".codex", "sessions");
+
+const asRecord = (value: unknown): Record<string, unknown> | undefined => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const record: Record<string, unknown> = { ...value };
+  return record;
+};
+
+const asList = (value: unknown): unknown[] => (Array.isArray(value) ? value : []);
+
+/** Codex's own additions to a user turn, not prompts. */
+const INJECTED = [
+  "# AGENTS.md instructions",
+  "<environment_context>",
+  "<permissions instructions>",
+  "<turn_aborted>",
+  "\n# Files mentioned by the user",
+];
+
+const promptOf = (payload: Record<string, unknown>): string | undefined => {
+  const text = asList(payload.content)
+    .flatMap((c) => {
+      const part = asRecord(c);
+      return part?.type === "input_text" && typeof part.text === "string" ? [part.text] : [];
+    })
+    .join("\n");
+  if (text.trim() === "" || INJECTED.some((prefix) => text.startsWith(prefix))) return undefined;
+  return text.slice(0, MAX_TASK_CHARS);
+};
+
+const FAILED_OUTPUT = /^apply_patch (verification )?failed|^error/i;
+
+export const parseCodexRollout = (file: string): ReplaySession => {
+  const turns: ReplayTurn[] = [];
+  const pending = new Map<string, { turn: ReplayTurn; command: string }>();
+  let cwd: string | undefined;
+  let turnIndex = 0;
+  const current = (): ReplayTurn => {
+    const last = turns.at(-1);
+    if (last !== undefined) return last;
+    const first: ReplayTurn = { index: 0, prompt: undefined, edits: [] };
+    turns.push(first);
+    return first;
+  };
+  const sessionId = path.basename(file, ".jsonl");
+  for (const line of readFileSync(file, "utf8").split("\n")) {
+    if (line.trim() === "") continue;
+    let entry: Record<string, unknown> | undefined;
+    try {
+      entry = asRecord(JSON.parse(line));
+    } catch {
+      // a torn line, still being written
+      continue;
+    }
+    const payload = asRecord(entry?.payload);
+    if (entry === undefined || payload === undefined) continue;
+    if (entry.type === "session_meta" && typeof payload.cwd === "string") cwd ??= payload.cwd;
+    if (entry.type !== "response_item") continue;
+    if (payload.type === "message" && payload.role === "user") {
+      const prompt = promptOf(payload);
+      if (prompt === undefined) continue;
+      turnIndex += 1;
+      turns.push({ index: turnIndex, prompt, edits: [] });
+      continue;
+    }
+    if (
+      payload.type === "custom_tool_call" &&
+      payload.name === "apply_patch" &&
+      typeof payload.call_id === "string" &&
+      typeof payload.input === "string"
+    ) {
+      pending.set(payload.call_id, { turn: current(), command: payload.input });
+      continue;
+    }
+    if (payload.type === "custom_tool_call_output" && typeof payload.call_id === "string") {
+      const call = pending.get(payload.call_id);
+      pending.delete(payload.call_id);
+      if (call === undefined) continue;
+      // a patch that did not apply changed nothing
+      if (typeof payload.output === "string" && FAILED_OUTPUT.test(payload.output)) continue;
+      const parsed = postToolUseInputSchema.safeParse({
+        session_id: sessionId,
+        cwd: cwd ?? process.cwd(),
+        hook_event_name: "PostToolUse",
+        tool_name: "apply_patch",
+        tool_use_id: payload.call_id,
+        tool_input: { command: call.command },
+      });
+      if (parsed.success) call.turn.edits.push({ turn: call.turn.index, input: parsed.data });
+    }
+  }
+  return { file, cwd: cwd ?? process.cwd(), turns: turns.filter((t) => t.edits.length > 0) };
+};
+
+const rolloutFiles = (dir: string): string[] => {
+  let names: string[];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.flatMap((name) => {
+    const full = path.join(dir, name);
+    try {
+      if (statSync(full).isDirectory()) return rolloutFiles(full);
+    } catch {
+      return [];
+    }
+    return name.startsWith("rollout-") && name.endsWith(".jsonl") ? [full] : [];
+  });
+};
+
+const inside = (root: string, dir: string): boolean => {
+  const rel = path.relative(root, dir);
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+};
+
+export const codexSessionsFor = (root: string, dir = codexSessionsDir()): ReplaySession[] =>
+  rolloutFiles(dir)
+    .sort()
+    .map(parseCodexRollout)
+    .filter((s) => inside(root, s.cwd) && s.turns.length > 0);

package/src/lib/replayOpencode.ts

@@ -0,0 +1,186 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { AbideError, postToolUseInputSchema } from "@coldtea/abide-schema";
+import { MAX_TASK_CHARS } from "./constants.js";
+import type { ReplaySession, ReplayTurn } from "./replay.js";
+
+/** Sessions live in SQLite. The `sqlite3` binary reads it so the CLI needs no driver. */
+export const opencodeDbPath = (): string =>
+  path.join(homedir(), ".local", "share", "opencode", "opencode.db");
+
+export type OpencodeRow = {
+  sessionId: string;
+  directory: string;
+  messageId: string;
+  role: string;
+  created: number;
+  part: string;
+};
+
+const asRecord = (value: unknown): Record<string, unknown> | undefined => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const record: Record<string, unknown> = { ...value };
+  return record;
+};
+
+const query = (db: string, sql: string): unknown[] => {
+  const result = spawnSync("sqlite3", ["-json", "-readonly", db, sql], {
+    encoding: "utf8",
+    maxBuffer: 512 * 1024 * 1024,
+  });
+  if (result.error !== undefined)
+    throw new AbideError(
+      "GIT_UNAVAILABLE",
+      "sqlite3 is not on PATH, and OpenCode sessions live in a SQLite database",
+      {
+        cause: result.error,
+      },
+    );
+  if (result.status !== 0)
+    throw new AbideError(
+      "GIT_UNAVAILABLE",
+      `sqlite3 could not read ${db}: ${result.stderr.trim()}`,
+    );
+  if (result.stdout.trim() === "") return [];
+  const parsed: unknown = JSON.parse(result.stdout);
+  return Array.isArray(parsed) ? parsed : [];
+};
+
+export const readOpencodeRows = (db: string): OpencodeRow[] =>
+  query(
+    db,
+    `select s.id as sessionId, s.directory as directory, m.id as messageId,
+            json_extract(m.data, '$.role') as role, m.time_created as created, p.data as part
+       from part p
+       join message m on m.id = p.message_id
+       join session s on s.id = m.session_id
+      order by s.id, m.time_created, m.id, p.id`,
+  ).flatMap((row) => {
+    const r = asRecord(row);
+    if (
+      r === undefined ||
+      typeof r.sessionId !== "string" ||
+      typeof r.directory !== "string" ||
+      typeof r.messageId !== "string" ||
+      typeof r.role !== "string" ||
+      typeof r.created !== "number" ||
+      typeof r.part !== "string"
+    )
+      return [];
+    return [
+      {
+        sessionId: r.sessionId,
+        directory: r.directory,
+        messageId: r.messageId,
+        role: r.role,
+        created: r.created,
+        part: r.part,
+      },
+    ];
+  });
+
+/** The same payload the live plugin builds. */
+const editPayload = (
+  sessionId: string,
+  directory: string,
+  callId: string,
+  tool: string,
+  input: Record<string, unknown>,
+): unknown => {
+  const file = typeof input.filePath === "string" ? input.filePath : "";
+  if (file === "") return undefined;
+  const file_path = path.isAbsolute(file) ? file : path.join(directory, file);
+  const base = {
+    session_id: sessionId,
+    cwd: directory,
+    hook_event_name: "PostToolUse",
+    tool_use_id: callId,
+  };
+  switch (tool) {
+    case "edit":
+      return {
+        ...base,
+        tool_name: "Edit",
+        tool_input: {
+          file_path,
+          old_string: String(input.oldString ?? ""),
+          new_string: String(input.newString ?? ""),
+          replace_all: Boolean(input.replaceAll),
+        },
+      };
+    case "write":
+      return {
+        ...base,
+        tool_name: "Write",
+        tool_input: { file_path, content: String(input.content ?? "") },
+        tool_response: { filePath: file_path, originalFile: null },
+      };
+    default:
+      return undefined;
+  }
+};
+
+export const opencodeSessionsFromRows = (
+  root: string,
+  rows: readonly OpencodeRow[],
+): ReplaySession[] => {
+  const sessions = new Map<string, ReplaySession & { turnIndex: number; lastMessage?: string }>();
+  for (const row of rows) {
+    const rel = path.relative(root, row.directory);
+    if (rel !== "" && (rel.startsWith("..") || path.isAbsolute(rel))) continue;
+    let session = sessions.get(row.sessionId);
+    if (session === undefined) {
+      session = { file: row.sessionId, cwd: row.directory, turns: [], turnIndex: 0 };
+      sessions.set(row.sessionId, session);
+    }
+    let part: Record<string, unknown> | undefined;
+    try {
+      part = asRecord(JSON.parse(row.part));
+    } catch {
+      continue;
+    }
+    if (part === undefined) continue;
+    if (row.role === "user") {
+      if (session.lastMessage !== row.messageId) {
+        session.lastMessage = row.messageId;
+        session.turnIndex += 1;
+        session.turns.push({ index: session.turnIndex, prompt: undefined, edits: [] });
+      }
+      const turn = session.turns.at(-1);
+      if (turn !== undefined && part.type === "text" && typeof part.text === "string") {
+        const text = part.text.trim();
+        if (text !== "" && !text.startsWith("Abide:"))
+          turn.prompt = `${turn.prompt === undefined ? "" : `${turn.prompt}\n`}${text}`.slice(
+            0,
+            MAX_TASK_CHARS,
+          );
+      }
+      continue;
+    }
+    if (part.type !== "tool" || typeof part.tool !== "string" || typeof part.callID !== "string")
+      continue;
+    const state = asRecord(part.state);
+    const input = asRecord(state?.input);
+    if (state?.status !== "completed" || input === undefined) continue;
+    const payload = editPayload(row.sessionId, row.directory, part.callID, part.tool, input);
+    if (payload === undefined) continue;
+    const parsed = postToolUseInputSchema.safeParse(payload);
+    if (!parsed.success) continue;
+    let turn: ReplayTurn | undefined = session.turns.at(-1);
+    if (turn === undefined) {
+      turn = { index: 0, prompt: undefined, edits: [] };
+      session.turns.push(turn);
+    }
+    turn.edits.push({ turn: turn.index, input: parsed.data });
+  }
+  return [...sessions.values()]
+    .map(({ file, cwd, turns }) => ({ file, cwd, turns: turns.filter((t) => t.edits.length > 0) }))
+    .filter((s) => s.turns.length > 0);
+};
+
+export const opencodeSessionsFor = (root: string, db = opencodeDbPath()): ReplaySession[] => {
+  if (!existsSync(db)) throw new AbideError("RUBRIC_MISSING", `no OpenCode database at ${db}`);
+  return opencodeSessionsFromRows(root, readOpencodeRows(db));
+};

package/src/lib/rubricFile.ts

@@ -0,0 +1,99 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import {
+  rubricSchema,
+  type CheckType,
+  type Rubric,
+  type Rule,
+  type RuleStatus,
+} from "@coldtea/abide-schema";
+import { hashFile } from "./sources.js";
+import { canonicalSourcePath, resolveSourcePath } from "./paths.js";
+import { readRegularText } from "./regularFile.js";
+
+export type RubricRead =
+  | { kind: "missing"; path: string }
+  | { kind: "invalid"; path: string; issues: string[] }
+  | { kind: "ok"; path: string; rubric: Rubric };
+
+export const readRubric = (file: string): RubricRead => {
+  const raw = readRegularText(file);
+  if (raw === undefined) return { kind: "missing", path: file };
+  let json: unknown;
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "not JSON";
+    return { kind: "invalid", path: file, issues: [message] };
+  }
+  const parsed = rubricSchema.safeParse(json);
+  if (!parsed.success) {
+    return {
+      kind: "invalid",
+      path: file,
+      issues: parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`),
+    };
+  }
+  return { kind: "ok", path: file, rubric: parsed.data };
+};
+
+export const writeRubric = (file: string, rubric: Rubric): void => {
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(rubric, null, 2)}\n`);
+};
+
+/** Hashes every source and settles on one spelling for each path, in sources and in rules. */
+export const fillSourceShas = (
+  rubric: Rubric,
+  root: string,
+): { rubric: Rubric; missing: string[] } => {
+  const missing: string[] = [];
+  const sources = rubric.sources.map((source) => {
+    const canonical = canonicalSourcePath(root, source.path);
+    const sha = hashFile(resolveSourcePath(root, source.path));
+    if (sha === undefined) {
+      missing.push(source.path);
+      return { ...source, path: canonical };
+    }
+    return { ...source, path: canonical, sha };
+  });
+  const rules = rubric.rules.map((rule) => ({
+    ...rule,
+    source: { ...rule.source, path: canonicalSourcePath(root, rule.source.path) },
+  }));
+  return { rubric: { ...rubric, sources, rules }, missing };
+};
+
+export type MergedRule = Rule & { origin: "project" | "global" };
+
+/** Project rules win on an id clash. */
+export const mergeRules = (
+  project: Rubric | undefined,
+  global: Rubric | undefined,
+): MergedRule[] => {
+  const byId = new Map<string, MergedRule>();
+  for (const rule of global?.rules ?? []) byId.set(rule.id, { ...rule, origin: "global" });
+  for (const rule of project?.rules ?? []) byId.set(rule.id, { ...rule, origin: "project" });
+  return [...byId.values()];
+};
+
+export type BucketCounts = Record<CheckType, number> & {
+  total: number;
+  byStatus: Record<RuleStatus, number>;
+};
+
+export const bucketCounts = (rules: readonly Rule[]): BucketCounts => {
+  const counts: BucketCounts = {
+    lint: 0,
+    model: 0,
+    deferred: 0,
+    unenforceable: 0,
+    total: rules.length,
+    byStatus: { active: 0, weak: 0, noisy: 0, disabled: 0 },
+  };
+  for (const rule of rules) {
+    counts[rule.check.type] += 1;
+    counts.byStatus[rule.status] += 1;
+  }
+  return counts;
+};

package/src/lib/scope.ts

@@ -0,0 +1,18 @@
+import picomatch from "picomatch";
+import type { Rule } from "@coldtea/abide-schema";
+
+const matchers = new Map<string, (p: string) => boolean>();
+
+const matcherFor = (globs: readonly string[]): ((p: string) => boolean) => {
+  const key = globs.join("\n");
+  let m = matchers.get(key);
+  if (m === undefined) {
+    m = picomatch([...globs], { dot: true });
+    matchers.set(key, m);
+  }
+  return m;
+};
+
+/** Repo-relative posix path against the rule's globs. No scope means every file. */
+export const ruleAppliesTo = (rule: Pick<Rule, "scope">, relativePath: string): boolean =>
+  rule.scope === undefined || matcherFor(rule.scope)(relativePath);

package/src/lib/session.ts

@@ -0,0 +1,223 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { MAX_TASK_CHARS, SESSION_STATE_MAX_AGE_MS } from "./constants.js";
+import { sessionsDir } from "./paths.js";
+
+/**
+ * Turn state on disk, one directory per session and prompt, written as
+ * first-write-wins files. Hooks for parallel tool calls run at the same time,
+ * so nothing here is read, changed and written back: a file's start-of-turn
+ * content is created once with `wx`, and a counter is the number of files
+ * with its prefix, each created with `wx`.
+ */
+
+const safe = (part: string): string => part.replace(/[^A-Za-z0-9_-]/g, "_");
+const shortHash = (value: string): string =>
+  createHash("sha256").update(value).digest("hex").slice(0, 24);
+
+export const NO_PROMPT_TURN = "turn";
+
+export const turnDir = (sessionId: string, promptId: string | undefined): string =>
+  path.join(sessionsDir(), safe(sessionId), safe(promptId ?? NO_PROMPT_TURN));
+
+const fileStartSchema = z.object({ path: z.string(), original: z.string().nullable() });
+export type FileStart = z.infer<typeof fileStartSchema>;
+
+// Owner-only: a start-of-turn snapshot holds whatever the agent edited.
+const writePrivate = (file: string, contents: string, flag: "w" | "wx" = "w"): void => {
+  mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  writeFileSync(file, contents, { flag, mode: 0o600 });
+};
+
+const createOnce = (file: string, contents: string): boolean => {
+  try {
+    writePrivate(file, contents, "wx");
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const countWithPrefix = (dir: string, prefix: string): number => {
+  try {
+    return readdirSync(dir).filter((name) => name.startsWith(prefix)).length;
+  } catch {
+    return 0;
+  }
+};
+
+/** Bumps a counter by creating the next numbered file. Two hooks racing both land: each retries past the other's number. */
+const increment = (dir: string, prefix: string): number => {
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    const next = countWithPrefix(dir, prefix) + 1;
+    if (createOnce(path.join(dir, `${prefix}${next}`), "")) return next;
+  }
+  return countWithPrefix(dir, prefix);
+};
+
+/** The content a file had when this turn first touched it. Only the first record counts. */
+export const recordFileStart = (
+  dir: string,
+  absolutePath: string,
+  original: string | null,
+): void => {
+  const record: FileStart = { path: absolutePath, original };
+  createOnce(path.join(dir, "files", `${shortHash(absolutePath)}.json`), JSON.stringify(record));
+};
+
+const readRecords = <T>(dir: string, schema: z.ZodType<T>): T[] => {
+  let names: string[];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const records: T[] = [];
+  for (const name of names) {
+    try {
+      const parsed = schema.safeParse(JSON.parse(readFileSync(path.join(dir, name), "utf8")));
+      if (parsed.success) records.push(parsed.data);
+    } catch {
+      // torn
+    }
+  }
+  return records;
+};
+
+export const readFileStarts = (dir: string): FileStart[] =>
+  readRecords(path.join(dir, "files"), fileStartSchema);
+
+/** Stop judges these again: a block the agent ignored must not end the turn quietly. */
+export const recordBlockedFile = (dir: string, relativePath: string): void => {
+  createOnce(path.join(dir, "blocked", shortHash(relativePath)), relativePath);
+};
+
+export const readBlockedFiles = (dir: string): Set<string> => {
+  const files = new Set<string>();
+  try {
+    for (const name of readdirSync(path.join(dir, "blocked"))) {
+      try {
+        files.add(readFileSync(path.join(dir, "blocked", name), "utf8"));
+      } catch {
+        // being written by the other hook
+      }
+    }
+  } catch {
+    // no blocks this turn
+  }
+  return files;
+};
+
+const checkedSchema = z.object({
+  path: z.string(),
+  /** Null when the file did not exist. */
+  before: z.string().nullable(),
+  after: z.string(),
+});
+/** An edit a check judged, as blob ids on either side of it. */
+export type CheckedEdit = z.infer<typeof checkedSchema>;
+
+/** All kept: Stop walks them as a chain from turn start to the file as it stands. */
+export const recordChecked = (dir: string, record: CheckedEdit): void => {
+  const contents = JSON.stringify(record);
+  createOnce(path.join(dir, "checked", `${shortHash(contents)}.json`), contents);
+};
+
+export const readChecked = (dir: string): CheckedEdit[] =>
+  readRecords(path.join(dir, "checked"), checkedSchema);
+
+const blockPrefix = (key: string): string => `${shortHash(key)}.`;
+
+export const blockCount = (dir: string, key: string): number =>
+  countWithPrefix(path.join(dir, "blocks"), blockPrefix(key));
+
+export const incrementBlock = (dir: string, key: string): number =>
+  increment(path.join(dir, "blocks"), blockPrefix(key));
+
+export const stopCheckCount = (dir: string): number =>
+  countWithPrefix(path.join(dir, "stops"), "stop.");
+
+export const incrementStopChecks = (dir: string): number =>
+  increment(path.join(dir, "stops"), "stop.");
+
+/** The prompt that started the turn, for hosts that send it instead of a transcript. */
+export const writePrompt = (dir: string, prompt: string): void => {
+  createOnce(path.join(dir, "prompt"), prompt);
+};
+
+export const readPrompt = (dir: string): string | undefined => {
+  try {
+    const text = readFileSync(path.join(dir, "prompt"), "utf8").trim();
+    return text === "" ? undefined : text.slice(0, MAX_TASK_CHARS);
+  } catch {
+    return undefined;
+  }
+};
+
+/** The git tree the working tree was at when the turn began, when a turn-start hook recorded one. */
+export const writeBaseline = (dir: string, tree: string): void => {
+  createOnce(path.join(dir, "baseline"), tree);
+};
+
+export const readBaseline = (dir: string): string | undefined => {
+  try {
+    const tree = readFileSync(path.join(dir, "baseline"), "utf8").trim();
+    return /^[0-9a-f]{40,64}$/.test(tree) ? tree : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * What became of the turn-start snapshot. Absent on a repository without git,
+ * where the per-file fallback is the documented mode. `pending` means the
+ * hook died before it could say, which for the Stop check is the same as
+ * failed: the turn cannot be read back whole.
+ */
+export type BaselineStatus = "pending" | "ok" | "failed";
+
+const statusFile = (dir: string): string => path.join(dir, "baseline-status");
+
+export const markBaseline = (dir: string, status: BaselineStatus): void => {
+  try {
+    writePrivate(statusFile(dir), status);
+  } catch {
+    // nothing to record on; Stop will see no status and take the fallback
+  }
+};
+
+export const readBaselineStatus = (dir: string): BaselineStatus | undefined => {
+  try {
+    const raw = readFileSync(statusFile(dir), "utf8").trim();
+    return raw === "ok" || raw === "pending" || raw === "failed" ? raw : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+export const hasTurnState = (dir: string): boolean =>
+  readFileStarts(dir).length > 0 ||
+  readBaseline(dir) !== undefined ||
+  readBaselineStatus(dir) !== undefined;
+
+export const clearTurn = (dir: string): void => {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // already gone
+  }
+};
+
+export const pruneOldTurns = (now = Date.now()): void => {
+  try {
+    for (const name of readdirSync(sessionsDir())) {
+      const file = path.join(sessionsDir(), name);
+      if (now - statSync(file).mtimeMs > SESSION_STATE_MAX_AGE_MS)
+        rmSync(file, { recursive: true, force: true });
+    }
+  } catch {
+    // no sessions dir yet
+  }
+};