getgloss 0.8.4 → 0.9.0

package/dist/server/daemon.js

@@ -1,4 +1,5 @@
 // src/server/daemon.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { serve } from "@hono/node-server";
 
 // src/shared/paths.ts
@@ -9,7 +10,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.8.4",
+  version: "0.9.0",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -198,6 +199,7 @@ var REVIEW_STATUSES = ["pending", "submitted", "cancelled", "resolved"];
 var DIFF_LINE_TYPES = ["context", "add", "delete"];
 var DIFF_SCOPE_MODES = ["working", "branch", "explicit"];
 var DIFF_FALLBACK_REASONS = ["working-tree-clean", "missing-branch-base"];
+var DIFF_CONTEXT_MAX_LINES = 500;
 var REVIEW_SCOPE_MODES = ["all", "single", "range"];
 var RESOLUTION_STATUSES = ["partial", "resolved"];
 
@@ -213,7 +215,7 @@ function parseJsonValue(value, guard, label) {
   return value;
 }
 function isServerInfo(value) {
-  return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isString(value.startedAt) && isString(value.stateDir);
+  return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isString(value.startedAt) && isString(value.stateDir) && isOptionalString(value.cwd) && isOptionalString(value.daemonPath);
 }
 function isClearReviewsRequest(value) {
   return isRecord(value) && isOptionalNonNegativeInteger(value.olderThanDays) && isOptionalBoolean(value.dryRun);
@@ -224,6 +226,9 @@ function isOpenFileRequest(value) {
 function isCommitRangeDiffRequest(value) {
   return isRecord(value) && isString(value.fromSha) && isString(value.toSha) && isOptionalString(value.turnId);
 }
+function isDiffContextRequest(value) {
+  return isRecord(value) && isString(value.filePath) && isNullableString(value.oldPath) && isOptionalString(value.turnId) && isDiffContextSource(value.source) && isPositiveInteger(value.oldStart) && isPositiveInteger(value.newStart) && isPositiveInteger(value.lineCount);
+}
 function isSubmitReviewRequest(value) {
   return isRecord(value) && isArrayOf(value.comments, isComment) && isOptional(value.reviewScope, isReviewScope);
 }
@@ -275,6 +280,21 @@ function isDiffCommit(value) {
 function isCommitDiff(value) {
   return isRecord(value) && isDiffCommit(value.commit) && isDiffStats(value.stats) && isString(value.rawDiff) && isArrayOf(value.files, isDiffFile);
 }
+function isDiffContextSource(value) {
+  if (!isRecord(value) || !isString(value.mode)) {
+    return false;
+  }
+  switch (value.mode) {
+    case "turn":
+      return true;
+    case "commit":
+      return isString(value.sha);
+    case "range":
+      return isString(value.fromSha) && isString(value.toSha);
+    default:
+      return false;
+  }
+}
 function isReviewScope(value) {
   if (!isRecord(value) || !isOneOf(value.mode, REVIEW_SCOPE_MODES)) {
     return false;
@@ -333,6 +353,9 @@ function isNullableString(value) {
 function isNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
+function isPositiveInteger(value) {
+  return isNumber(value) && Number.isInteger(value) && value > 0;
+}
 function isOptionalNumber(value) {
   return value === void 0 || isNumber(value);
 }
@@ -438,9 +461,61 @@ async function assertStateDirWritable() {
   }
 }
 
+// src/server/idle.ts
+var DEFAULT_DAEMON_IDLE_TIMEOUT_MS = 12e4;
+function normalizeIdleTimeoutMs(rawValue = process.env.GLOSS_IDLE_TIMEOUT_MS, warn = (message) => process.stderr.write(message)) {
+  if (rawValue === void 0) {
+    return DEFAULT_DAEMON_IDLE_TIMEOUT_MS;
+  }
+  const parsed = Number(rawValue);
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return parsed;
+  }
+  warn(
+    `Warning: GLOSS_IDLE_TIMEOUT_MS=${JSON.stringify(rawValue)} is not positive; using ${DEFAULT_DAEMON_IDLE_TIMEOUT_MS}.
+`
+  );
+  return DEFAULT_DAEMON_IDLE_TIMEOUT_MS;
+}
+function createIdleScheduler(options) {
+  let idleTimer = null;
+  const cancel = () => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+  };
+  const schedule = () => {
+    if (options.isShuttingDown()) {
+      return;
+    }
+    if (options.hasLiveClients()) {
+      cancel();
+      return;
+    }
+    if (!idleTimer) {
+      idleTimer = setTimeout(() => {
+        idleTimer = null;
+        void shutdownIfIdle();
+      }, options.timeoutMs);
+    }
+  };
+  const shutdownIfIdle = async () => {
+    if (options.isShuttingDown()) {
+      return;
+    }
+    if (options.hasLiveClients()) {
+      schedule();
+      return;
+    }
+    await options.shutdown();
+  };
+  return { cancel, schedule };
+}
+
 // src/server/index.ts
-import { readFile as readFile4, realpath, stat } from "fs/promises";
-import path6 from "path";
+import { readFile as readFile5, realpath, stat } from "fs/promises";
+import path7 from "path";
 import { fileURLToPath } from "url";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
@@ -473,6 +548,8 @@ function resolutionCounts(feedback, resolvedComments = []) {
 }
 
 // src/shared/git-diff.ts
+import { readFile as readFile2 } from "fs/promises";
+import path5 from "path";
 import { execa } from "execa";
 
 // src/shared/language.ts
@@ -660,6 +737,59 @@ async function captureCommitRangeDiff(fromSha, toSha, repoRoot) {
     files
   };
 }
+async function captureDiffContext({
+  filePath,
+  lineCount,
+  newRef,
+  oldPath,
+  oldRef,
+  newStart,
+  oldStart,
+  repoRoot
+}) {
+  const [oldLines, newLines] = await Promise.all([
+    oldRef && oldPath ? readRevisionLines(repoRoot, oldRef, oldPath).catch(() => null) : null,
+    newRef === null ? readWorkingTreeLines(repoRoot, filePath).catch(() => null) : readRevisionLines(repoRoot, newRef, filePath).catch(() => null)
+  ]);
+  if (!oldLines && !newLines) {
+    throw new Error(`Could not read ${filePath} from either side of the diff`);
+  }
+  const lines = [];
+  for (let index = 0; index < lineCount; index += 1) {
+    const oldLine = oldStart + index;
+    const newLine = newStart + index;
+    const content = newLines?.[newLine - 1] ?? oldLines?.[oldLine - 1];
+    if (content === void 0) {
+      continue;
+    }
+    lines.push({
+      type: "context",
+      oldLine,
+      newLine,
+      content
+    });
+  }
+  return {
+    filePath,
+    oldStart,
+    newStart,
+    lines
+  };
+}
+async function readRevisionLines(repoRoot, ref, filePath) {
+  const result = await execa("git", ["show", `${ref}:${filePath}`], { cwd: repoRoot });
+  return splitFileLines(result.stdout);
+}
+async function readWorkingTreeLines(repoRoot, filePath) {
+  return splitFileLines(await readFile2(path5.resolve(repoRoot, filePath), "utf8"));
+}
+function splitFileLines(contents) {
+  const lines = contents.replace(/\r\n/g, "\n").split("\n");
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+  return lines;
+}
 
 // src/shared/reviews.ts
 function isResolvableReviewStatus(status) {
@@ -674,12 +804,12 @@ async function openLocalPath(filePath) {
 
 // src/server/store.ts
 import { createHash } from "crypto";
-import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-import path5 from "path";
+import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import path6 from "path";
 import { ulid } from "ulid";
 
 // src/shared/cleanup.ts
-import { readdir, readFile as readFile2, rm as rm3 } from "fs/promises";
+import { readdir, readFile as readFile3, rm as rm3 } from "fs/promises";
 var DEFAULT_REVIEW_RETENTION_DAYS = 30;
 var clearableStatuses = /* @__PURE__ */ new Set(["submitted", "resolved", "cancelled"]);
 var millisecondsPerDay = 24 * 60 * 60 * 1e3;
@@ -739,7 +869,7 @@ function normalizeRetentionDays(value) {
 async function cleanupCandidate(reviewId, artifactDir, cutoff, skipped) {
   let raw;
   try {
-    raw = await readFile2(globalReviewMetaFile(reviewId), "utf8");
+    raw = await readFile3(globalReviewMetaFile(reviewId), "utf8");
   } catch (error) {
     if (isFileNotFound(error)) {
       skipped.push({ reviewId, artifactDir, reason: "missing metadata" });
@@ -819,7 +949,7 @@ async function persistedTurnCleanupState(reviewId, artifactDir, skipped) {
 async function readPersistedTurnMeta(reviewId, turnDirName, artifactDir, skipped) {
   let raw;
   try {
-    raw = await readFile2(globalReviewTurnMetaFile(reviewId, turnDirName), "utf8");
+    raw = await readFile3(globalReviewTurnMetaFile(reviewId, turnDirName), "utf8");
   } catch (error) {
     skipped.push({
       reviewId,
@@ -1328,16 +1458,25 @@ var ReviewStore = class {
     const reviewLoads = [];
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        reviewLoads.push(this.loadReview(entry.name));
+        reviewLoads.push(this.loadReviewForList(entry.name));
       }
     }
     await Promise.all(reviewLoads);
   }
+  async loadReviewForList(id) {
+    try {
+      return await this.loadReview(id);
+    } catch (error) {
+      process.stderr.write(`Warning: Skipping corrupt review ${id}: ${formatError(error)}
+`);
+      return null;
+    }
+  }
   async loadReview(id) {
     const metaPath = globalReviewMetaFile(id);
     let metaRaw;
     try {
-      metaRaw = await readFile3(metaPath, "utf8");
+      metaRaw = await readFile4(metaPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return this.loadReviewFromTurnsOnly(id);
@@ -1419,8 +1558,8 @@ var ReviewStore = class {
     let diffRaw;
     try {
       [metaRaw, diffRaw] = await Promise.all([
-        readFile3(metaPath, "utf8"),
-        readFile3(diffPath, "utf8")
+        readFile4(metaPath, "utf8"),
+        readFile4(diffPath, "utf8")
       ]);
     } catch (error) {
       if (isFileNotFound(error)) {
@@ -1450,7 +1589,7 @@ var ReviewStore = class {
     const diffPath = globalReviewDiffFile(id);
     let diffRaw;
     try {
-      diffRaw = await readFile3(diffPath, "utf8");
+      diffRaw = await readFile4(diffPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return null;
@@ -1630,9 +1769,9 @@ function reconcileTurn(meta, diff, feedback, resolution) {
     status,
     submittedAt: feedback?.timestamp ?? meta.submittedAt,
     resolvedAt: status === "resolved" ? resolution?.resolvedAt ?? meta.resolvedAt : void 0,
-    feedbackPath: feedback ? meta.feedbackPath ?? path5.join(meta.artifactDir, "feedback.json") : void 0,
-    markdownPath: feedback ? meta.markdownPath ?? path5.join(meta.artifactDir, "feedback.md") : void 0,
-    resolvedPath: resolution ? meta.resolvedPath ?? path5.join(meta.artifactDir, "resolved.json") : void 0,
+    feedbackPath: feedback ? meta.feedbackPath ?? path6.join(meta.artifactDir, "feedback.json") : void 0,
+    markdownPath: feedback ? meta.markdownPath ?? path6.join(meta.artifactDir, "feedback.md") : void 0,
+    resolvedPath: resolution ? meta.resolvedPath ?? path6.join(meta.artifactDir, "resolved.json") : void 0,
     diff,
     ...feedback ? { feedback } : {},
     ...resolution ? { resolution } : {}
@@ -1665,7 +1804,7 @@ function requiredPath(value, label) {
 async function readOptionalJsonFile(filePath, guard, label) {
   let raw;
   try {
-    raw = await readFile3(filePath, "utf8");
+    raw = await readFile4(filePath, "utf8");
   } catch (error) {
     if (isFileNotFound(error)) {
       return void 0;
@@ -1705,7 +1844,8 @@ function createApp(origin2, options = {}) {
     const response = {
       ok: true,
       version: packageVersion,
-      activeReviews: reviews.filter((review) => review.status === "pending").length
+      activeReviews: reviews.filter((review) => review.status === "pending").length,
+      ...options.health?.()
     };
     return c.json(response);
   });
@@ -1916,6 +2056,60 @@ function createApp(origin2, options = {}) {
     };
     return c.json(response);
   });
+  app.post("/api/reviews/:id/files/context", async (c) => {
+    const id = c.req.param("id");
+    const existing = await reviewStore.get(id);
+    if (!existing) {
+      return c.json({ error: "review not found" }, 404);
+    }
+    const parsed = await readJsonBody(c, isDiffContextRequest, "diff context request");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    const body = parsed.body;
+    if (body.lineCount > DIFF_CONTEXT_MAX_LINES) {
+      return c.json({ error: `lineCount must be ${DIFF_CONTEXT_MAX_LINES} or less` }, 400);
+    }
+    const turn = body.turnId ? await reviewStore.getTurn(id, body.turnId) : null;
+    if (body.turnId && !turn) {
+      return c.json({ error: "turn not found" }, 404);
+    }
+    const diffPayload = turn?.diff ?? existing.diff;
+    const repoRoot = path7.resolve(diffPayload.cwd);
+    const pathError = validateContextPath(repoRoot, body.filePath, "filePath") ?? (body.oldPath ? validateContextPath(repoRoot, body.oldPath, "oldPath") : null);
+    if (pathError) {
+      return c.json({ error: pathError }, 400);
+    }
+    const source = await resolveContextSource(diffPayload, body.source);
+    if (!source.ok) {
+      return c.json({ error: source.error }, source.status);
+    }
+    const reviewFile = source.files.find((file) => file.path === body.filePath);
+    if (!reviewFile) {
+      return c.json({ error: "file is not part of this review context" }, 404);
+    }
+    if ((reviewFile.oldPath ?? null) !== body.oldPath) {
+      return c.json({ error: "oldPath does not match the reviewed file" }, 400);
+    }
+    if (reviewFile.isBinary) {
+      return c.json({ error: "binary file context is not available" }, 409);
+    }
+    try {
+      const response = await captureDiffContext({
+        filePath: body.filePath,
+        oldPath: body.oldPath,
+        oldRef: source.oldRef,
+        newRef: source.newRef,
+        oldStart: body.oldStart,
+        newStart: body.newStart,
+        lineCount: body.lineCount,
+        repoRoot
+      });
+      return c.json(response);
+    } catch (error) {
+      return c.json({ error: `context is unavailable: ${formatError(error)}` }, 409);
+    }
+  });
   app.post("/api/reviews/:id/files/open", async (c) => {
     const id = c.req.param("id");
     const existing = await reviewStore.get(id);
@@ -1927,11 +2121,11 @@ function createApp(origin2, options = {}) {
       return parsed.response;
     }
     const { filePath, turnId } = parsed.body;
-    if (!filePath || filePath.includes("\0") || path6.isAbsolute(filePath)) {
+    if (!filePath || filePath.includes("\0") || path7.isAbsolute(filePath)) {
       return c.json({ error: "filePath must be a repo-relative path" }, 400);
     }
-    const repoRoot = path6.resolve(existing.diff.cwd);
-    const requestedAbsolutePath = path6.resolve(repoRoot, filePath);
+    const repoRoot = path7.resolve(existing.diff.cwd);
+    const requestedAbsolutePath = path7.resolve(repoRoot, filePath);
     if (!isPathWithin(repoRoot, requestedAbsolutePath)) {
       return c.json({ error: "filePath must stay within the review cwd" }, 400);
     }
@@ -2047,13 +2241,13 @@ function createApp(origin2, options = {}) {
 }
 async function serveAsset(c) {
   const requestPath = new URL(c.req.url).pathname.replace(/^\/assets\//, "");
-  const normalized = path6.normalize(requestPath).replace(/^(\.\.(\/|\\|$))+/, "");
-  const assetPath = path6.join(webRoot, "assets", normalized);
+  const normalized = path7.normalize(requestPath).replace(/^(\.\.(\/|\\|$))+/, "");
+  const assetPath = path7.join(webRoot, "assets", normalized);
   try {
-    const body = await readFile4(assetPath);
+    const body = await readFile5(assetPath);
     return new Response(body, {
       headers: {
-        "content-type": mimeTypes[path6.extname(assetPath)] ?? "application/octet-stream"
+        "content-type": mimeTypes[path7.extname(assetPath)] ?? "application/octet-stream"
       }
     });
   } catch (error) {
@@ -2065,7 +2259,7 @@ async function serveAsset(c) {
 }
 async function serveIndex() {
   try {
-    const body = await readFile4(path6.join(webRoot, "index.html"));
+    const body = await readFile5(path7.join(webRoot, "index.html"));
     return new Response(body, {
       headers: { "content-type": "text/html; charset=utf-8" }
     });
@@ -2079,7 +2273,7 @@ async function serveIndex() {
 function serveRootFile(fileName, contentType) {
   return async () => {
     try {
-      const body = await readFile4(path6.join(webRoot, fileName));
+      const body = await readFile5(path7.join(webRoot, fileName));
       return new Response(body, {
         headers: { "content-type": contentType }
       });
@@ -2111,8 +2305,63 @@ async function readJsonBody(c, guard, label) {
   }
 }
 function isPathWithin(parentPath, childPath) {
-  const relative = path6.relative(parentPath, childPath);
-  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
+  const relative = path7.relative(parentPath, childPath);
+  return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
+}
+async function resolveContextSource(diffPayload, source) {
+  if (source.mode === "turn") {
+    return {
+      ok: true,
+      files: diffPayload.files,
+      oldRef: diffPayload.base.sha,
+      newRef: diffPayload.scope.comparison.sha
+    };
+  }
+  const commitDiffs = diffPayload.commitDiffs ?? [];
+  if (commitDiffs.length === 0) {
+    return {
+      ok: false,
+      status: 409,
+      error: "commit context is only available for branch reviews"
+    };
+  }
+  if (source.mode === "commit") {
+    const commitDiff = commitDiffs.find((diff) => diff.commit.sha === source.sha);
+    if (!commitDiff) {
+      return { ok: false, status: 404, error: "commit must be part of this review" };
+    }
+    return {
+      ok: true,
+      files: commitDiff.files,
+      oldRef: `${source.sha}^`,
+      newRef: source.sha
+    };
+  }
+  const fromIndex = commitDiffs.findIndex((diff) => diff.commit.sha === source.fromSha);
+  const toIndex = commitDiffs.findIndex((diff) => diff.commit.sha === source.toSha);
+  if (fromIndex < 0 || toIndex < 0) {
+    return { ok: false, status: 404, error: "commit range must use commits from this review" };
+  }
+  if (fromIndex > toIndex) {
+    return { ok: false, status: 400, error: "fromSha must come before or match toSha" };
+  }
+  const rangeDiff = source.fromSha === source.toSha ? commitDiffs[fromIndex] : await captureCommitRangeDiff(source.fromSha, source.toSha, diffPayload.cwd);
+  return {
+    ok: true,
+    files: rangeDiff.files,
+    oldRef: `${source.fromSha}^`,
+    newRef: source.toSha
+  };
+}
+function validateContextPath(repoRoot, filePath, label) {
+  if (!filePath || filePath.includes("\0") || path7.isAbsolute(filePath)) {
+    return `${label} must be a repo-relative path`;
+  }
+  const requestedAbsolutePath = path7.resolve(repoRoot, filePath);
+  if (!isPathWithin(repoRoot, requestedAbsolutePath)) {
+    return `${label} must stay within the review cwd`;
+  }
+  return null;
 }
 function activeTurnSummary(meta) {
   if (!meta.activeTurnId) {
@@ -2157,23 +2406,39 @@ async function runStartupCleanup(logger = defaultLogger) {
 
 // src/server/daemon.ts
 var port = Number(process.env.GLOSS_PORT ?? "0");
-var idleTimeoutMs = Number(process.env.GLOSS_IDLE_TIMEOUT_MS ?? "120000");
+var idleTimeoutMs = normalizeIdleTimeoutMs();
+var daemonPath = fileURLToPath2(import.meta.url);
 if (!port) {
   throw new Error("GLOSS_PORT is required");
 }
 var origin = `http://localhost:${port}`;
 var eventStreams = /* @__PURE__ */ new Set();
-var idleTimer = null;
 var shuttingDown = false;
+var idleScheduler = createIdleScheduler({
+  timeoutMs: idleTimeoutMs,
+  hasLiveClients: () => eventStreams.size > 0,
+  isShuttingDown: () => shuttingDown,
+  shutdown: () => shutdown(0)
+});
 var server = serve({
   fetch: createApp(origin, {
     onReviewActivity: () => {
-      void scheduleIdleShutdown();
+      idleScheduler.schedule();
     },
     registerEventStream: (close) => {
       eventStreams.add(close);
+      idleScheduler.schedule();
       return () => {
         eventStreams.delete(close);
+        idleScheduler.schedule();
+      };
+    },
+    health: () => {
+      return {
+        connections: eventStreams.size,
+        cwd: process.cwd(),
+        daemonPath,
+        stateDir: globalStateDir()
       };
     }
   }).fetch,
@@ -2184,54 +2449,23 @@ await writeServerInfo({
   port,
   version: packageVersion,
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-  stateDir: globalStateDir()
+  stateDir: globalStateDir(),
+  cwd: process.cwd(),
+  daemonPath
 });
 await runStartupCleanup();
-await scheduleIdleShutdown();
+idleScheduler.schedule();
 for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
   process.on(signal, () => {
     void shutdown(0);
   });
 }
-async function scheduleIdleShutdown() {
-  if (shuttingDown || idleTimeoutMs <= 0) {
-    return;
-  }
-  const activeReviews = await countActiveReviews();
-  if (activeReviews > 0) {
-    if (idleTimer) {
-      clearTimeout(idleTimer);
-      idleTimer = null;
-    }
-    return;
-  }
-  if (!idleTimer) {
-    idleTimer = setTimeout(() => {
-      idleTimer = null;
-      void shutdownIfIdle();
-    }, idleTimeoutMs);
-  }
-}
-async function shutdownIfIdle() {
-  if (await countActiveReviews() > 0) {
-    await scheduleIdleShutdown();
-    return;
-  }
-  await shutdown(0);
-}
-async function countActiveReviews() {
-  const reviews = await reviewStore.list();
-  return reviews.filter((review) => review.status === "pending").length;
-}
 async function shutdown(exitCode) {
   if (shuttingDown) {
     return;
   }
   shuttingDown = true;
-  if (idleTimer) {
-    clearTimeout(idleTimer);
-    idleTimer = null;
-  }
+  idleScheduler.cancel();
   for (const close of [...eventStreams]) {
     close();
   }