mergie-cli 0.1.0

package/src/daemon/splitView.ts

@@ -0,0 +1,63 @@
+import type { CharRange, DiffLine } from "@/domain/diff.ts";
+
+/** One side of a split-view row. */
+export interface SplitCell {
+  /** Line number on this side, or null for padding. */
+  no: number | null;
+  /** Line text. */
+  text: string;
+  /** Cell kind: unchanged, deleted, added, or empty padding. */
+  kind: "ctx" | "del" | "add" | "empty";
+  /** Intra-line changed character ranges for word highlighting, if any. */
+  changes?: CharRange[];
+}
+
+/** A single row of the side-by-side split view. */
+export interface SplitRow {
+  /** Base (left) cell. */
+  left: SplitCell;
+  /** Head (right) cell. */
+  right: SplitCell;
+}
+
+/** An empty padding cell. */
+const EMPTY: SplitCell = { no: null, text: "", kind: "empty" };
+
+/**
+ * Convert a full-file diff's lines into aligned side-by-side rows (GitHub-style
+ * split view): context lines appear on both sides; a change block pairs its
+ * deleted lines (left) with its added lines (right), padding the shorter side.
+ */
+export function buildSplitRows(lines: DiffLine[]): SplitRow[] {
+  const rows: SplitRow[] = [];
+  let dels: DiffLine[] = [];
+  let adds: DiffLine[] = [];
+
+  const flush = (): void => {
+    const n: number = Math.max(dels.length, adds.length);
+    for (let i = 0; i < n; i++) {
+      const d = dels[i];
+      const a = adds[i];
+      rows.push({
+        left: d ? { no: d.oldNo ?? null, text: d.text, kind: "del", changes: d.changes } : EMPTY,
+        right: a ? { no: a.newNo ?? null, text: a.text, kind: "add", changes: a.changes } : EMPTY,
+      });
+    }
+    dels = [];
+    adds = [];
+  };
+
+  for (const line of lines) {
+    if (line.kind === "del") dels.push(line);
+    else if (line.kind === "add") adds.push(line);
+    else {
+      flush();
+      rows.push({
+        left: { no: line.oldNo ?? null, text: line.text, kind: "ctx" },
+        right: { no: line.newNo ?? null, text: line.text, kind: "ctx" },
+      });
+    }
+  }
+  flush();
+  return rows;
+}

package/src/daemon/trpc.ts

@@ -0,0 +1,20 @@
+import { initTRPC } from "@trpc/server";
+import type { PrRegistry } from "./registry.ts";
+import type { GhSearchService } from "@/services/ghSearch.ts";
+
+/** Per-request context passed to every tRPC procedure. */
+export interface Context {
+  /** The registry of loaded PRs. */
+  registry: PrRegistry;
+  /** GitHub search for the viewer's open PRs (home picker). */
+  search: GhSearchService;
+  /** Request daemon shutdown (called by the `stop` procedure). */
+  requestStop: () => void;
+}
+
+const t = initTRPC.context<Context>().create();
+
+/** Build a tRPC router. */
+export const router = t.router;
+/** A procedure with no auth/middleware (this is a local single-user tool). */
+export const publicProcedure = t.procedure;

package/src/db/migrate.ts

@@ -0,0 +1,24 @@
+import { Database } from "bun:sqlite";
+import { SCHEMA_SQL, SCHEMA_VERSION } from "./schema.ts";
+
+/**
+ * Apply the schema to a database and record the schema version. Idempotent —
+ * uses `IF NOT EXISTS` DDL so it is safe to run on every open.
+ */
+export function migrate(db: Database): void {
+  db.exec(SCHEMA_SQL);
+  db.query("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', ?)").run(
+    String(SCHEMA_VERSION),
+  );
+}
+
+/**
+ * Open (creating if needed) a SQLite database at `path`, apply migrations, and
+ * return the ready-to-use handle. Pass `:memory:` for tests.
+ */
+export function openDatabase(path: string): Database {
+  const db = new Database(path, { create: true });
+  db.exec("PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;");
+  migrate(db);
+  return db;
+}

package/src/db/repositories/aiReviews.ts

