mergie-cli 0.1.0

package/src/domain/wordDiff.ts

@@ -0,0 +1,174 @@
+import type { CharRange, DiffLine } from "./diff.ts";
+
+export type { CharRange };
+
+/** The intra-line changed ranges for one file, keyed by absolute line number. */
+export interface FileWordChanges {
+  /** Base-side path (`a/…`). */
+  oldPath: string;
+  /** Head-side path (`b/…`). */
+  newPath: string;
+  /** Base-side changed ranges by 1-based old line number (only changed lines). */
+  oldByLine: Map<number, CharRange[]>;
+  /** Head-side changed ranges by 1-based new line number (only changed lines). */
+  newByLine: Map<number, CharRange[]>;
+}
+
+/**
+ * Ratio of a line's characters that must have changed before we treat it as a
+ * near-total rewrite and drop word highlighting (falling back to the plain
+ * line background). Also naturally suppresses pure insertions/deletions, whose
+ * whole line reads as changed.
+ */
+const NEAR_TOTAL_REWRITE_RATIO = 0.6;
+
+/** One porcelain segment within a reconstructed line. */
+interface Segment {
+  /** Which side(s) the text belongs to. */
+  kind: "common" | "old" | "new";
+  /** The segment's literal text (marker prefix already stripped). */
+  text: string;
+}
+
+/**
+ * Parse `git diff --word-diff=porcelain` output into per-file, per-line changed
+ * character ranges. Pure — performs no git or filesystem access.
+ *
+ * Porcelain emits a token stream: lines prefixed ` ` (common), `-` (base only),
+ * `+` (head only), and a bare `~` marking a source newline. A block (the
+ * segments since the last `~`) advances the base line number if it holds any
+ * common/`-` segment, and the head line number if it holds any common/`+`
+ * segment — so pure insertions advance only the head side and pure deletions
+ * only the base side.
+ */
+export function parseWordDiff(text: string): FileWordChanges[] {
+  const files: FileWordChanges[] = [];
+  let current: FileWordChanges | null = null;
+  let oldNo = 0;
+  let newNo = 0;
+  let block: Segment[] = [];
+
+  const flush = (): void => {
+    if (!current) { block = []; return; }
+    applyBlock(current, block, oldNo, newNo, (o, n) => { oldNo = o; newNo = n; });
+    block = [];
+  };
+
+  for (const line of text.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      current = startFile(line);
+      if (current) files.push(current);
+    } else if (line.startsWith("@@ ")) {
+      flush();
+      const header = parseAtAt(line);
+      if (header) { oldNo = header.oldStart; newNo = header.newStart; }
+    } else if (line === "~") {
+      flush();
+    } else if (line.startsWith("\\")) {
+      // "" — not part of the content.
+    } else if (current && (line.startsWith(" ") || line.startsWith("-") || line.startsWith("+"))) {
+      block.push({ kind: markerKind(line[0]), text: line.slice(1) });
+    }
+  }
+  flush();
+  return files;
+}
+
+/** Start a new file accumulator from a `diff --git a/… b/…` line. */
+function startFile(line: string): FileWordChanges | null {
+  const m = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
+  if (!m) return null;
+  return { oldPath: m[1] ?? "", newPath: m[2] ?? "", oldByLine: new Map(), newByLine: new Map() };
+}
+
+/** Parse an `@@ -a,b +c,d @@` header into its 1-based start line numbers. */
+function parseAtAt(header: string): { oldStart: number; newStart: number } | null {
+  const m = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(header);
+  if (!m) return null;
+  return { oldStart: Number(m[1]), newStart: Number(m[2]) };
+}
+
+/** Map a porcelain marker character to a segment kind. */
+function markerKind(marker: string | undefined): Segment["kind"] {
+  if (marker === "-") return "old";
+  if (marker === "+") return "new";
+  return "common";
+}
+
+/**
+ * Fold one `~`-terminated block into `current`, recording changed ranges and
+ * advancing whichever side(s) the block participates in.
+ */
+function applyBlock(
+  current: FileWordChanges,
+  block: Segment[],
+  oldNo: number,
+  newNo: number,
+  advance: (oldNo: number, newNo: number) => void,
+): void {
+  const { oldRanges, newRanges, hasOld, hasNew } = reduceBlock(block);
+  if (hasOld) {
+    if (oldRanges.length > 0) current.oldByLine.set(oldNo, oldRanges);
+    oldNo += 1;
+  }
+  if (hasNew) {
+    if (newRanges.length > 0) current.newByLine.set(newNo, newRanges);
+    newNo += 1;
+  }
+  advance(oldNo, newNo);
+}
+
+/** Reconstruct a block's base/head text offsets and changed ranges. */
+function reduceBlock(block: Segment[]): {
+  oldRanges: CharRange[];
+  newRanges: CharRange[];
+  hasOld: boolean;
+  hasNew: boolean;
+} {
+  const oldRanges: CharRange[] = [];
+  const newRanges: CharRange[] = [];
+  let oldLen = 0;
+  let newLen = 0;
+  let hasOld = block.length === 0;
+  let hasNew = block.length === 0;
+  for (const seg of block) {
+    const len = seg.text.length;
+    if (seg.kind === "common") {
+      oldLen += len; newLen += len; hasOld = true; hasNew = true;
+    } else if (seg.kind === "old") {
+      oldRanges.push({ start: oldLen, end: oldLen + len }); oldLen += len; hasOld = true;
+    } else {
+      newRanges.push({ start: newLen, end: newLen + len }); newLen += len; hasNew = true;
+    }
+  }
+  return { oldRanges, newRanges, hasOld, hasNew };
+}
+
+/**
+ * Attach word-diff ranges to each line of a file's structural diff, keyed by
+ * side + line number, dropping ranges for near-total rewrites. Returns a new
+ * array; never mutates the input.
+ */
+export function withWordChanges(lines: DiffLine[], changes: FileWordChanges | undefined): DiffLine[] {
+  if (!changes) return lines;
+  return lines.map((line) => {
+    const ranges = rangesFor(line, changes);
+    if (ranges.length === 0 || isNearTotal(ranges, line.text.length)) return line;
+    return { ...line, changes: ranges };
+  });
+}
+
+/** The changed ranges recorded for a line's side, or an empty list. */
+function rangesFor(line: DiffLine, changes: FileWordChanges): CharRange[] {
+  if (line.kind === "del" && line.oldNo !== undefined) return changes.oldByLine.get(line.oldNo) ?? [];
+  if (line.kind === "add" && line.newNo !== undefined) return changes.newByLine.get(line.newNo) ?? [];
+  return [];
+}
+
+/** Whether the changed ranges cover at least the near-total-rewrite ratio. */
+function isNearTotal(ranges: CharRange[], length: number): boolean {
+  if (length <= 0) return true;
+  const changed = ranges.reduce((sum, r) => sum + (r.end - r.start), 0);
+  return changed / length >= NEAR_TOTAL_REWRITE_RATIO;
+}

