mergie-cli 0.1.0

package/src/web/state/useChat.ts

@@ -0,0 +1,181 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { trpc } from "../trpc.ts";
+import type { ChatMessageRow, ChatScopeKind, ChatSessionRow } from "@/db/repositories/chatSessions.ts";
+import type { ArtifactRow } from "@/db/repositories/artifacts.ts";
+import type { ModelChoice } from "@/domain/config.ts";
+
+/** A commit range accessor (the range currently in view). */
+export type RangeAccessor = () => { start: string; end: string } | null;
+
+/** What a chat session is scoped to. */
+export interface ChatScope {
+  /** Hunk or file. */
+  kind: ChatScopeKind;
+  /** Hunk hash or file path. */
+  ref: string;
+  /** Human label for the panel header. */
+  label: string;
+}
+
+/** Chat state + actions for the AI chat panel. */
+export interface ChatState {
+  scope: ChatScope | null;
+  open: (scope: ChatScope) => void;
+  close: () => void;
+  sessions: ChatSessionRow[];
+  activeId: number | null;
+  selectSession: (id: number) => void;
+  newSession: () => void;
+  messages: ChatMessageRow[];
+  models: ModelChoice[];
+  model: string;
+  setModel: (m: string) => void;
+  streaming: boolean;
+  streamText: string;
+  pending: string | null;
+  /** The agent's most recent activity note (e.g. "Reading src/app.ts"), or null. */
+  activity: string | null;
+  error: string | null;
+  send: (prompt: string) => void;
+  /** Artifacts generated under the range currently in view. */
+  artifacts: ArtifactRow[];
+  /** Build a URL to open an artifact file in a new tab. */
+  artifactUrl: (relPath: string) => string;
+}
+
+/** The daemon's chat WebSocket URL, derived from the page origin. */
+function chatWsUrl(): string {
+  const proto: string = window.location.protocol === "https:" ? "wss" : "ws";
+  return `${proto}://${window.location.host}/ws/chat`;
+}
+
+/** A parsed chat stream event from the server. */
+function parseEvent(raw: string): { type: string; text?: string; message?: string } | null {
+  try {
+    const v: unknown = JSON.parse(raw);
+    return typeof v === "object" && v !== null ? (v as { type: string; text?: string; message?: string }) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Manage the AI chat panel for a PR: scope, sessions, the selected model, and
+ * streaming a turn over the chat WebSocket while persisting via the daemon.
+ */
+export function useChat(prId: string, getRange: RangeAccessor): ChatState {
+  const utils = trpc.useUtils();
+  const [scope, setScope] = useState<ChatScope | null>(null);
+  const [activeId, setActiveId] = useState<number | null>(null);
+  const [model, setModel] = useState<string>("");
+  const [streaming, setStreaming] = useState(false);
+  const [streamText, setStreamText] = useState("");
+  const [pending, setPending] = useState<string | null>(null);
+  const [activity, setActivity] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const wsRef = useRef<WebSocket | null>(null);
+  // Set when a turn completes; the next persisted-messages refetch hands off.
+  const awaitingPersistRef = useRef(false);
+
+  const config = trpc.config.useQuery({ id: prId });
+  const models: ModelChoice[] = useMemo(() => config.data?.models ?? [], [config.data]);
+  const sessionsQuery = trpc.listChatSessions.useQuery(
+    { id: prId, scopeKind: scope?.kind, scopeRef: scope?.ref },
+    { enabled: scope !== null },
+  );
+  const messagesQuery = trpc.listChatMessages.useQuery(
+    { id: prId, sessionId: activeId ?? -1 },
+    { enabled: activeId !== null },
+  );
+  const create = trpc.createChatSession.useMutation();
+  const range = getRange();
+  const artifactsQuery = trpc.listArtifacts.useQuery(
+    { id: prId, start: range?.start, end: range?.end },
+    { enabled: scope !== null },
+  );
+
+  // Default the model to the first configured choice once loaded.
+  useEffect(() => { if (!model && models[0]) setModel(models[0].id); }, [models, model]);
+
+  // Tear down any open socket on unmount.
+  useEffect(() => () => wsRef.current?.close(), []);
+
+  const stream = (sessionId: number, prompt: string): void => {
+    setPending(prompt);
+    setStreamText("");
+    setActivity(null);
+    setStreaming(true);
+    setError(null);
+    const ws = new WebSocket(chatWsUrl());
+    wsRef.current = ws;
+    const current = getRange();
+    ws.onopen = () => ws.send(JSON.stringify({ id: prId, sessionId, prompt, range: current ?? undefined }));
+    ws.onmessage = (ev: MessageEvent) => {
+      const msg = parseEvent(String(ev.data));
+      if (!msg) return;
+      if (msg.type === "chunk") setStreamText((t) => t + (msg.text ?? ""));
+      else if (msg.type === "activity") setActivity(msg.text ?? null);
+      else if (msg.type === "done") { finish(true); ws.close(); }
+      else if (msg.type === "error") { setError(msg.message ?? "Chat failed."); finish(false); ws.close(); }
+    };
+    ws.onerror = () => { setError("Chat connection failed."); finish(false); };
+  };
+
+  // End the turn's "working" state. On success, keep the streamed reply + prompt
+  // on screen and mark that we're awaiting the persisted copy, so the assistant
+  // bubble never blinks out before the refetch lands. On failure, clear now.
+  const finish = (persisted: boolean): void => {
+    setStreaming(false);
+    setActivity(null);
+    if (persisted) awaitingPersistRef.current = true;
+    else { setPending(null); setStreamText(""); }
+    void utils.listChatMessages.invalidate();
+    void utils.listChatSessions.invalidate();
+    void utils.listArtifacts.invalidate();
+  };
+
+  // When the persisted messages refetch lands after a completed turn, hand off
+  // from the transient stream state to the stored transcript (no flicker). Keyed
+  // only on the data change so a mid-turn refetch (e.g. a new session's first
+  // fetch) never clears an in-flight bubble.
+  useEffect(() => {
+    if (!awaitingPersistRef.current) return;
+    awaitingPersistRef.current = false;
+    setPending(null);
+    setStreamText("");
+  }, [messagesQuery.data]);
+
+  const send = async (prompt: string): Promise<void> => {
+    let sessionId: number | null = activeId;
+    if (sessionId === null) {
+      if (!scope || !model) return;
+      const res = await create.mutateAsync({ id: prId, scopeKind: scope.kind, scopeRef: scope.ref, model });
+      sessionId = res.sessionId;
+      setActiveId(sessionId);
+      await utils.listChatSessions.invalidate();
+    }
+    stream(sessionId, prompt);
+  };
+
+  return {
+    scope,
+    open: (s) => { setScope(s); setActiveId(null); },
+    close: () => { setScope(null); setActiveId(null); wsRef.current?.close(); },
+    sessions: sessionsQuery.data ?? [],
+    activeId,
+    selectSession: (id) => setActiveId(id),
+    newSession: () => setActiveId(null),
+    messages: messagesQuery.data ?? [],
+    models,
+    model,
+    setModel,
+    streaming,
+    streamText,
+    pending,
+    activity,
+    error,
+    send: (prompt) => void send(prompt),
+    artifacts: artifactsQuery.data ?? [],
+    artifactUrl: (relPath) => `/artifact?id=${encodeURIComponent(prId)}&path=${encodeURIComponent(relPath)}`,
+  };
+}

package/src/web/state/useCodeSearch.ts

@@ -0,0 +1,198 @@
+import { useRef, useState } from "react";
+import { trpc } from "../trpc.ts";
+import { nextToken, isCurrent } from "@/web/lib/searchToken.ts";
+import { fetchResults, errorMessage, type RunParams } from "@/web/lib/codeSearchFetch.ts";
+import { searchInputsKey } from "@/web/lib/searchInputsKey.ts";
+import type { CodeResult } from "@/services/symbols.ts";
+import type { CodeResultFilters } from "@/web/lib/filterCodeResults.ts";
+
+/** Search mode: a free-text search vs a semantic symbol lookup. */
+export type SearchMode = "general" | "symbol";
+
+/** Which symbol lookup to run in symbol mode. */
+export type SymbolAction = "definition" | "usages";
+
+/** Which checkout to run against: the range's head (end) or base (start). */
+export type SearchSide = "head" | "base";
+
+/**
+ * A snapshot of the inputs a run used. Drives the results header (which stays
+ * frozen on the last run rather than tracking the live controls) and the
+ * "broaden to the whole repo" action.
+ */
+export interface RunSnapshot {
+  /** Mode the run used. */
+  mode: SearchMode;
+  /** Symbol lookup the run used (relevant in symbol mode). */
+  symbolAction: SymbolAction;
+  /** The term/query the run used. */
+  term: string;
+  /** The checkout side the run targeted. */
+  side: SearchSide;
+  /** The file the run was scoped to ("" = repo-wide). */
+  scopeFile: string;
+}
+
+/** SHA getters for the two ends of the current review range. */
+export interface ShaGetters {
+  /** Current head (end) SHA of the range, or "" when unset. */
+  headSha: () => string;
+  /** Current base (start) SHA of the range, or "" when unset. */
+  baseSha: () => string;
+}
+
+/** The full code-search rail state plus its actions. */
+export interface CodeSearchState {
+  /** General text search vs semantic symbol lookup. */
+  mode: SearchMode;
+  /** The query / symbol term in the input. */
+  query: string;
+  /** General mode: case-sensitive matching. */
+  caseSensitive: boolean;
+  /** General mode: treat the query as a regex. */
+  regex: boolean;
+  /** Symbol mode: which lookup to run. */
+  symbolAction: SymbolAction;
+  /** Which checkout the next/last run targets. */
+  side: SearchSide;
+  /** The SHA the last completed run resolved to (for opening file views). */
+  resultSha: string;
+  /** The last run's results (deduping is done in the view). */
+  results: CodeResult[];
+  /** True while a lookup is running. */
+  loading: boolean;
+  /** A user-facing error from the last run (e.g. bad regex), or null. */
+  error: string | null;
+  /**
+   * Whether the current inputs differ from the last run (so the shown results
+   * are stale and "Run" should be pressed). False before the first run when the
+   * query is empty.
+   */
+  dirty: boolean;
+  /**
+   * The inputs the last run used, or null before the first run. The results
+   * header reads this (not the live controls) so it only changes on Run.
+   */
+  lastRun: RunSnapshot | null;
+  /** The active client-side result filters. */
+  filters: CodeResultFilters;
+  /** Update the query text. */
+  setQuery: (q: string) => void;
+  /** Switch search mode. */
+  setMode: (m: SearchMode) => void;
+  /** Toggle case-sensitive (general mode). */
+  setCaseSensitive: (v: boolean) => void;
+  /** Toggle regex (general mode). */
+  setRegex: (v: boolean) => void;
+  /** Switch the symbol lookup (symbol mode). */
+  setSymbolAction: (a: SymbolAction) => void;
+  /** Switch the target checkout. */
+  setSide: (s: SearchSide) => void;
+  /** Replace the active filters. */
+  setFilters: (f: CodeResultFilters) => void;
+  /** Run the current query as configured by the rail controls. */
+  runFromRail: () => void;
+  /**
+   * Run a lookup initiated from the diff double-click menu: sets the state to
+   * match the picked action/term/side (+ file scope hint) and runs it.
+   */
+  runFromMenu: (op: MenuOp, term: string, side: SearchSide, file: string) => void;
+  /**
+   * Re-run the last (file-scoped) lookup across the whole repo, dropping the
+   * file scope. A no-op when the last run was already repo-wide.
+   */
+  broaden: () => void;
+}
+
+/** The operation a double-click menu can pick. */
+export type MenuOp = "definition" | "usages" | "search";
+
+/**
+ * The code-search rail state: holds the query + mode + toggles + filters, runs
+ * general (rg) searches and symbol (sem) definition/usages lookups against the
+ * chosen checkout, and surfaces loading/error/results. A monotonic request
+ * token drops results from superseded runs (last-wins) so overlapping async
+ * work — including StrictMode's double-fire — never shows stale results.
+ *
+ * @param prId - The PR id lookups run against.
+ * @param shas - Getters for the current head/base SHAs of the review range.
+ */
+export function useCodeSearch(prId: string, shas: ShaGetters): CodeSearchState {
+  const utils = trpc.useUtils();
+  const token = useRef(0);
+  const [mode, setMode] = useState<SearchMode>("general");
+  const [query, setQuery] = useState("");
+  const [caseSensitive, setCaseSensitive] = useState(false);
+  const [regex, setRegex] = useState(false);
+  const [symbolAction, setSymbolAction] = useState<SymbolAction>("definition");
+  const [side, setSide] = useState<SearchSide>("head");
+  const [resultSha, setResultSha] = useState("");
+  const [results, setResults] = useState<CodeResult[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [filters, setFilters] = useState<CodeResultFilters>({});
+  // Key of the inputs the last run used, so the view can flag stale results.
+  const [lastRunKey, setLastRunKey] = useState<string | null>(null);
+  // The inputs the last run used — the header reads this so it only changes on Run.
+  const [lastRun, setLastRun] = useState<RunSnapshot | null>(null);
+
+  const run = async (p: RunParams): Promise<void> => {
+    const id = nextToken(token.current);
+    token.current = id;
+    const sha: string = p.side === "base" ? shas.baseSha() : shas.headSha();
+    setLastRunKey(searchInputsKey({
+      mode: p.mode, query: p.term, caseSensitive: p.caseSensitive,
+      regex: p.regex, symbolAction: p.symbolAction, side: p.side,
+    }));
+    setLastRun({ mode: p.mode, symbolAction: p.symbolAction, term: p.term, side: p.side, scopeFile: p.file ?? "" });
+    setLoading(true);
+    setError(null);
+    if (sha === "" || p.term === "") {
+      if (isCurrent(id, token.current)) { setLoading(false); setResults([]); }
+      return;
+    }
+    try {
+      const out = await fetchResults(utils, prId, sha, p);
+      if (isCurrent(id, token.current)) { setResults(out); setResultSha(sha); setLoading(false); }
+    } catch (err) {
+      if (isCurrent(id, token.current)) { setResults([]); setError(errorMessage(err)); setLoading(false); }
+    }
+  };
+
+  const runFromRail = (): void => {
+    void run({ mode, symbolAction, term: query.trim(), side, caseSensitive, regex });
+  };
+
+  const currentKey: string = searchInputsKey({ mode, query, caseSensitive, regex, symbolAction, side });
+  const dirty: boolean = query.trim() !== "" && currentKey !== lastRunKey;
+
+  return {
+    mode, query, caseSensitive, regex, symbolAction, side, resultSha, results, loading, error, dirty, lastRun, filters,
+    setQuery, setMode, setCaseSensitive, setRegex, setSymbolAction, setSide, setFilters,
+    runFromRail,
+    broaden: () => {
+      if (!lastRun || lastRun.scopeFile === "") return;
+      void run({
+        mode: lastRun.mode, symbolAction: lastRun.symbolAction, term: lastRun.term,
+        side: lastRun.side, caseSensitive, regex, file: undefined,
+      });
+    },
+    runFromMenu: (op, term, side_, file) => {
+      const nextMode: SearchMode = op === "search" ? "general" : "symbol";
+      const nextAction: SymbolAction = op === "usages" ? "usages" : "definition";
+      setMode(nextMode);
+      setSide(side_);
+      setQuery(term);
+      if (op !== "search") setSymbolAction(nextAction);
+      void run({
+        mode: nextMode,
+        symbolAction: nextAction,
+        term,
+        side: side_,
+        caseSensitive,
+        regex,
+        file: file === "" ? undefined : file,
+      });
+    },
+  };
+}

package/src/web/state/useReview.ts

@@ -0,0 +1,138 @@
+import { useState } from "react";
+import { trpc } from "../trpc.ts";
+import type { CommitInfo } from "@/services/git.ts";
+import type { FileView } from "@/daemon/reviewService.ts";
+import type { ReviewedRangeRow } from "@/db/repositories/reviewedRanges.ts";
+import type { PostPreview, PostTarget } from "@/daemon/registry.ts";
+
+/** A selected commit range. */
+export interface RangeSel {
+  /** Baseline (excluded) SHA. */
+  start: string;
+  /** End (inclusive) SHA. */
+  end: string;
+}
+
+/** Arguments for creating a comment (PR id is injected by the hook). */
+export interface AddCommentArgs {
+  /** Line range or whole hunk. */
+  kind: "lines" | "hunk";
+  /** Diff side. */
+  side: "LEFT" | "RIGHT";
+  /** File path. */
+  path: string;
+  /** Markdown body. */
+  body: string;
+  /** End commit of the current range. */
+  madeAtSha: string;
+  /** Exact line text (for line comments). */
+  lineText?: string;
+  /** First side line number (for line comments). */
+  lineNo?: number;
+  /** Last side line number (for multi-line comments). */
+  endLineNo?: number;
+  /** Hunk content hash (for hunk comments). */
+  hunkHash?: string;
+}
+
+/** Everything the review UI needs for one PR. */
+export interface ReviewState {
+  baselineSha: string | null;
+  commits: CommitInfo[];
+  range: RangeSel | null;
+  setRange: (r: RangeSel) => void;
+  files: FileView[];
+  loading: boolean;
+  reviewedRanges: ReviewedRangeRow[];
+  toggleHunkViewed: (hunkHash: string, viewed: boolean) => void;
+  markReviewed: () => void;
+  /** Un-mark the currently selected range as reviewed. */
+  unmarkReviewed: () => void;
+  addComment: (args: AddCommentArgs) => void;
+  editComment: (commentId: number, body: string) => void;
+  deleteComment: (commentId: number) => void;
+  /** Preview where a comment would post (line + warning) without posting. */
+  previewPost: (commentId: number, target: PostTarget) => Promise<PostPreview>;
+  /** Post a comment to GitHub at the chosen target. */
+  postComment: (commentId: number, target: PostTarget) => void;
+  /** Re-fetch the PR from GitHub (new commits / head movement). */
+  refreshPr: () => void;
+  /** True while a PR refresh is in flight. */
+  refreshing: boolean;
+  /** Reply to a synced GitHub thread by its root comment id. */
+  replyToThread: (rootGithubId: string, body: string) => void;
+}
+
+/**
+ * Load and manage review state for a PR: commit topology, the selected range
+ * (defaulting to last-reviewed→head), the range's file/hunk view, and the
+ * mutations for viewed state and reviewed ranges.
+ */
+export function useReview(prId: string, initialRange?: RangeSel | null, hideWhitespace = false): ReviewState {
+  const utils = trpc.useUtils();
+  const topo = trpc.commitsWithBaseline.useQuery({ id: prId });
+  const def = trpc.defaultRange.useQuery({ id: prId });
+  const [override, setOverride] = useState<RangeSel | null>(initialRange ?? null);
+
+  const range: RangeSel | null =
+    override ?? (def.data ? { start: def.data.startSha, end: def.data.endSha } : null);
+
+  // `ignoreWhitespace` is part of the query key, so toggling it re-fetches the
+  // diff (git re-diffs with `--ignore-all-space`), collapsing whitespace-only
+  // hunks. Viewed-progress is keyed to each mode's hunk content, so it does not
+  // carry between the two modes — intentional, and lossless on round-trip.
+  const view = trpc.rangeView.useQuery(
+    { id: prId, start: range?.start ?? "", end: range?.end ?? "", ignoreWhitespace: hideWhitespace },
+    { enabled: range !== null },
+  );
+  const reviewed = trpc.listReviewedRanges.useQuery({ id: prId });
+  const setViewed = trpc.setHunkViewed.useMutation({ onSuccess: () => utils.rangeView.invalidate() });
+  const addReviewed = trpc.addReviewedRange.useMutation({ onSuccess: () => utils.listReviewedRanges.invalidate() });
+  const removeReviewed = trpc.removeReviewedRange.useMutation({ onSuccess: () => utils.listReviewedRanges.invalidate() });
+  const invalidateView = (): void => {
+    void utils.rangeView.invalidate();
+    void utils.listComments.invalidate();
+    // The All-comments side panel shares the screen now, so keep it in sync
+    // when comments change from the diff (add / edit / delete / post / sync).
+    void utils.listAllComments.invalidate();
+  };
+  const addC = trpc.addComment.useMutation({ onSuccess: invalidateView });
+  const editC = trpc.editComment.useMutation({ onSuccess: invalidateView });
+  const delC = trpc.deleteComment.useMutation({ onSuccess: invalidateView });
+  const postC = trpc.postComment.useMutation({ onSuccess: invalidateView });
+  const reply = trpc.replyToThread.useMutation({ onSuccess: invalidateView });
+  const refresh = trpc.refreshPr.useMutation({
+    onSuccess: () => {
+      void utils.commitsWithBaseline.invalidate();
+      void utils.defaultRange.invalidate();
+      void utils.prCommits.invalidate();
+      void utils.health.invalidate();
+      invalidateView();
+    },
+  });
+
+  return {
+    baselineSha: topo.data?.baselineSha ?? null,
+    commits: topo.data?.commits ?? [],
+    range,
+    setRange: setOverride,
+    files: view.data ?? [],
+    loading: topo.isLoading || def.isLoading || view.isLoading,
+    reviewedRanges: reviewed.data ?? [],
+    toggleHunkViewed: (hunkHash, viewed) => setViewed.mutate({ id: prId, hunkHash, viewed }),
+    markReviewed: () => {
+      if (range) addReviewed.mutate({ id: prId, start: range.start, end: range.end });
+    },
+    unmarkReviewed: () => {
+      if (range) removeReviewed.mutate({ id: prId, start: range.start, end: range.end });
+    },
+    addComment: (args) => addC.mutate({ id: prId, ...args }),
+    editComment: (commentId, body) => editC.mutate({ id: prId, commentId, body }),
+    deleteComment: (commentId) => delC.mutate({ id: prId, commentId }),
+    previewPost: (commentId, target) => utils.postCommentPreview.fetch({ id: prId, commentId, target }),
+    postComment: (commentId, target) => postC.mutate({ id: prId, commentId, target }),
+    replyToThread: (rootGithubId, body) => reply.mutate({ id: prId, rootGithubId, body }),
+    refreshPr: () => refresh.mutate({ id: prId }),
+    refreshing: refresh.isPending,
+  };
+}