@@ -0,0 +1,113 @@
+import type { Database } from "bun:sqlite";
+
+/**
+ * Input required to create a new AI review record. The caller supplies all
+ * timestamps so they stay deterministic in tests.
+ */
+export interface AiReviewInput {
+  /** The baseline (exclusive) commit SHA for this review. */
+  startSha: string;
+  /** The end (inclusive) commit SHA for this review. */
+  endSha: string;
+  /** Model identifier used to generate the review (e.g. `'claude-3-opus'`). */
+  model: string;
+  /** Optional template id from config (e.g. `'adversarial'`). */
+  template: string | null;
+  /** Optional user-supplied prompt to focus the review. */
+  prompt: string | null;
+  /** Markdown body of the review result. */
+  body: string;
+  /** Creation timestamp in milliseconds. */
+  createdAt: number;
+}
+
+/**
+ * A fully-hydrated AI review row as returned by the repository.
+ * Extends {@link AiReviewInput} with the auto-generated id.
+ */
+export interface AiReviewRow extends AiReviewInput {
+  /** Auto-increment primary key. */
+  id: number;
+}
+
+/** Persistence for AI-generated review results. */
+export interface AiReviewsRepo {
+  /** Persist a new AI review and return its auto-generated id. */
+  create(input: AiReviewInput): number;
+  /** Fetch an AI review by id; returns null if not found. */
+  get(id: number): AiReviewRow | null;
+  /** All AI reviews for the given commit range. */
+  listByRange(startSha: string, endSha: string): AiReviewRow[];
+  /** Every AI review in the database. */
+  listAll(): AiReviewRow[];
+}
+
+/** Raw DB row for the ai_review table. */
+interface AiReviewDbRow {
+  id: number;
+  start_sha: string;
+  end_sha: string;
+  model: string;
+  template: string | null;
+  prompt: string | null;
+  body: string;
+  created_at: number;
+}
+
+/** Map a raw DB row to the public {@link AiReviewRow} shape. */
+function toRow(r: AiReviewDbRow): AiReviewRow {
+  return {
+    id: r.id,
+    startSha: r.start_sha,
+    endSha: r.end_sha,
+    model: r.model,
+    template: r.template,
+    prompt: r.prompt,
+    body: r.body,
+    createdAt: r.created_at,
+  };
+}
+
+/** Create an {@link AiReviewsRepo} backed by the given database. */
+export function aiReviewsRepo(db: Database): AiReviewsRepo {
+  const insert = db.query<{ id: number }, [string, string, string, string | null, string | null, string, number]>(`
+    INSERT INTO ai_review (start_sha, end_sha, model, template, prompt, body, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    RETURNING id
+  `);
+
+  const selectOne = db.query<AiReviewDbRow, [number]>(
+    "SELECT * FROM ai_review WHERE id = ?",
+  );
+
+  const byRange = db.query<AiReviewDbRow, [string, string]>(
+    "SELECT * FROM ai_review WHERE start_sha = ? AND end_sha = ?",
+  );
+
+  const all = db.query<AiReviewDbRow, []>("SELECT * FROM ai_review");
+
+  return {
+    create(input) {
+      const result = insert.get(
+        input.startSha,
+        input.endSha,
+        input.model,
+        input.template,
+        input.prompt,
+        input.body,
+        input.createdAt,
+      );
+      return result!.id;
+    },
+    get(id) {
+      const row = selectOne.get(id);
+      return row ? toRow(row) : null;
+    },
+    listByRange(startSha, endSha) {
+      return byRange.all(startSha, endSha).map(toRow);
+    },
+    listAll() {
+      return all.all().map(toRow);
+    },
+  };
+}

package/src/db/repositories/artifacts.ts

