mergie-cli 0.1.0

package/src/db/repositories/comments.ts

@@ -0,0 +1,195 @@
+import type { Database } from "bun:sqlite";
+
+/**
+ * The kind of comment — whether it targets a whole hunk or a line range.
+ *
+ * - `'hunk'` — comment on the entire hunk.
+ * - `'lines'` — comment on a specific line range.
+ */
+export type CommentKind = "hunk" | "lines";
+
+/**
+ * Which side of the diff the comment applies to.
+ *
+ * - `'LEFT'` — the base (start) version of the file.
+ * - `'RIGHT'` — the head (end) version of the file.
+ */
+export type CommentSide = "LEFT" | "RIGHT";
+
+/**
+ * Input required to create a new comment. Timestamps must be supplied by the
+ * caller so they remain deterministic in tests.
+ */
+export interface CommentInput {
+  /** Whether the comment targets a whole hunk or a line range. */
+  kind: CommentKind;
+  /** Which diff side the comment appears on. */
+  side: CommentSide;
+  /** Repo-relative file path. */
+  path: string;
+  /** Content hash of {path, side, exact line text}. Controls visibility. */
+  anchorHash: string;
+  /** First line of the range (1-based, nullable for hunk-level comments). */
+  startLine: number | null;
+  /** Last line of the range (1-based, nullable for hunk-level comments). */
+  endLine: number | null;
+  /** SHA of the commit that was the head when the comment was made. */
+  madeAtSha: string;
+  /** Markdown body text. */
+  body: string;
+  /** Creation timestamp in milliseconds. */
+  createdAt: number;
+  /** Last-updated timestamp in milliseconds. */
+  updatedAt: number;
+  /** GitHub comment id when posted; null otherwise. */
+  githubId: string | null;
+  /** GitHub URL when posted; null otherwise. */
+  githubUrl: string | null;
+  /** GitHub id of the comment being replied to; null for top-level. */
+  inReplyToGithubId: string | null;
+}
+
+/**
+ * A fully-hydrated comment row as returned by the repository.
+ * Extends {@link CommentInput} with the auto-generated id.
+ */
+export interface CommentRow extends CommentInput {
+  /** Auto-increment primary key. */
+  id: number;
+}
+
+/** Persistence for user-authored comments. */
+export interface CommentsRepo {
+  /** Persist a new comment and return its auto-generated id. */
+  create(input: CommentInput): number;
+  /** Fetch a comment by id; returns null if not found. */
+  get(id: number): CommentRow | null;
+  /** Update the body and updatedAt of an existing comment. No-op if not found. */
+  update(id: number, fields: { body: string; updatedAt: number }): void;
+  /** Delete a comment by id. No-op if not found. */
+  remove(id: number): void;
+  /** All comments whose anchorHash matches. */
+  listByAnchor(anchorHash: string): CommentRow[];
+  /** Every comment in the database. */
+  listAll(): CommentRow[];
+  /** Record that a comment was posted to GitHub; updates githubId + githubUrl. */
+  setGithub(id: number, fields: { githubId: string; githubUrl: string }): void;
+  /** Clear GitHub association from a comment (sets githubId/githubUrl to null). */
+  clearGithub(id: number): void;
+}
+
+/** Raw DB row for the comment table. */
+interface CommentDbRow {
+  id: number;
+  kind: string;
+  side: string;
+  path: string;
+  anchor_hash: string;
+  start_line: number | null;
+  end_line: number | null;
+  made_at_sha: string;
+  body: string;
+  created_at: number;
+  updated_at: number;
+  github_id: string | null;
+  github_url: string | null;
+  in_reply_to_github_id: string | null;
+}
+
+/** Map a raw DB row to the public {@link CommentRow} shape. */
+function toRow(r: CommentDbRow): CommentRow {
+  return {
+    id: r.id,
+    kind: r.kind as CommentKind,
+    side: r.side as CommentSide,
+    path: r.path,
+    anchorHash: r.anchor_hash,
+    startLine: r.start_line,
+    endLine: r.end_line,
+    madeAtSha: r.made_at_sha,
+    body: r.body,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+    githubId: r.github_id,
+    githubUrl: r.github_url,
+    inReplyToGithubId: r.in_reply_to_github_id,
+  };
+}
+
+/** Create a {@link CommentsRepo} backed by the given database. */
+export function commentsRepo(db: Database): CommentsRepo {
+  const insert = db.query<{ id: number }, [string, string, string, string, number | null, number | null, string, string, number, number, string | null, string | null, string | null]>(`
+    INSERT INTO comment
+      (kind, side, path, anchor_hash, start_line, end_line, made_at_sha,
+       body, created_at, updated_at, github_id, github_url, in_reply_to_github_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    RETURNING id
+  `);
+
+  const selectOne = db.query<CommentDbRow, [number]>(
+    "SELECT * FROM comment WHERE id = ?",
+  );
+
+  const updateStmt = db.query(
+    "UPDATE comment SET body = ?, updated_at = ? WHERE id = ?",
+  );
+
+  const del = db.query("DELETE FROM comment WHERE id = ?");
+
+  const byAnchor = db.query<CommentDbRow, [string]>(
+    "SELECT * FROM comment WHERE anchor_hash = ?",
+  );
+
+  const all = db.query<CommentDbRow, []>("SELECT * FROM comment");
+
+  const setGithubStmt = db.query(
+    "UPDATE comment SET github_id = ?, github_url = ? WHERE id = ?",
+  );
+
+  const clearGithubStmt = db.query(
+    "UPDATE comment SET github_id = NULL, github_url = NULL WHERE id = ?",
+  );
+
+  return {
+    create(input) {
+      const result = insert.get(
+        input.kind,
+        input.side,
+        input.path,
+        input.anchorHash,
+        input.startLine,
+        input.endLine,
+        input.madeAtSha,
+        input.body,
+        input.createdAt,
+        input.updatedAt,
+        input.githubId,
+        input.githubUrl,
+        input.inReplyToGithubId,
+      );
+      return result!.id;
+    },
+    get(id) {
+      const row = selectOne.get(id);
+      return row ? toRow(row) : null;
+    },
+    update(id, fields) {
+      updateStmt.run(fields.body, fields.updatedAt, id);
+    },
+    remove(id) {
+      del.run(id);
+    },
+    listByAnchor(anchorHash) {
+      return byAnchor.all(anchorHash).map(toRow);
+    },
+    listAll() {
+      return all.all().map(toRow);
+    },
+    setGithub(id, fields) {
+      setGithubStmt.run(fields.githubId, fields.githubUrl, id);
+    },
+    clearGithub(id) {
+      clearGithubStmt.run(id);
+    },
+  };
+}

