getgloss 0.12.1 → 0.13.0

package/dist/server/daemon.js

@@ -10,7 +10,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.12.1",
+  version: "0.13.0",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -67,8 +67,8 @@ var package_default = {
     tsup: "8.5.1",
     tsx: "4.22.3",
     typescript: "5.9.3",
-    vite: "6.4.2",
-    vitest: "3.2.4"
+    vite: "6.4.3",
+    vitest: "3.2.6"
   },
   keywords: [
     "diff",
@@ -202,6 +202,7 @@ var DIFF_SCOPE_MODES = ["working", "branch", "explicit"];
 var DIFF_FALLBACK_REASONS = ["working-tree-clean", "missing-branch-base"];
 var DIFF_CONTEXT_MAX_LINES = 500;
 var SOURCE_PEEK_MAX_BYTES = 35e4;
+var SOURCE_PEEK_RANGE_MAX_LINES = 240;
 var REVIEW_SCOPE_MODES = ["all", "single", "range"];
 var RESOLUTION_STATUSES = ["partial", "resolved"];
 var OPEN_FILE_SCOPES = ["review", "repo"];
@@ -272,6 +273,9 @@ function isDiffContextRequest(value) {
 function isSourcePeekRequest(value) {
   return isRecord(value) && isString(value.filePath) && isNullableString(value.oldPath) && isOptionalString(value.turnId) && isDiffContextSource(value.source) && isOneOf(value.side, SIDES) && isPositiveInteger(value.line) && isNonNegativeInteger(value.column) && isIdentifier(value.symbol);
 }
+function isSourcePeekRangeRequest(value) {
+  return isRecord(value) && isString(value.filePath) && isOptionalString(value.turnId) && isDiffContextSource(value.source) && isOneOf(value.side, SIDES) && isPositiveInteger(value.startLine) && isPositiveInteger(value.lineCount) && value.lineCount <= SOURCE_PEEK_RANGE_MAX_LINES;
+}
 function isSubmitReviewRequest(value) {
   return isRecord(value) && isArrayOf(value.comments, isComment) && isOptional(value.reviewScope, isReviewScope);
 }
@@ -361,7 +365,13 @@ function isDiffLine(value) {
   return isRecord(value) && isOneOf(value.type, DIFF_LINE_TYPES) && isNullableNumber(value.oldLine) && isNullableNumber(value.newLine) && isString(value.content);
 }
 function isComment(value) {
-  return isRecord(value) && isString(value.id) && isString(value.filePath) && isNumber(value.startLine) && isNumber(value.endLine) && isOneOf(value.side, SIDES) && isString(value.body) && isString(value.originalSnippet) && isString(value.createdAt);
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (value.kind === "general") {
+    return isString(value.id) && isString(value.body) && isString(value.createdAt);
+  }
+  return isString(value.id) && (value.kind === void 0 || value.kind === "line") && isString(value.filePath) && isNumber(value.startLine) && isNumber(value.endLine) && isOneOf(value.side, SIDES) && isString(value.body) && isString(value.originalSnippet) && isString(value.createdAt);
 }
 function isResolvedComment(value) {
   return isRecord(value) && isString(value.commentId) && value.status === "resolved" && isOptionalString(value.summary) && isString(value.resolvedAt);
@@ -576,11 +586,28 @@ import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 
 // src/shared/comments.ts
+function isLineComment(comment) {
+  return comment.kind === void 0 || comment.kind === "line";
+}
 function compareCommentsByLocation(a, b) {
+  const aIsLine = isLineComment(a);
+  const bIsLine = isLineComment(b);
+  if (!aIsLine || !bIsLine) {
+    if (aIsLine !== bIsLine) {
+      return aIsLine ? 1 : -1;
+    }
+    return a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id);
+  }
   return a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine || a.endLine - b.endLine || a.side.localeCompare(b.side);
 }
 function countCommentFiles(comments) {
-  return new Set(comments.map((comment) => comment.filePath)).size;
+  const filePaths = /* @__PURE__ */ new Set();
+  for (const comment of comments) {
+    if (isLineComment(comment)) {
+      filePaths.add(comment.filePath);
+    }
+  }
+  return filePaths.size;
 }
 function formatLineRange(range, options = {}) {
   const startLine = Math.min(range.startLine, range.endLine);
@@ -777,6 +804,17 @@ function summarizeDiffFiles(files) {
   );
 }
 
+// src/shared/file-order.ts
+function compareFilePaths(leftPath, rightPath, leftTieBreaker = "", rightTieBreaker = "") {
+  return leftPath.localeCompare(rightPath, void 0, { sensitivity: "base" }) || leftPath.localeCompare(rightPath) || leftTieBreaker.localeCompare(rightTieBreaker, void 0, { sensitivity: "base" }) || leftTieBreaker.localeCompare(rightTieBreaker);
+}
+function compareDiffFiles(left, right) {
+  return compareFilePaths(left.path, right.path, left.oldPath ?? "", right.oldPath ?? "");
+}
+function sortDiffFiles(files) {
+  return files.toSorted(compareDiffFiles);
+}
+
 // src/shared/git-diff.ts
 var DIFF_ARGS = ["diff", "--no-color", "--find-renames", "--find-copies"];
 async function git(args, cwd) {
@@ -785,7 +823,7 @@ async function git(args, cwd) {
 }
 async function captureCommitRangeDiff(fromSha, toSha, repoRoot) {
   const rawDiff = await git([...DIFF_ARGS, `${fromSha}^`, toSha, "--"], repoRoot);
-  const files = parseUnifiedDiff(rawDiff);
+  const files = sortDiffFiles(parseUnifiedDiff(rawDiff));
   return {
     stats: summarizeDiffFiles(files),
     rawDiff,
@@ -1013,6 +1051,25 @@ async function resolveSourcePeek({
   }
   throw new Error(`No definition found for ${symbol}`);
 }
+async function readSourcePeekRange({
+  lineCount,
+  repoRoot,
+  sourceFilePath,
+  sourceRef,
+  startLine
+}) {
+  const content = await readRepoText(repoRoot, sourceRef, sourceFilePath);
+  const limited = limitContentRange(content, startLine, lineCount);
+  return {
+    filePath: sourceFilePath,
+    startLine: limited.startLine,
+    totalLines: limited.totalLines,
+    content: limited.content,
+    truncated: limited.truncated,
+    hasMoreAbove: limited.hasMoreAbove,
+    hasMoreBelow: limited.hasMoreBelow
+  };
+}
 async function resolveImportedTarget({
   aliasConfig,
   importedName,
@@ -1191,37 +1248,86 @@ function responseForMatch({
     language: languageForPath(filePath),
     content: limited.content,
     truncated: limited.truncated,
+    totalLines: limited.totalLines,
+    hasMoreAbove: limited.hasMoreAbove,
+    hasMoreBelow: limited.hasMoreBelow,
     matchReason
   };
 }
 function limitContentAroundLine(content, line) {
+  const lines = splitFileLines2(content);
+  const totalLines = sourceTotalLines(lines);
   if (Buffer.byteLength(content, "utf8") <= SOURCE_PEEK_MAX_BYTES) {
-    return { content, startLine: 1, truncated: false };
+    return {
+      content,
+      startLine: 1,
+      totalLines,
+      truncated: false,
+      hasMoreAbove: false,
+      hasMoreBelow: false
+    };
+  }
+  if (lines.length === 0) {
+    return emptySourceWindow();
   }
-  const lines = splitFileLines2(content);
   const targetIndex = Math.max(0, line - 1);
   const preferredStartIndex = Math.max(0, targetIndex - SOURCE_PEEK_TARGET_CONTEXT_LINES);
   const preferredEndIndex = Math.min(lines.length, preferredStartIndex + SOURCE_PEEK_CONTEXT_LINES);
-  let startIndex = preferredStartIndex;
-  let endIndex = preferredEndIndex;
-  let limitedContent = lines.slice(startIndex, endIndex).join("\n");
-  while (Buffer.byteLength(limitedContent, "utf8") > SOURCE_PEEK_MAX_BYTES && endIndex - startIndex > 1) {
-    if (targetIndex - startIndex > endIndex - targetIndex - 1) {
-      startIndex += 1;
+  return limitLinesByIndexes(lines, preferredStartIndex, preferredEndIndex, targetIndex);
+}
+function limitContentRange(content, startLine, lineCount) {
+  const lines = splitFileLines2(content);
+  if (lines.length === 0) {
+    return emptySourceWindow();
+  }
+  const cappedLineCount = Math.min(lineCount, SOURCE_PEEK_RANGE_MAX_LINES);
+  const startIndex = clampNumber(startLine - 1, 0, lines.length - 1);
+  const endIndex = Math.min(lines.length, startIndex + cappedLineCount);
+  return limitLinesByIndexes(lines, startIndex, endIndex, null);
+}
+function limitLinesByIndexes(lines, startIndex, endIndex, targetIndex) {
+  let limitedStartIndex = startIndex;
+  let limitedEndIndex = endIndex;
+  let limitedContent = lines.slice(limitedStartIndex, limitedEndIndex).join("\n");
+  let truncatedByBytes = false;
+  while (Buffer.byteLength(limitedContent, "utf8") > SOURCE_PEEK_MAX_BYTES && limitedEndIndex - limitedStartIndex > 1) {
+    if (targetIndex !== null && targetIndex - limitedStartIndex > limitedEndIndex - targetIndex - 1) {
+      limitedStartIndex += 1;
     } else {
-      endIndex -= 1;
+      limitedEndIndex -= 1;
     }
-    limitedContent = lines.slice(startIndex, endIndex).join("\n");
+    limitedContent = lines.slice(limitedStartIndex, limitedEndIndex).join("\n");
+    truncatedByBytes = true;
   }
   if (Buffer.byteLength(limitedContent, "utf8") > SOURCE_PEEK_MAX_BYTES) {
     limitedContent = truncateUtf8(limitedContent, SOURCE_PEEK_MAX_BYTES);
+    truncatedByBytes = true;
   }
   return {
     content: limitedContent,
-    startLine: startIndex + 1,
-    truncated: true
+    startLine: limitedStartIndex + 1,
+    totalLines: sourceTotalLines(lines),
+    truncated: truncatedByBytes || limitedStartIndex > 0 || limitedEndIndex < lines.length,
+    hasMoreAbove: limitedStartIndex > 0,
+    hasMoreBelow: limitedEndIndex < lines.length
   };
 }
+function emptySourceWindow() {
+  return {
+    content: "",
+    startLine: 1,
+    totalLines: 1,
+    truncated: false,
+    hasMoreAbove: false,
+    hasMoreBelow: false
+  };
+}
+function sourceTotalLines(lines) {
+  return Math.max(1, lines.length);
+}
+function clampNumber(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
 function truncateUtf8(value, maxBytes) {
   const buffer = Buffer.from(value, "utf8");
   if (buffer.byteLength <= maxBytes) {
@@ -1833,9 +1939,11 @@ function languageForSnippet(filePath, snippet) {
 }
 function serializeFeedbackMarkdown(bundle) {
   const comments = bundle.comments.toSorted(compareCommentsByLocation);
+  const generalComments = comments.filter((comment) => !isLineComment(comment));
+  const lineComments = comments.filter(isLineComment);
   const commentsByFile = /* @__PURE__ */ new Map();
   const files = [];
-  for (const comment of comments) {
+  for (const comment of lineComments) {
     const fileComments = commentsByFile.get(comment.filePath);
     if (fileComments) {
       fileComments.push(comment);
@@ -1853,6 +1961,12 @@ function serializeFeedbackMarkdown(bundle) {
     `Files: ${files.length}   Comments: ${comments.length}`,
     ""
   ];
+  if (generalComments.length > 0) {
+    lines.push("## General comments", "");
+    for (const comment of generalComments) {
+      lines.push(`### ${comment.id}`, comment.body.trim(), "");
+    }
+  }
   for (const filePath of files) {
     lines.push(`## ${filePath}`, "");
     for (const comment of commentsByFile.get(filePath) ?? []) {
@@ -2914,6 +3028,46 @@ function createApp(origin2, options = {}) {
       return c.json({ error: `source peek unavailable: ${formatError(error)}` }, 404);
     }
   });
+  app.post("/api/reviews/:id/source-peek/range", 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, isSourcePeekRangeRequest, "source peek range request");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    const body = parsed.body;
+    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 = path9.resolve(diffPayload.cwd);
+    const pathError = validateContextPath(repoRoot, body.filePath, "filePath");
+    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 sourceRef = body.side === "L" ? source.oldRef : source.newRef;
+    try {
+      return c.json(
+        await readSourcePeekRange({
+          repoRoot,
+          sourceFilePath: body.filePath,
+          sourceRef,
+          startLine: body.startLine,
+          lineCount: body.lineCount
+        })
+      );
+    } catch (error) {
+      return c.json({ error: `source range unavailable: ${formatError(error)}` }, 404);
+    }
+  });
   app.post("/api/reviews/:id/files/content", async (c) => {
     const id = c.req.param("id");
     const existing = await reviewStore.get(id);