@@ -0,0 +1,101 @@
+import type { Database } from "bun:sqlite";
+
+/**
+ * Input required to create a new artifact record. The caller supplies all
+ * timestamps so they remain deterministic in tests.
+ */
+export interface ArtifactInput {
+  /** The baseline commit SHA for the range this artifact was generated under. */
+  rangeStartSha: string;
+  /** The end commit SHA for the range this artifact was generated under. */
+  rangeEndSha: string;
+  /**
+   * Foreign key referencing the chat_session that produced this artifact.
+   * Null when the artifact was not generated from a specific session.
+   */
+  sessionId: number | null;
+  /** Path to the artifact file relative to the PR artifacts directory. */
+  relPath: string;
+  /** Human-readable title shown in the artifacts browser. */
+  title: string;
+  /** Creation timestamp in milliseconds. */
+  createdAt: number;
+}
+
+/**
+ * A fully-hydrated artifact row as returned by the repository.
+ * Extends {@link ArtifactInput} with the auto-generated id.
+ */
+export interface ArtifactRow extends ArtifactInput {
+  /** Auto-increment primary key. */
+  id: number;
+}
+
+/** Persistence for AI-generated artifact records. */
+export interface ArtifactsRepo {
+  /** Persist a new artifact and return its auto-generated id. */
+  create(input: ArtifactInput): number;
+  /** All artifacts generated under the given commit range. */
+  listByRange(rangeStartSha: string, rangeEndSha: string): ArtifactRow[];
+  /** Every artifact in the database. */
+  listAll(): ArtifactRow[];
+}
+
+/** Raw DB row for the artifact table. */
+interface ArtifactDbRow {
+  id: number;
+  range_start_sha: string;
+  range_end_sha: string;
+  session_id: number | null;
+  rel_path: string;
+  title: string;
+  created_at: number;
+}
+
+/** Map a raw DB row to the public {@link ArtifactRow} shape. */
+function toRow(r: ArtifactDbRow): ArtifactRow {
+  return {
+    id: r.id,
+    rangeStartSha: r.range_start_sha,
+    rangeEndSha: r.range_end_sha,
+    sessionId: r.session_id,
+    relPath: r.rel_path,
+    title: r.title,
+    createdAt: r.created_at,
+  };
+}
+
+/** Create an {@link ArtifactsRepo} backed by the given database. */
+export function artifactsRepo(db: Database): ArtifactsRepo {
+  const insert = db.query<{ id: number }, [string, string, number | null, string, string, number]>(`
+    INSERT INTO artifact (range_start_sha, range_end_sha, session_id, rel_path, title, created_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+    RETURNING id
+  `);
+
+  const byRange = db.query<ArtifactDbRow, [string, string]>(
+    "SELECT * FROM artifact WHERE range_start_sha = ? AND range_end_sha = ?",
+  );
+
+  const all = db.query<ArtifactDbRow, []>("SELECT * FROM artifact");
+
+  return {
+    create(input) {
+      const result = insert.get(
+        input.rangeStartSha,
+        input.rangeEndSha,
+        input.sessionId,
+        input.relPath,
+        input.title,
+        input.createdAt,
+      );
+      return result!.id;
+    },
+    listByRange(rangeStartSha, rangeEndSha) {
+      return byRange.all(rangeStartSha, rangeEndSha).map(toRow);
+    },
+    listAll() {
+      return all.all().map(toRow);
+    },
+  };
+}

package/src/db/repositories/chatSessions.ts