package/src/services/ai.ts

@@ -0,0 +1,137 @@
+import { query as sdkQuery } from "@anthropic-ai/claude-agent-sdk";
+
+/** Options for one agentic chat turn. */
+export interface AiChatOptions {
+  /** The user's prompt for this turn. */
+  prompt: string;
+  /** Model id to run (from the config model list). */
+  model: string;
+  /** Working directory the agent operates in (the head-checkout worktree). */
+  cwd: string;
+  /** Extra readable/writable directories (e.g. the base checkout, artifacts dir). */
+  additionalDirectories?: string[];
+  /** Optional system prompt prepended to the session. */
+  systemPrompt?: string;
+}
+
+/**
+ * A single streamed event from an agentic turn:
+ * - `delta`: an incremental token of assistant text, for live display.
+ * - `text`: a finalized assistant text block, used as the authoritative
+ *   content to persist (independent of whether deltas were emitted).
+ * - `activity`: a human-readable note that the agent is doing something
+ *   (using a tool), shown while it works so the wait never feels frozen.
+ */
+export type ChatEvent =
+  | { kind: "delta"; text: string }
+  | { kind: "text"; text: string }
+  | { kind: "activity"; text: string };
+
+/** A stream of raw agent messages (shape narrowed internally). */
+export type RawMessageStream = AsyncIterable<unknown>;
+
+/** The injectable boundary: turn chat options into a raw message stream. */
+export type QueryRunner = (opts: AiChatOptions) => RawMessageStream;
+
+/** The AI service: run an agentic chat turn and stream back events. */
+export interface AiService {
+  /** Stream {@link ChatEvent}s as the turn progresses. */
+  chat(opts: AiChatOptions): AsyncIterable<ChatEvent>;
+}
+
+/** True when the value is a non-null object. */
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null;
+}
+
+/** A short human phrase describing a tool_use block (e.g. "Reading src/app.ts"). */
+function describeTool(name: string, input: Record<string, unknown>): string {
+  const str = (v: unknown): string => (typeof v === "string" ? v : "");
+  const trunc = (s: string, n: number): string => (s.length > n ? `${s.slice(0, n - 1)}…` : s);
+  switch (name) {
+    case "Read":
+      return `Reading ${str(input.file_path)}`;
+    case "Edit":
+    case "Write":
+    case "NotebookEdit":
+      return `Editing ${str(input.file_path ?? input.notebook_path)}`;
+    case "Bash":
+      return `Running: ${trunc(str(input.command), 60)}`;
+    case "Grep":
+      return `Searching “${trunc(str(input.pattern), 40)}”`;
+    case "Glob":
+      return `Finding files ${str(input.pattern)}`;
+    default:
+      return `${name}…`;
+  }
+}
+
+/** Extract a live text delta from a partial (`stream_event`) message, if any. */
+function deltaOf(msg: Record<string, unknown>): ChatEvent[] {
+  if (!isRecord(msg.event)) return [];
+  const event = msg.event;
+  if (event.type !== "content_block_delta" || !isRecord(event.delta)) return [];
+  const delta = event.delta;
+  if (delta.type === "text_delta" && typeof delta.text === "string") return [{ kind: "delta", text: delta.text }];
+  return [];
+}
+
+/** Extract finalized text + tool activity from a complete assistant message. */
+function assistantEventsOf(msg: Record<string, unknown>): ChatEvent[] {
+  if (!isRecord(msg.message)) return [];
+  const content: unknown = msg.message.content;
+  if (!Array.isArray(content)) return [];
+  const out: ChatEvent[] = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block.type === "text" && typeof block.text === "string") {
+      out.push({ kind: "text", text: block.text });
+    } else if (block.type === "tool_use" && typeof block.name === "string") {
+      out.push({ kind: "activity", text: describeTool(block.name, isRecord(block.input) ? block.input : {}) });
+    }
+  }
+  return out;
+}
+
+/**
+ * Map one raw SDK message to zero or more {@link ChatEvent}s. Live text comes
+ * from streaming `delta`s; the authoritative persisted text and tool activity
+ * come from complete assistant messages. Exported for unit testing.
+ */
+export function eventsOf(msg: unknown): ChatEvent[] {
+  if (!isRecord(msg)) return [];
+  if (msg.type === "stream_event") return deltaOf(msg);
+  if (msg.type === "assistant") return assistantEventsOf(msg);
+  return [];
+}
+
+/** The default runner: drive the Claude Agent SDK with full clone access. */
+function defaultRunner(opts: AiChatOptions): RawMessageStream {
+  return sdkQuery({
+    prompt: opts.prompt,
+    options: {
+      model: opts.model,
+      cwd: opts.cwd,
+      additionalDirectories: opts.additionalDirectories,
+      permissionMode: "auto",
+      systemPrompt: opts.systemPrompt,
+      // Emit token-level deltas so replies stream as they are generated.
+      includePartialMessages: true,
+    },
+  });
+}
+
+/**
+ * Create an {@link AiService}. The `runner` seam wraps the Claude Agent SDK by
+ * default (using the user's Claude Max login) and is replaced with a fake in
+ * tests. `chat` maps each raw message into {@link ChatEvent}s.
+ */
+export function createAiService(runner: QueryRunner = defaultRunner): AiService {
+  return {
+    async *chat(opts: AiChatOptions): AsyncIterable<ChatEvent> {
+      for await (const msg of runner(opts)) {
+        yield* eventsOf(msg);
+      }
+    },
+  };
+}

