mergie-cli 0.1.0

package/src/daemon/githubThreads.ts

@@ -0,0 +1,92 @@
+import type { DiffSide } from "@/domain/hash.ts";
+
+/** A cached GitHub comment row enriched with its computed html URL. */
+export interface GithubThreadRow {
+  /** GitHub's stable comment id. */
+  githubId: string;
+  /** File path the comment is on (null if GitHub omitted it). */
+  path: string | null;
+  /** Raw side string from GitHub (`'LEFT'`/`'RIGHT'`). */
+  side: string | null;
+  /** Line number the comment anchors to (side-relative, 1-based). */
+  line: number | null;
+  /** Markdown body. */
+  body: string;
+  /** Author login (null if unknown). */
+  author: string | null;
+  /** Creation time as a Unix ms timestamp (null if unknown). */
+  createdAt: number | null;
+  /** Parent comment id if this is a reply; null for roots. */
+  inReplyTo: string | null;
+  /** Full URL to the comment on GitHub. */
+  htmlUrl: string;
+}
+
+/** A single comment as presented within a thread. */
+export interface ThreadComment {
+  /** GitHub comment id. */
+  githubId: string;
+  /** Author login (empty string if unknown). */
+  author: string;
+  /** Markdown body. */
+  body: string;
+  /** Creation time (Unix ms) or null. */
+  createdAt: number | null;
+  /** Link to the comment on GitHub. */
+  htmlUrl: string;
+}
+
+/** A GitHub inline comment thread: a root comment plus ordered replies. */
+export interface GithubThread {
+  /** File the thread is on. */
+  path: string | null;
+  /** Diff side the thread anchors to. */
+  side: DiffSide;
+  /** Side-relative line number the thread anchors to. */
+  line: number | null;
+  /** The root (non-reply) comment. */
+  root: ThreadComment;
+  /** Replies, oldest-first. */
+  replies: ThreadComment[];
+}
+
+/** Normalise GitHub's side string to the typed union (defaulting to RIGHT). */
+function toSide(side: string | null): DiffSide {
+  return side === "LEFT" ? "LEFT" : "RIGHT";
+}
+
+/** Project a row to its thread-comment view. */
+function toComment(r: GithubThreadRow): ThreadComment {
+  return { githubId: r.githubId, author: r.author ?? "", body: r.body, createdAt: r.createdAt, htmlUrl: r.htmlUrl };
+}
+
+/**
+ * Group flat GitHub inline comments into threads: each root (no `inReplyTo`)
+ * gets its replies attached oldest-first. Replies whose parent is missing from
+ * the set become their own single-comment threads so nothing is dropped.
+ */
+export function groupGithubThreads(rows: GithubThreadRow[]): GithubThread[] {
+  const byId = new Map<string, GithubThreadRow>(rows.map((r) => [r.githubId, r]));
+  const replies = new Map<string, GithubThreadRow[]>();
+  const roots: GithubThreadRow[] = [];
+
+  for (const r of rows) {
+    if (r.inReplyTo !== null && byId.has(r.inReplyTo)) {
+      const bucket = replies.get(r.inReplyTo) ?? [];
+      bucket.push(r);
+      replies.set(r.inReplyTo, bucket);
+    } else {
+      roots.push(r);
+    }
+  }
+
+  return roots.map((root) => ({
+    path: root.path,
+    side: toSide(root.side),
+    line: root.line,
+    root: toComment(root),
+    replies: (replies.get(root.githubId) ?? [])
+      .sort((a, b) => (a.createdAt ?? 0) - (b.createdAt ?? 0))
+      .map(toComment),
+  }));
+}

package/src/daemon/inflight.ts

@@ -0,0 +1,49 @@
+/** Tracks in-flight long-running operations so shutdown can drain them. */
+export interface Inflight {
+  /** Mark an operation started; returns an idempotent `done` callback. */
+  begin(): () => void;
+  /** Number of currently-active operations. */
+  active(): number;
+  /**
+   * Resolve `true` once no operations are in flight, or `false` if `timeoutMs`
+   * elapses first. Resolves `true` immediately when already idle.
+   */
+  idle(timeoutMs: number): Promise<boolean>;
+}
+
+/** Create an {@link Inflight} tracker. */
+export function createInflight(): Inflight {
+  let count = 0;
+  let waiters: Array<() => void> = [];
+
+  const settleIfIdle = (): void => {
+    if (count === 0) {
+      const pending = waiters;
+      waiters = [];
+      for (const w of pending) w();
+    }
+  };
+
+  return {
+    begin() {
+      count += 1;
+      let called = false;
+      return () => {
+        if (called) return;
+        called = true;
+        count = Math.max(0, count - 1);
+        settleIfIdle();
+      };
+    },
+    active: () => count,
+    idle(timeoutMs: number) {
+      if (count === 0) return Promise.resolve(true);
+      return new Promise<boolean>((resolve) => {
+        let done = false;
+        const finish = (v: boolean): void => { if (!done) { done = true; resolve(v); } };
+        waiters.push(() => finish(true));
+        setTimeout(() => finish(false), timeoutMs);
+      });
+    },
+  };
+}