@@ -0,0 +1,197 @@
+import type { Database } from "bun:sqlite";
+
+/**
+ * The scope kind for a chat session — whether it was started from a hunk or a
+ * whole file.
+ *
+ * - `'hunk'` — session scoped to a single hunk (scopeRef is the hunk hash).
+ * - `'file'` — session scoped to a file (scopeRef is the repo-relative path).
+ */
+export type ChatScopeKind = "hunk" | "file";
+
+/**
+ * The role of a chat participant.
+ *
+ * - `'user'` — message sent by the user.
+ * - `'assistant'` — message from the AI model.
+ */
+export type ChatRole = "user" | "assistant";
+
+/**
+ * Input required to create a new chat session. Timestamps are supplied by the
+ * caller to remain deterministic in tests.
+ */
+export interface ChatSessionInput {
+  /** Whether the session was started from a hunk or a file. */
+  scopeKind: ChatScopeKind;
+  /** Hunk hash (when scopeKind='hunk') or repo-relative file path (when 'file'). */
+  scopeRef: string;
+  /** Short title summarising the session purpose. */
+  title: string;
+  /** Model identifier used in this session (e.g. `'claude-3-opus'`). */
+  model: string;
+  /** Creation timestamp in milliseconds. */
+  createdAt: number;
+}
+
+/**
+ * A fully-hydrated chat session row as returned by the repository.
+ * Extends {@link ChatSessionInput} with the auto-generated id.
+ */
+export interface ChatSessionRow extends ChatSessionInput {
+  /** Auto-increment primary key. */
+  id: number;
+}
+
+/**
+ * Input required to add a message to an existing chat session. Timestamps are
+ * supplied by the caller.
+ */
+export interface ChatMessageInput {
+  /** Foreign key referencing the parent chat_session.id. */
+  sessionId: number;
+  /** Who sent the message. */
+  role: ChatRole;
+  /** Markdown content of the message. */
+  content: string;
+  /** Creation timestamp in milliseconds. */
+  createdAt: number;
+}
+
+/**
+ * A fully-hydrated chat message row as returned by the repository.
+ * Extends {@link ChatMessageInput} with the auto-generated id.
+ */
+export interface ChatMessageRow extends ChatMessageInput {
+  /** Auto-increment primary key. */
+  id: number;
+}
+
+/** Persistence for AI chat sessions and their messages. */
+export interface ChatSessionsRepo {
+  /** Persist a new chat session and return its auto-generated id. */
+  createSession(input: ChatSessionInput): number;
+  /** Fetch a chat session by id; returns null if not found. */
+  getSession(id: number): ChatSessionRow | null;
+  /** All chat sessions in the database. */
+  listSessions(): ChatSessionRow[];
+  /** All sessions with the given scopeKind and scopeRef. */
+  listSessionsByScope(scopeKind: ChatScopeKind, scopeRef: string): ChatSessionRow[];
+  /** Rename a session. No-op if the id does not exist. */
+  setTitle(id: number, title: string): void;
+  /** Append a message to an existing session and return its auto-generated id. */
+  addMessage(input: ChatMessageInput): number;
+  /** All messages for a session ordered by createdAt ascending. */
+  listMessages(sessionId: number): ChatMessageRow[];
+}
+
+/** Raw DB row for the chat_session table. */
+interface SessionDbRow {
+  id: number;
+  scope_kind: string;
+  scope_ref: string;
+  title: string;
+  model: string;
+  created_at: number;
+}
+
+/** Raw DB row for the chat_message table. */
+interface MessageDbRow {
+  id: number;
+  session_id: number;
+  role: string;
+  content: string;
+  created_at: number;
+}
+
+/** Map a raw DB row to the public {@link ChatSessionRow} shape. */
+function toSessionRow(r: SessionDbRow): ChatSessionRow {
+  return {
+    id: r.id,
+    scopeKind: r.scope_kind as ChatScopeKind,
+    scopeRef: r.scope_ref,
+    title: r.title,
+    model: r.model,
+    createdAt: r.created_at,
+  };
+}
+
+/** Map a raw DB row to the public {@link ChatMessageRow} shape. */
+function toMessageRow(r: MessageDbRow): ChatMessageRow {
+  return {
+    id: r.id,
+    sessionId: r.session_id,
+    role: r.role as ChatRole,
+    content: r.content,
+    createdAt: r.created_at,
+  };
+}
+
+/** Create a {@link ChatSessionsRepo} backed by the given database. */
+export function chatSessionsRepo(db: Database): ChatSessionsRepo {
+  const insertSession = db.query<{ id: number }, [string, string, string, string, number]>(`
+    INSERT INTO chat_session (scope_kind, scope_ref, title, model, created_at)
+    VALUES (?, ?, ?, ?, ?)
+    RETURNING id
+  `);
+
+  const selectSession = db.query<SessionDbRow, [number]>(
+    "SELECT * FROM chat_session WHERE id = ?",
+  );
+
+  const allSessions = db.query<SessionDbRow, []>("SELECT * FROM chat_session");
+
+  const sessionsByScope = db.query<SessionDbRow, [string, string]>(
+    "SELECT * FROM chat_session WHERE scope_kind = ? AND scope_ref = ?",
+  );
+
+  const updateTitle = db.query("UPDATE chat_session SET title = ? WHERE id = ?");
+
+  const insertMessage = db.query<{ id: number }, [number, string, string, number]>(`
+    INSERT INTO chat_message (session_id, role, content, created_at)
+    VALUES (?, ?, ?, ?)
+    RETURNING id
+  `);
+
+  const messagesBySession = db.query<MessageDbRow, [number]>(
+    "SELECT * FROM chat_message WHERE session_id = ? ORDER BY created_at ASC",
+  );
+
+  return {
+    createSession(input) {
+      const result = insertSession.get(
+        input.scopeKind,
+        input.scopeRef,
+        input.title,
+        input.model,
+        input.createdAt,
+      );
+      return result!.id;
+    },
+    getSession(id) {
+      const row = selectSession.get(id);
+      return row ? toSessionRow(row) : null;
+    },
+    listSessions() {
+      return allSessions.all().map(toSessionRow);
+    },
+    listSessionsByScope(scopeKind, scopeRef) {
+      return sessionsByScope.all(scopeKind, scopeRef).map(toSessionRow);
+    },
+    setTitle(id, title) {
+      updateTitle.run(title, id);
+    },
+    addMessage(input) {
+      const result = insertMessage.get(
+        input.sessionId,
+        input.role,
+        input.content,
+        input.createdAt,
+      );
+      return result!.id;
+    },
+    listMessages(sessionId) {
+      return messagesBySession.all(sessionId).map(toMessageRow);
+    },
+  };
+}