package/src/services/exec.ts

@@ -0,0 +1,44 @@
+/** Result of running an external command. */
+export interface CommandResult {
+  /** Captured standard output. */
+  stdout: string;
+  /** Captured standard error. */
+  stderr: string;
+  /** Process exit code (0 = success). */
+  exitCode: number;
+}
+
+/** Options for running a command. */
+export interface RunOptions {
+  /** Working directory to run in. */
+  cwd?: string;
+  /** String written to the command's stdin. */
+  input?: string;
+}
+
+/**
+ * Abstraction over running external commands (git, gh, sem, rg). Services
+ * depend on this interface so tests can inject a fake runner instead of
+ * spawning real processes.
+ */
+export interface CommandRunner {
+  run(cmd: string, args: string[], opts?: RunOptions): Promise<CommandResult>;
+}
+
+/** The real runner, backed by `Bun.spawn`. */
+export const bunRunner: CommandRunner = {
+  async run(cmd, args, opts) {
+    const proc = Bun.spawn([cmd, ...args], {
+      cwd: opts?.cwd,
+      stdin: opts?.input != null ? new TextEncoder().encode(opts.input) : undefined,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode: number = await proc.exited;
+    return { stdout, stderr, exitCode };
+  },
+};

package/src/services/ghPr.ts

@@ -0,0 +1,102 @@
+import { bunRunner, type CommandRunner } from "./exec.ts";
+
+/** Minimal commit metadata for a PR, from GitHub. */
+export interface PrCommitMeta {
+  /** Full commit SHA. */
+  sha: string;
+  /** Commit subject (message headline). */
+  subject: string;
+  /** First author's display name. */
+  authorName: string;
+  /** ISO commit date. */
+  isoDate: string;
+}
+
+/** PR-level metadata from GitHub. */
+export interface PrMeta {
+  /** PR title. */
+  title: string;
+  /** PR description (the PR body), as GitHub-flavored markdown. Normalized to
+   * LF line endings and trimmed; an empty string means "no description". */
+  body: string;
+  /** Target (base) branch name. */
+  baseRef: string;
+  /** Source (head) branch name. */
+  headRef: string;
+  /** Head commit SHA. */
+  headSha: string;
+  /** PR commits, oldest → newest (as GitHub returns them). */
+  commits: PrCommitMeta[];
+}
+
+/** Identifies a PR for metadata lookup. */
+export interface PrLookup {
+  owner: string;
+  repo: string;
+  number: number;
+}
+
+/** Service for fetching PR-level metadata via the `gh` CLI. */
+export interface GhPrService {
+  fetchPr(ref: PrLookup): Promise<PrMeta>;
+}
+
+/** Create a {@link GhPrService}. */
+export function createGhPrService(runner: CommandRunner = bunRunner): GhPrService {
+  return {
+    async fetchPr(ref: PrLookup): Promise<PrMeta> {
+      const args: string[] = [
+        "pr", "view", String(ref.number), "--repo", `${ref.owner}/${ref.repo}`,
+        "--json", "title,body,baseRefName,headRefName,headRefOid,commits",
+      ];
+      const res = await runner.run("gh", args);
+      if (res.exitCode !== 0) {
+        throw new Error(`gh pr view failed (${res.exitCode}): ${res.stderr.trim()}`);
+      }
+      return toPrMeta(JSON.parse(res.stdout));
+    },
+  };
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null;
+}
+
+function str(v: unknown): string {
+  return typeof v === "string" ? v : "";
+}
+
+/**
+ * Normalize a raw PR body: coerce non-strings to "", convert CRLF → LF, and
+ * trim. A whitespace-only body collapses to "" so callers can treat empty as
+ * "no description provided".
+ */
+export function normalizeBody(raw: unknown): string {
+  return str(raw).replace(/\r\n/g, "\n").trim();
+}
+
+/** Map raw `gh pr view` JSON into a typed {@link PrMeta}. */
+function toPrMeta(raw: unknown): PrMeta {
+  const rec: Record<string, unknown> = isRecord(raw) ? raw : {};
+  const rawCommits: unknown[] = Array.isArray(rec.commits) ? rec.commits : [];
+  return {
+    title: str(rec.title),
+    body: normalizeBody(rec.body),
+    baseRef: str(rec.baseRefName),
+    headRef: str(rec.headRefName),
+    headSha: str(rec.headRefOid),
+    commits: rawCommits.map(toCommitMeta),
+  };
+}
+
+function toCommitMeta(raw: unknown): PrCommitMeta {
+  const rec: Record<string, unknown> = isRecord(raw) ? raw : {};
+  const authors: unknown[] = Array.isArray(rec.authors) ? rec.authors : [];
+  const first: Record<string, unknown> = isRecord(authors[0]) ? authors[0] : {};
+  return {
+    sha: str(rec.oid),
+    subject: str(rec.messageHeadline),
+    authorName: str(first.name),
+    isoDate: str(rec.committedDate),
+  };
+}

package/src/services/ghSearch.ts

@@ -0,0 +1,135 @@
+import { bunRunner, type CommandRunner } from "./exec.ts";
+import { parsePrUrl } from "@/domain/url.ts";
+
+/** How the authenticated user is related to a pull request. */
+export type PrRelationship = "authored" | "assigned" | "review-requested";
+
+/** A pull request the authenticated user cares about, from GitHub search. */
+export interface MyPrSummary {
+  /** Repository owner / organisation. */
+  owner: string;
+  /** Repository name. */
+  repo: string;
+  /** Pull request number. */
+  number: number;
+  /** PR title. */
+  title: string;
+  /** Canonical PR URL (used as the dedupe key and to load the PR). */
+  url: string;
+  /** GitHub login of the PR author. */
+  author: string;
+  /** Whether the PR is a draft. */
+  isDraft: boolean;
+  /** ISO-8601 last-updated timestamp (used to sort newest-first). */
+  updatedAtIso: string;
+  /** All relationships the viewer has to this PR, in canonical order. */
+  relationships: PrRelationship[];
+}
+
+/** Service for listing the viewer's open PRs via the `gh` CLI. */
+export interface GhSearchService {
+  /** Open PRs authored by, assigned to, or review-requested from the viewer. */
+  listMyPrs(): Promise<MyPrSummary[]>;
+}
+
+/** The `--<flag>=@me` search filter for each relationship. */
+const RELATION_FLAG: Record<PrRelationship, string> = {
+  authored: "--author=@me",
+  assigned: "--assignee=@me",
+  "review-requested": "--review-requested=@me",
+};
+
+/** Canonical relationship order for stable, deduped unions. */
+const RELATION_ORDER: readonly PrRelationship[] = ["authored", "assigned", "review-requested"];
+
+/** JSON fields requested from `gh search prs`. */
+const JSON_FIELDS = "number,title,url,author,isDraft,updatedAt";
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null;
+}
+
+function str(v: unknown): string {
+  return typeof v === "string" ? v : "";
+}
+
+/**
+ * Parse a `gh search prs --json` array into typed summaries, each tagged with a
+ * single relationship. Owner/repo/number are derived from the item's URL; items
+ * without a valid PR URL are skipped rather than throwing.
+ */
+export function toMyPrs(rawJson: string, relationship: PrRelationship): MyPrSummary[] {
+  const parsed: unknown = JSON.parse(rawJson);
+  const items: unknown[] = Array.isArray(parsed) ? parsed : [];
+  const out: MyPrSummary[] = [];
+  for (const raw of items) {
+    if (!isRecord(raw)) continue;
+    const url: string = str(raw.url);
+    const ref = tryParse(url);
+    if (!ref) continue;
+    const author: Record<string, unknown> = isRecord(raw.author) ? raw.author : {};
+    out.push({
+      owner: ref.owner,
+      repo: ref.repo,
+      number: ref.number,
+      title: str(raw.title),
+      url,
+      author: str(author.login),
+      isDraft: raw.isDraft === true,
+      updatedAtIso: str(raw.updatedAt),
+      relationships: [relationship],
+    });
+  }
+  return out;
+}
+
+/** Parse a PR URL, returning null instead of throwing on a non-PR URL. */
+function tryParse(url: string): { owner: string; repo: string; number: number } | null {
+  try {
+    return parsePrUrl(url);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Merge per-relationship result groups into one list: deduped by URL, with each
+ * PR's relationships unioned into canonical order and the list sorted
+ * newest-updated first.
+ */
+export function mergePrGroups(groups: MyPrSummary[][]): MyPrSummary[] {
+  const byUrl = new Map<string, MyPrSummary>();
+  for (const group of groups) {
+    for (const pr of group) {
+      const existing = byUrl.get(pr.url);
+      if (!existing) {
+        byUrl.set(pr.url, { ...pr, relationships: [...pr.relationships] });
+        continue;
+      }
+      const rels = new Set<PrRelationship>([...existing.relationships, ...pr.relationships]);
+      existing.relationships = RELATION_ORDER.filter((r) => rels.has(r));
+    }
+  }
+  return [...byUrl.values()].sort((a, b) => b.updatedAtIso.localeCompare(a.updatedAtIso));
+}
+
+/** Create a {@link GhSearchService}. */
+export function createGhSearchService(runner: CommandRunner = bunRunner): GhSearchService {
+  async function search(relationship: PrRelationship): Promise<MyPrSummary[]> {
+    const res = await runner.run("gh", [
+      "search", "prs", RELATION_FLAG[relationship],
+      "--state=open", "--json", JSON_FIELDS, "--limit", "100",
+    ]);
+    if (res.exitCode !== 0) {
+      throw new Error(`gh search prs failed (${res.exitCode}): ${res.stderr.trim()}`);
+    }
+    return toMyPrs(res.stdout, relationship);
+  }
+
+  return {
+    async listMyPrs(): Promise<MyPrSummary[]> {
+      const groups = await Promise.all(RELATION_ORDER.map(search));
+      return mergePrGroups(groups);
+    },
+  };
+}