package/src/daemon/postMapping.ts

@@ -0,0 +1,94 @@
+import { commentAnchorHash, type DiffSide } from "@/domain/hash.ts";
+import type { DiffLine } from "@/domain/diff.ts";
+import type { PostCommentInput } from "@/services/github.ts";
+
+/** A resolved line-number span on one diff side (both bounds inclusive). */
+export interface LineSpan {
+  /** First (smallest) 1-based line number on the side. */
+  startNo: number;
+  /** Last 1-based line number on the side. */
+  endNo: number;
+}
+
+/** Indices of lines that participate on a given diff side, in reading order. */
+function sideIndices(lines: DiffLine[], side: DiffSide): number[] {
+  const out: number[] = [];
+  lines.forEach((line, i) => {
+    const onSide: boolean = side === "RIGHT"
+      ? line.kind === "add" || line.kind === "ctx"
+      : line.kind === "del" || line.kind === "ctx";
+    if (onSide) out.push(i);
+  });
+  return out;
+}
+
+/** The side line number of a line (new-side for RIGHT, old-side for LEFT). */
+function lineNo(line: DiffLine, side: DiffSide): number | undefined {
+  return side === "RIGHT" ? line.newNo : line.oldNo;
+}
+
+/**
+ * Locate a contiguous window of `span` same-side lines whose joined text hashes
+ * to `anchorHash`, and return its first/last side line numbers — or null when
+ * the block is not present on that side.
+ */
+export function locateLineComment(
+  path: string,
+  lines: DiffLine[],
+  side: DiffSide,
+  span: number,
+  anchorHash: string,
+): LineSpan | null {
+  const idx: number[] = sideIndices(lines, side);
+  for (let s = 0; s + span <= idx.length; s++) {
+    const window: number[] = idx.slice(s, s + span);
+    const text: string = window.map((i) => lines[i]?.text ?? "").join("\n");
+    if (commentAnchorHash(path, side, text) !== anchorHash) continue;
+    const startNo = lineNo(lines[window[0] ?? 0]!, side);
+    const endNo = lineNo(lines[window[window.length - 1] ?? 0]!, side);
+    if (startNo === undefined || endNo === undefined) return null;
+    return { startNo, endNo };
+  }
+  return null;
+}
+
+/**
+ * The side line-number span covering a hunk's changed lines (additions for
+ * RIGHT, deletions for LEFT). Null when the hunk changes nothing on that side.
+ */
+export function hunkChangedSpan(lines: DiffLine[], side: DiffSide): LineSpan | null {
+  const changedKind: DiffLine["kind"] = side === "RIGHT" ? "add" : "del";
+  const nums: number[] = lines
+    .filter((l) => l.kind === changedKind)
+    .map((l) => lineNo(l, side))
+    .filter((n): n is number => n !== undefined);
+  if (nums.length === 0) return null;
+  return { startNo: Math.min(...nums), endNo: Math.max(...nums) };
+}
+
+/** Fields needed to build a GitHub inline-comment post request. */
+export interface ToPostInputArgs extends LineSpan {
+  /** Repo-relative file path. */
+  path: string;
+  /** Diff side to post on. */
+  side: DiffSide;
+  /** Markdown body. */
+  body: string;
+  /** Commit SHA to anchor the comment to. */
+  commitId: string;
+}
+
+/**
+ * Build a {@link PostCommentInput}: a single-line comment when start and end
+ * coincide, otherwise a multi-line span from `startNo` to `endNo`.
+ */
+export function toPostInput(args: ToPostInputArgs): PostCommentInput {
+  const base: PostCommentInput = {
+    body: args.body,
+    commitId: args.commitId,
+    path: args.path,
+    side: args.side,
+    line: args.endNo,
+  };
+  return args.startNo < args.endNo ? { ...base, startLine: args.startNo } : base;
+}