package/src/db/repositories/githubComments.ts

@@ -0,0 +1,166 @@
+import type { Database } from "bun:sqlite";
+
+/**
+ * An inbound GitHub inline comment (or reply) cached from the GitHub API.
+ * Used both as the input shape for writes and as the row shape for reads,
+ * because the primary key (`githubId`) comes from GitHub, not auto-increment.
+ */
+export interface GithubCommentRow {
+  /** GitHub's stable comment id — the primary key. */
+  githubId: string;
+  /** Repo-relative file path the comment was made on. */
+  path: string | null;
+  /** Diff side (`'LEFT'` or `'RIGHT'`). */
+  side: string | null;
+  /** Line number the comment is anchored to (1-based). */
+  line: number | null;
+  /** First line of a multi-line comment span; null for single-line. */
+  startLine: number | null;
+  /** The commit SHA the comment was posted against. */
+  commitSha: string | null;
+  /** Markdown body of the comment. */
+  body: string;
+  /** GitHub username of the comment author. */
+  author: string | null;
+  /**
+   * When the comment was created on GitHub, as a Unix timestamp in
+   * milliseconds. May be null if the API response omits it.
+   */
+  createdAt: number | null;
+  /** GitHub id of the parent comment if this is a reply; null otherwise. */
+  inReplyTo: string | null;
+  /** When this row was last synced from GitHub (ms). */
+  syncedAt: number;
+}
+
+/** Persistence for the inbound GitHub inline comment cache. */
+export interface GithubCommentsRepo {
+  /**
+   * Insert or fully replace a GitHub comment row keyed by githubId.
+   * Uses `INSERT OR REPLACE` — all fields are overwritten on conflict.
+   */
+  upsert(row: GithubCommentRow): void;
+  /**
+   * Replace the entire table with the provided rows in a single transaction.
+   * Clears all existing rows first, then bulk-inserts the new set.
+   */
+  replaceAll(rows: GithubCommentRow[]): void;
+  /** Every GitHub comment in the cache. */
+  listAll(): GithubCommentRow[];
+  /** All GitHub comments on the given file path. */
+  listByPath(path: string): GithubCommentRow[];
+  /** Delete the cached row for a GitHub comment id. No-op if absent. */
+  remove(githubId: string): void;
+  /** Update only the body of the cached row for a GitHub comment id. No-op if absent. */
+  updateBody(githubId: string, body: string): void;
+}
+
+/** Raw DB row for the github_comment table. */
+interface GithubCommentDbRow {
+  github_id: string;
+  path: string | null;
+  side: string | null;
+  line: number | null;
+  start_line: number | null;
+  commit_sha: string | null;
+  body: string;
+  author: string | null;
+  created_at: number | null;
+  in_reply_to: string | null;
+  synced_at: number;
+}
+
+/** Map a raw DB row to the public {@link GithubCommentRow} shape. */
+function toRow(r: GithubCommentDbRow): GithubCommentRow {
+  return {
+    githubId: r.github_id,
+    path: r.path,
+    side: r.side,
+    line: r.line,
+    startLine: r.start_line,
+    commitSha: r.commit_sha,
+    body: r.body,
+    author: r.author,
+    createdAt: r.created_at,
+    inReplyTo: r.in_reply_to,
+    syncedAt: r.synced_at,
+  };
+}
+
+const INSERT_SQL = `
+  INSERT OR REPLACE INTO github_comment
+    (github_id, path, side, line, start_line, commit_sha, body, author, created_at, in_reply_to, synced_at)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+
+/** Create a {@link GithubCommentsRepo} backed by the given database. */
+export function githubCommentsRepo(db: Database): GithubCommentsRepo {
+  const upsertStmt = db.query<
+    void,
+    [string, string | null, string | null, number | null, number | null, string | null, string, string | null, number | null, string | null, number]
+  >(INSERT_SQL);
+
+  const all = db.query<GithubCommentDbRow, []>("SELECT * FROM github_comment");
+
+  const byPath = db.query<GithubCommentDbRow, [string]>(
+    "SELECT * FROM github_comment WHERE path = ?",
+  );
+
+  const clearAll = db.query("DELETE FROM github_comment");
+
+  const deleteOne = db.query("DELETE FROM github_comment WHERE github_id = ?");
+
+  const updateBodyStmt = db.query("UPDATE github_comment SET body = ? WHERE github_id = ?");
+
+  const replaceAllFn = db.transaction((rows: GithubCommentRow[]) => {
+    clearAll.run();
+    for (const row of rows) {
+      upsertStmt.run(
+        row.githubId,
+        row.path,
+        row.side,
+        row.line,
+        row.startLine,
+        row.commitSha,
+        row.body,
+        row.author,
+        row.createdAt,
+        row.inReplyTo,
+        row.syncedAt,
+      );
+    }
+  });
+
+  return {
+    upsert(row) {
+      upsertStmt.run(
+        row.githubId,
+        row.path,
+        row.side,
+        row.line,
+        row.startLine,
+        row.commitSha,
+        row.body,
+        row.author,
+        row.createdAt,
+        row.inReplyTo,
+        row.syncedAt,
+      );
+    },
+    replaceAll(rows) {
+      replaceAllFn(rows);
+    },
+    listAll() {
+      return all.all().map(toRow);
+    },
+    listByPath(path) {
+      return byPath.all(path).map(toRow);
+    },
+    remove(githubId) {
+      deleteOne.run(githubId);
+    },
+    updateBody(githubId, body) {
+      updateBodyStmt.run(body, githubId);
+    },
+  };
+}

package/src/db/repositories/hunkViews.ts

@@ -0,0 +1,36 @@
+import type { Database } from "bun:sqlite";
+
+/** Persistence for per-hunk viewed state, keyed by hunk content hash. */
+export interface HunkViewsRepo {
+  /** Mark a hunk viewed at the given timestamp (ms); idempotent. */
+  markViewed(hunkHash: string, at: number): void;
+  /** Remove a hunk's viewed state. */
+  unmarkViewed(hunkHash: string): void;
+  /** Whether a hunk hash is currently marked viewed. */
+  isViewed(hunkHash: string): boolean;
+  /** All currently-viewed hunk hashes. */
+  viewedHashes(): string[];
+}
+
+/** Create a {@link HunkViewsRepo} backed by the given database. */
+export function hunkViewsRepo(db: Database): HunkViewsRepo {
+  const insert = db.query("INSERT OR REPLACE INTO hunk_view (hunk_hash, viewed_at) VALUES (?, ?)");
+  const del = db.query("DELETE FROM hunk_view WHERE hunk_hash = ?");
+  const one = db.query<{ n: number }, [string]>("SELECT COUNT(*) AS n FROM hunk_view WHERE hunk_hash = ?");
+  const all = db.query<{ hunk_hash: string }, []>("SELECT hunk_hash FROM hunk_view");
+
+  return {
+    markViewed(hunkHash, at) {
+      insert.run(hunkHash, at);
+    },
+    unmarkViewed(hunkHash) {
+      del.run(hunkHash);
+    },
+    isViewed(hunkHash) {
+      return (one.get(hunkHash)?.n ?? 0) > 0;
+    },
+    viewedHashes() {
+      return all.all().map((r) => r.hunk_hash);
+    },
+  };
+}

package/src/db/repositories/reviewedRanges.ts

@@ -0,0 +1,75 @@
+import type { Database } from "bun:sqlite";
+
+/**
+ * A single reviewed commit range record as returned by the repository.
+ */
+export interface ReviewedRangeRow {
+  /** Auto-increment primary key. */
+  id: number;
+  /** The baseline (exclusive) commit SHA. */
+  startSha: string;
+  /** The end (inclusive) commit SHA. */
+  endSha: string;
+  /** Unix timestamp (ms) when this range was recorded. */
+  createdAt: number;
+}
+
+/** Persistence for reviewed commit ranges keyed by (startSha, endSha). */
+export interface ReviewedRangesRepo {
+  /**
+   * Record a reviewed range. Duplicate (startSha, endSha) pairs are silently
+   * ignored (INSERT OR IGNORE) — the original record is preserved.
+   */
+  add(startSha: string, endSha: string, createdAt: number): void;
+  /** All recorded ranges ordered by createdAt ascending. */
+  list(): ReviewedRangeRow[];
+  /** Delete a range by its id. No-op if the id does not exist. */
+  remove(id: number): void;
+  /** Delete the range matching an exact (startSha, endSha) pair. No-op if absent. */
+  removeByRange(startSha: string, endSha: string): void;
+}
+
+/** Internal DB row shape for reviewed_range queries. */
+interface RangeDbRow {
+  id: number;
+  start_sha: string;
+  end_sha: string;
+  created_at: number;
+}
+
+/** Map a raw DB row to the public {@link ReviewedRangeRow} shape. */
+function toRow(r: RangeDbRow): ReviewedRangeRow {
+  return {
+    id: r.id,
+    startSha: r.start_sha,
+    endSha: r.end_sha,
+    createdAt: r.created_at,
+  };
+}
+
+/** Create a {@link ReviewedRangesRepo} backed by the given database. */
+export function reviewedRangesRepo(db: Database): ReviewedRangesRepo {
+  const insert = db.query(
+    "INSERT OR IGNORE INTO reviewed_range (start_sha, end_sha, created_at) VALUES (?, ?, ?)",
+  );
+  const selectAll = db.query<RangeDbRow, []>(
+    "SELECT id, start_sha, end_sha, created_at FROM reviewed_range ORDER BY created_at ASC",
+  );
+  const del = db.query("DELETE FROM reviewed_range WHERE id = ?");
+  const delByRange = db.query("DELETE FROM reviewed_range WHERE start_sha = ? AND end_sha = ?");
+
+  return {
+    add(startSha, endSha, createdAt) {
+      insert.run(startSha, endSha, createdAt);
+    },
+    list() {
+      return selectAll.all().map(toRow);
+    },
+    remove(id) {
+      del.run(id);
+    },
+    removeByRange(startSha, endSha) {
+      delByRange.run(startSha, endSha);
+    },
+  };
+}

package/src/db/schema.ts

@@ -0,0 +1,97 @@
+/** Current database schema version. Bump when SCHEMA_SQL changes. */
+export const SCHEMA_VERSION = 1;
+
+/**
+ * Full schema DDL for a per-PR mergie database. All statements use
+ * `IF NOT EXISTS` so applying them is idempotent. See docs/PLAN.md for the
+ * data model rationale.
+ */
+export const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS hunk_view (
+  hunk_hash TEXT PRIMARY KEY,
+  viewed_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS reviewed_range (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  start_sha  TEXT NOT NULL,
+  end_sha    TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  UNIQUE (start_sha, end_sha)
+);
+
+CREATE TABLE IF NOT EXISTS comment (
+  id                    INTEGER PRIMARY KEY AUTOINCREMENT,
+  kind                  TEXT NOT NULL,           -- 'hunk' | 'lines'
+  side                  TEXT NOT NULL,           -- 'LEFT' | 'RIGHT'
+  path                  TEXT NOT NULL,
+  anchor_hash           TEXT NOT NULL,
+  start_line            INTEGER,
+  end_line              INTEGER,
+  made_at_sha           TEXT NOT NULL,
+  body                  TEXT NOT NULL,
+  created_at            INTEGER NOT NULL,
+  updated_at            INTEGER NOT NULL,
+  github_id             TEXT,
+  github_url            TEXT,
+  in_reply_to_github_id TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_comment_anchor ON comment (anchor_hash);
+
+CREATE TABLE IF NOT EXISTS github_comment (
+  github_id  TEXT PRIMARY KEY,
+  path       TEXT,
+  side       TEXT,
+  line       INTEGER,
+  start_line INTEGER,
+  commit_sha TEXT,
+  body       TEXT NOT NULL,
+  author     TEXT,
+  created_at INTEGER,
+  in_reply_to TEXT,
+  synced_at  INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS ai_review (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  start_sha  TEXT NOT NULL,
+  end_sha    TEXT NOT NULL,
+  model      TEXT NOT NULL,
+  template   TEXT,
+  prompt     TEXT,
+  body       TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chat_session (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  scope_kind TEXT NOT NULL,                      -- 'hunk' | 'file'
+  scope_ref  TEXT NOT NULL,                      -- hunk hash or file path
+  title      TEXT NOT NULL,
+  model      TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chat_message (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id INTEGER NOT NULL REFERENCES chat_session (id),
+  role       TEXT NOT NULL,                      -- 'user' | 'assistant'
+  content    TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS artifact (
+  id             INTEGER PRIMARY KEY AUTOINCREMENT,
+  range_start_sha TEXT NOT NULL,
+  range_end_sha   TEXT NOT NULL,
+  session_id     INTEGER,
+  rel_path       TEXT NOT NULL,
+  title          TEXT NOT NULL,
+  created_at     INTEGER NOT NULL
+);
+`;