package/src/daemon/registry.ts

@@ -0,0 +1,263 @@
+import type { CommitInfo } from "@/services/git.ts";
+import type { CodeResult } from "@/services/symbols.ts";
+import type { ChatMessageRow, ChatScopeKind, ChatSessionRow } from "@/db/repositories/chatSessions.ts";
+import type { ArtifactRow } from "@/db/repositories/artifacts.ts";
+import type { AiReviewRow } from "@/db/repositories/aiReviews.ts";
+import type { AiReviewStatus } from "./aiReviewTracker.ts";
+import type { ModelChoice, ReviewTemplate } from "@/domain/config.ts";
+
+/** Options for running an AI review of a commit range. */
+export interface AiReviewOptions {
+  /** Model id to run. */
+  model: string;
+  /** Optional config template id to base the review on. */
+  templateId?: string;
+  /** Optional user prompt to focus the review. */
+  prompt?: string;
+}
+
+/** A commit range an AI turn / artifact is linked to. */
+export interface ChatRange {
+  /** Range baseline SHA. */
+  start: string;
+  /** Range end SHA. */
+  end: string;
+}
+
+/**
+ * A live event streamed during a chat turn:
+ * - `delta`: an incremental chunk of the assistant's reply text.
+ * - `activity`: a human-readable note that the agent is using a tool.
+ */
+export interface LiveChatEvent {
+  /** Which kind of live event this is. */
+  kind: "delta" | "activity";
+  /** The delta text, or the activity description. */
+  text: string;
+}
+import type { Range } from "@/domain/ranges.ts";
+import type { ReviewedRangeRow } from "@/db/repositories/reviewedRanges.ts";
+import type { CommentRow, CommentSide, CommentKind } from "@/db/repositories/comments.ts";
+import type { AllCommentEntry } from "./allComments.ts";
+import type { FileView } from "./reviewService.ts";
+import type { SplitRow } from "./splitView.ts";
+
+/** Input to create a new comment (server derives the anchor hash). */
+export interface NewComment {
+  /** Whether the comment targets a line or the whole hunk. */
+  kind: CommentKind;
+  /** Which diff side it applies to. */
+  side: CommentSide;
+  /** Repo-relative file path. */
+  path: string;
+  /** Markdown body. */
+  body: string;
+  /** The end commit of the range the comment was made in. */
+  madeAtSha: string;
+  /** For `lines`: the exact text of the commented line. */
+  lineText?: string;
+  /** For `lines`: the first line number on the comment's side. */
+  lineNo?: number;
+  /** For `lines`: the last line number on the comment's side (defaults to lineNo). */
+  endLineNo?: number;
+  /** For `hunk`: the hunk's content hash. */
+  hunkHash?: string;
+}
+
+/**
+ * Which commit a comment should be anchored to when posting to GitHub.
+ *
+ * - `'end'` — the range's end commit (pins to exactly what was reviewed).
+ * - `'head'` — the PR's head commit (the comment stays "live").
+ */
+export type PostTarget = "end" | "head";
+
+/**
+ * The result of resolving where a comment would land if posted to GitHub.
+ * Used both to preview (warn before posting) and to drive the actual post.
+ */
+export interface PostPreview {
+  /** Whether the comment can be posted at the chosen target. */
+  canPost: boolean;
+  /** The commit SHA the comment would be anchored to. */
+  commitId: string;
+  /** The diff side the comment would post on. */
+  side: CommentSide;
+  /** The last (or only) line number, or null when it cannot be resolved. */
+  line: number | null;
+  /** First line of a multi-line span, or null for a single-line comment. */
+  startLine: number | null;
+  /** A human-readable reason the comment cannot be posted; null when postable. */
+  warning: string | null;
+}
+
+/** A PR's commit topology for the range selector. */
+export interface CommitsWithBaseline {
+  /** The "before-PR" baseline SHA (merge-base with the target branch). */
+  baselineSha: string;
+  /** PR commits, oldest → newest. */
+  commits: CommitInfo[];
+}
+
+/** Per-PR review operations (backed by the PR's clone + database). */
+export interface Workspace {
+  /** The public PR summary. */
+  pr: LoadedPr;
+  /** The selectable models and review templates from config. */
+  config(): { models: ModelChoice[]; templates: ReviewTemplate[] };
+  /**
+   * Re-fetch the PR's metadata from GitHub and its git objects, picking up any
+   * new commits / head movement and an updated title/base.
+   */
+  refresh(): Promise<void>;
+  /** PR commits mapped from metadata (no clone required). */
+  commits(): CommitInfo[];
+  /** Commit topology (baseline + commits) for range selection (clones lazily). */
+  commitsWithBaseline(): Promise<CommitsWithBaseline>;
+  /** The default range to show on open (last-reviewed → head, else whole PR). */
+  defaultRange(): Promise<Range>;
+  /**
+   * Assemble the file/hunk view for a commit range.
+   *
+   * @param ignoreWhitespace - When true, collapse whitespace-only changes so a
+   *   line/hunk that differs only in spacing no longer appears as changed.
+   */
+  rangeView(startSha: string, endSha: string, ignoreWhitespace?: boolean): Promise<FileView[]>;
+  /** Set or clear a hunk's viewed state (by hunk hash). */
+  setHunkViewed(hunkHash: string, viewed: boolean): void;
+  /** Mark a commit range reviewed. */
+  addReviewedRange(startSha: string, endSha: string): void;
+  /** Un-mark a reviewed range by its exact (startSha, endSha) pair. */
+  removeReviewedRange(startSha: string, endSha: string): void;
+  /** List reviewed ranges (oldest → newest). */
+  listReviewedRanges(): ReviewedRangeRow[];
+  /** Create a comment; returns its id. */
+  addComment(input: NewComment): number;
+  /** Edit a comment's body; propagates to GitHub if the comment was posted. */
+  editComment(id: number, body: string): Promise<void>;
+  /** Delete a comment; also deletes it on GitHub if it was posted. */
+  deleteComment(id: number): Promise<void>;
+  /** All comments for this PR. */
+  listComments(): CommentRow[];
+  /**
+   * Unified list for the "All comments" view: local comments merged with
+   * fetched GitHub threads (deduped by GitHub id), classified by origin and
+   * authorship. Async because it resolves the viewer's GitHub login.
+   */
+  listAllComments(): Promise<AllCommentEntry[]>;
+  /** Resolve where a comment would post (line + warnings) without posting. */
+  postCommentPreview(id: number, target: PostTarget): Promise<PostPreview>;
+  /** Post a comment to GitHub; records the GitHub id/url on success. */
+  postComment(id: number, target: PostTarget): Promise<{ githubId: string; githubUrl: string }>;
+  /** Pull GitHub inline comments into the local cache; returns the count synced. */
+  syncGithub(): Promise<number>;
+  /** Reply to a GitHub thread (by root comment id) and refresh the cache. */
+  replyToThread(rootGithubId: string, body: string): Promise<void>;
+  /**
+   * Edit a GitHub comment (by GitHub id) that the viewer authored, updating it
+   * on GitHub and in the local cache. Refuses comments authored by others.
+   */
+  editGithubComment(githubId: string, body: string): Promise<void>;
+  /**
+   * Delete a GitHub comment (by GitHub id) that the viewer authored, on GitHub
+   * and from the local cache. Refuses comments authored by others.
+   */
+  deleteGithubComment(githubId: string): Promise<void>;
+  /**
+   * Definition of a symbol (via `sem`) at the given commit's checkout.
+   * `file` (repo-relative) scopes the lookup; if the scoped call is empty it
+   * retries unscoped.
+   */
+  symbolDefinition(symbol: string, sha: string, file?: string): Promise<CodeResult[]>;
+  /**
+   * Usages of a symbol (via `sem`) at the given commit's checkout, resolved to
+   * the real reference lines within each dependent. `file` scopes as above.
+   */
+  symbolUsages(symbol: string, sha: string, file?: string): Promise<CodeResult[]>;
+  /**
+   * Literal (default) or regex word search (via `rg`) at a commit's checkout.
+   * @param opts - `caseSensitive` (default false), `regex` (default false).
+   */
+  symbolSearch(word: string, sha: string, opts?: { caseSensitive?: boolean; regex?: boolean }): Promise<CodeResult[]>;
+  /** Full text of a file at a commit (null if absent/binary). */
+  fileAt(sha: string, path: string): Promise<string | null>;
+  /** Start an AI chat session scoped to a hunk or file; returns its id. */
+  createChatSession(scopeKind: ChatScopeKind, scopeRef: string, model: string, title?: string): number;
+  /** List chat sessions, optionally filtered to a scope. */
+  listChatSessions(scopeKind?: ChatScopeKind, scopeRef?: string): ChatSessionRow[];
+  /** List messages for a chat session (oldest first). */
+  listChatMessages(sessionId: number): ChatMessageRow[];
+  /**
+   * Run one agentic chat turn: persist the user prompt, stream live events via
+   * `onEvent` (`delta` = incremental reply text; `activity` = a note that the
+   * agent is using a tool), persist the full reply, and return it. When a
+   * `range` is given, any files the agent writes to the artifacts folder are
+   * captured and linked to that commit range.
+   */
+  streamChat(sessionId: number, prompt: string, onEvent: (ev: LiveChatEvent) => void, range?: ChatRange): Promise<string>;
+  /** List generated artifacts, optionally scoped to a commit range. */
+  listArtifacts(range?: ChatRange): ArtifactRow[];
+  /** Absolute path of an artifact file if it exists within the artifacts dir. */
+  resolveArtifact(relPath: string): string | null;
+  /** Run an AI review of a commit range; persists and returns the result. */
+  runAiReview(range: ChatRange, opts: AiReviewOptions): Promise<AiReviewRow>;
+  /** List AI reviews, optionally scoped to a commit range. */
+  listAiReviews(range?: ChatRange): AiReviewRow[];
+  /**
+   * Snapshot of in-flight and recently-completed AI reviews for this PR, keyed
+   * by range. Powers the app-level progress indicator; completed entries linger
+   * until dismissed.
+   */
+  aiReviewStatuses(): AiReviewStatus[];
+  /** Dismiss a completed (done/failed) AI-review status for a range. */
+  dismissAiReviewStatus(range: ChatRange): void;
+  /**
+   * Full-file side-by-side split rows for a path over a range.
+   *
+   * @param ignoreWhitespace - When true, collapse whitespace-only changes.
+   */
+  fileSplit(path: string, startSha: string, endSha: string, ignoreWhitespace?: boolean): Promise<SplitRow[]>;
+}
+
+/** A pull request loaded into the daemon. */
+export interface LoadedPr {
+  /** Stable id for routing/UI (e.g. `owner_repo_number`). */
+  id: string;
+  /** The original PR URL. */
+  url: string;
+  /** Repository owner. */
+  owner: string;
+  /** Repository name. */
+  repo: string;
+  /** PR number. */
+  number: number;
+  /** PR title (from GitHub). */
+  title: string;
+  /** PR description / body (from GitHub), as GitHub-flavored markdown.
+   * Empty string when the PR has no description. Kept current by Refresh PR. */
+  body: string;
+  /** Target branch the PR merges into. */
+  baseRef: string;
+  /** Source branch the PR merges from. */
+  headRef: string;
+}
+
+/** Manages the set of PRs the daemon is serving. */
+export interface PrRegistry {
+  /** Load (or attach to an already-loaded) PR by URL. */
+  loadPr(url: string): Promise<LoadedPr>;
+  /** All currently-loaded PRs. */
+  listPrs(): LoadedPr[];
+  /** A loaded PR by id, or undefined. */
+  getPr(id: string): LoadedPr | undefined;
+  /** Commits belonging to a loaded PR, oldest → newest. */
+  commits(id: string): Promise<CommitInfo[]>;
+  /** The review workspace for a loaded PR, or undefined if not loaded. */
+  getWorkspace(id: string): Workspace | undefined;
+  /**
+   * Wait for in-flight AI operations (chat turns, reviews) to finish before
+   * shutdown, up to `timeoutMs`. Resolves `true` if they drained, `false` on
+   * timeout.
+   */
+  drainAi(timeoutMs: number): Promise<boolean>;
+}

package/src/daemon/reviewPrompt.ts

@@ -0,0 +1,22 @@
+import type { ChatRange } from "./registry.ts";
+
+/**
+ * Assemble the prompt for an AI review: the chosen template's prompt (if any),
+ * the user's optional focus prompt (if any), and an instruction to inspect the
+ * range's diff in the working directory.
+ */
+export function buildReviewPrompt(
+  templatePrompt: string | null,
+  userPrompt: string | null,
+  range: ChatRange,
+): string {
+  const parts: string[] = [];
+  if (templatePrompt) parts.push(templatePrompt.trim());
+  if (userPrompt) parts.push(userPrompt.trim());
+  parts.push(
+    `Review the changes in this pull request from commit ${range.start} to ${range.end}. ` +
+      `Run \`git diff ${range.start} ${range.end}\` in the working directory to see them, ` +
+      `explore the code as needed, and respond in markdown.`,
+  );
+  return parts.join("\n\n");
+}