package/src/domain/config.ts

@@ -0,0 +1,137 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { configDir, type PathEnv } from "./paths.ts";
+
+/** A selectable Claude model. */
+export interface ModelChoice {
+  /** Model id passed to the Agent SDK, e.g. "claude-opus-4-8". */
+  id: string;
+  /** Human-friendly label shown in the picker. */
+  label: string;
+}
+
+/** An AI-review prompt template. */
+export interface ReviewTemplate {
+  /** Stable identifier. */
+  id: string;
+  /** Display title. */
+  title: string;
+  /** The prompt text seeding the review. */
+  prompt: string;
+}
+
+/** Fully-resolved mergie configuration (defaults merged with user config). */
+export interface MergieConfig {
+  /** Glob patterns identifying lock/generated files (defaults + user, deduped). */
+  lockfilePatterns: string[];
+  /** Selectable models for chat and reviews. */
+  models: ModelChoice[];
+  /** Available AI-review templates. */
+  templates: ReviewTemplate[];
+}
+
+/** Built-in lock/generated-file patterns; user patterns extend these. */
+const DEFAULT_LOCKFILE_PATTERNS: readonly string[] = [
+  "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "npm-shrinkwrap.json",
+  "bun.lock", "bun.lockb", "Cargo.lock", "go.sum", "composer.lock",
+  "Gemfile.lock", "poetry.lock", "Pipfile.lock", "*.min.js", "*.min.css",
+];
+
+/** Built-in model choices. */
+const DEFAULT_MODELS: readonly ModelChoice[] = [
+  { id: "claude-opus-4-8", label: "Opus 4.8" },
+  { id: "claude-sonnet-4-6", label: "Sonnet 4.6" },
+  { id: "claude-haiku-4-5-20251001", label: "Haiku 4.5" },
+];
+
+/** Built-in AI-review templates (from SPEC). */
+const DEFAULT_TEMPLATES: readonly ReviewTemplate[] = [
+  {
+    id: "key-decisions",
+    title: "Key decisions",
+    prompt: "Analyse the diff and list the key decisions made in these changes, then reduce them to the essential ones.",
+  },
+  {
+    id: "adversarial",
+    title: "Adversarial bug pass",
+    prompt: "Perform an adversarial pass over the diff to find bugs and any obvious performance issues.",
+  },
+];
+
+/** The default configuration, with no user overrides applied. */
+export function defaultConfig(): MergieConfig {
+  return {
+    lockfilePatterns: [...DEFAULT_LOCKFILE_PATTERNS],
+    models: DEFAULT_MODELS.map((m) => ({ ...m })),
+    templates: DEFAULT_TEMPLATES.map((t) => ({ ...t })),
+  };
+}
+
+/**
+ * Parse a TOML config string and merge it over the defaults. Lock patterns
+ * extend the defaults (deduped); models and templates replace the defaults
+ * when present. Unknown keys are ignored.
+ */
+export function parseConfig(tomlText: string): MergieConfig {
+  const raw: unknown = Bun.TOML.parse(tomlText);
+  const rec: Record<string, unknown> = isRecord(raw) ? raw : {};
+
+  const userPatterns: string[] = stringArray(rec.lockfilePatterns) ?? [];
+  const models = parseModels(rec.models);
+  const templates = parseTemplates(rec.templates);
+  const base = defaultConfig();
+
+  return {
+    lockfilePatterns: dedupe([...base.lockfilePatterns, ...userPatterns]),
+    models: models ?? base.models,
+    templates: templates ?? base.templates,
+  };
+}
+
+/**
+ * Load configuration from disk, merging the user's config file (if present)
+ * over the defaults.
+ *
+ * @param opts.path Override the config file path (defaults to
+ *   `<configDir>/config.toml`).
+ */
+export function loadConfig(opts?: { path?: string } & PathEnv): MergieConfig {
+  const path: string = opts?.path ?? join(configDir(opts), "config.toml");
+  if (!existsSync(path)) return defaultConfig();
+  return parseConfig(readFileSync(path, "utf8"));
+}
+
+function dedupe(items: string[]): string[] {
+  return [...new Set(items)];
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+function stringArray(v: unknown): string[] | undefined {
+  if (!Array.isArray(v)) return undefined;
+  return v.filter((x): x is string => typeof x === "string");
+}
+
+function parseModels(v: unknown): ModelChoice[] | undefined {
+  if (!Array.isArray(v)) return undefined;
+  const out: ModelChoice[] = [];
+  for (const item of v) {
+    if (isRecord(item) && typeof item.id === "string") {
+      out.push({ id: item.id, label: typeof item.label === "string" ? item.label : item.id });
+    }
+  }
+  return out;
+}
+
+function parseTemplates(v: unknown): ReviewTemplate[] | undefined {
+  if (!Array.isArray(v)) return undefined;
+  const out: ReviewTemplate[] = [];
+  for (const item of v) {
+    if (isRecord(item) && typeof item.id === "string" && typeof item.title === "string" && typeof item.prompt === "string") {
+      out.push({ id: item.id, title: item.title, prompt: item.prompt });
+    }
+  }
+  return out;
+}