getgloss 0.10.0 → 0.12.0

package/dist/server/daemon.js

@@ -10,7 +10,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.10.0",
+  version: "0.12.0",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -53,6 +53,7 @@ var package_default = {
     react: "19.2.6",
     "react-dom": "19.2.6",
     shiki: "4.1.0",
+    "simple-icons": "16.23.0",
     ulid: "3.0.2",
     zustand: "5.0.13"
   },
@@ -200,8 +201,44 @@ 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 SOURCE_PEEK_MAX_BYTES = 35e4;
 var REVIEW_SCOPE_MODES = ["all", "single", "range"];
 var RESOLUTION_STATUSES = ["partial", "resolved"];
+var OPEN_FILE_SCOPES = ["review", "repo"];
+var OPEN_FILE_TARGETS = [
+  "default",
+  "vscode",
+  "vscode-insiders",
+  "vscodium",
+  "cursor",
+  "sublime",
+  "zed",
+  "windsurf",
+  "webstorm",
+  "intellij",
+  "pycharm",
+  "goland",
+  "phpstorm",
+  "rubymine",
+  "clion",
+  "datagrip",
+  "android-studio",
+  "fleet",
+  "neovide",
+  "macvim",
+  "emacs",
+  "lapce",
+  "textmate",
+  "bbedit",
+  "coteditor",
+  "nova",
+  "textedit",
+  "xcode",
+  "terminal",
+  "iterm2",
+  "ghostty",
+  "folder"
+];
 
 // src/shared/validation.ts
 function parseJson(raw, guard, label) {
@@ -221,7 +258,10 @@ function isClearReviewsRequest(value) {
   return isRecord(value) && isOptionalNonNegativeInteger(value.olderThanDays) && isOptionalBoolean(value.dryRun);
 }
 function isOpenFileRequest(value) {
-  return isRecord(value) && isString(value.filePath) && isOptionalString(value.turnId);
+  return isRecord(value) && isString(value.filePath) && isOptionalString(value.turnId) && isOptional(value.scope, isOpenFileScope) && isOptional(value.target, isOpenFileTarget);
+}
+function isFileContentRequest(value) {
+  return isRecord(value) && isString(value.filePath) && isOptionalString(value.turnId) && isOptional(value.scope, isOpenFileScope);
 }
 function isCommitRangeDiffRequest(value) {
   return isRecord(value) && isString(value.fromSha) && isString(value.toSha) && isOptionalString(value.turnId);
@@ -229,6 +269,9 @@ function isCommitRangeDiffRequest(value) {
 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 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 isSubmitReviewRequest(value) {
   return isRecord(value) && isArrayOf(value.comments, isComment) && isOptional(value.reviewScope, isReviewScope);
 }
@@ -332,6 +375,12 @@ function isReviewStatus(value) {
 function isResolutionStatus(value) {
   return isOneOf(value, RESOLUTION_STATUSES);
 }
+function isOpenFileScope(value) {
+  return isOneOf(value, OPEN_FILE_SCOPES);
+}
+function isOpenFileTarget(value) {
+  return isOneOf(value, OPEN_FILE_TARGETS);
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -356,6 +405,12 @@ function isNumber(value) {
 function isPositiveInteger(value) {
   return isNumber(value) && Number.isInteger(value) && value > 0;
 }
+function isNonNegativeInteger(value) {
+  return isNumber(value) && Number.isInteger(value) && value >= 0;
+}
+function isIdentifier(value) {
+  return isString(value) && /^[A-Za-z_$][\w$]*$/.test(value);
+}
 function isOptionalNumber(value) {
   return value === void 0 || isNumber(value);
 }
@@ -514,8 +569,8 @@ function createIdleScheduler(options) {
 }
 
 // src/server/index.ts
-import { readFile as readFile5, realpath, stat } from "fs/promises";
-import path7 from "path";
+import { readFile as readFile6, realpath, stat } from "fs/promises";
+import path9 from "path";
 import { fileURLToPath } from "url";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
@@ -797,19 +852,706 @@ function isResolvableReviewStatus(status) {
 }
 
 // src/server/local-open.ts
+import { execFile } from "child_process";
+import { access } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import path6 from "path";
+import { promisify } from "util";
 import open from "open";
-async function openLocalPath(filePath) {
-  await open(filePath, { wait: false });
+var execFileAsync = promisify(execFile);
+var applicationRoots = [
+  "/Applications",
+  path6.join(homedir2(), "Applications"),
+  "/System/Applications",
+  "/System/Applications/Utilities"
+];
+var openFileTargetDescriptors = [
+  { appName: "Visual Studio Code", label: "VS Code", target: "vscode" },
+  {
+    appName: ["Visual Studio Code - Insiders", "Code - Insiders"],
+    label: "VS Code Insiders",
+    target: "vscode-insiders"
+  },
+  { appName: "VSCodium", label: "VSCodium", target: "vscodium" },
+  { appName: "Cursor", label: "Cursor", target: "cursor" },
+  { appName: "Sublime Text", label: "Sublime Text", target: "sublime" },
+  { appName: "Zed", label: "Zed", target: "zed" },
+  { appName: "Windsurf", label: "Windsurf", target: "windsurf" },
+  { appName: "WebStorm", label: "WebStorm", target: "webstorm" },
+  {
+    appName: ["IntelliJ IDEA", "IntelliJ IDEA Ultimate", "IntelliJ IDEA CE"],
+    label: "IntelliJ IDEA",
+    target: "intellij"
+  },
+  { appName: ["PyCharm", "PyCharm CE"], label: "PyCharm", target: "pycharm" },
+  { appName: "GoLand", label: "GoLand", target: "goland" },
+  { appName: "PhpStorm", label: "PhpStorm", target: "phpstorm" },
+  { appName: "RubyMine", label: "RubyMine", target: "rubymine" },
+  { appName: "CLion", label: "CLion", target: "clion" },
+  { appName: "DataGrip", label: "DataGrip", target: "datagrip" },
+  { appName: "Android Studio", label: "Android Studio", target: "android-studio" },
+  { appName: "Fleet", label: "Fleet", target: "fleet" },
+  { appName: "Neovide", label: "Neovide", target: "neovide" },
+  { appName: "MacVim", label: "MacVim", target: "macvim" },
+  { appName: "Emacs", label: "Emacs", target: "emacs" },
+  { appName: "Lapce", label: "Lapce", target: "lapce" },
+  { appName: "TextMate", label: "TextMate", target: "textmate" },
+  { appName: "BBEdit", label: "BBEdit", target: "bbedit" },
+  { appName: "CotEditor", label: "CotEditor", target: "coteditor" },
+  { appName: "Nova", label: "Nova", target: "nova" },
+  { appName: "TextEdit", label: "TextEdit", target: "textedit" },
+  { appName: "Terminal", label: "Terminal", opensFolder: true, target: "terminal" },
+  { appName: ["iTerm", "iTerm2"], label: "iTerm2", opensFolder: true, target: "iterm2" },
+  { appName: "Ghostty", label: "Ghostty", opensFolder: true, target: "ghostty" },
+  { appName: "Xcode", label: "Xcode", target: "xcode" },
+  { label: "Default app", target: "default" },
+  { label: "Open in folder", opensFolder: true, target: "folder" }
+];
+var openFileTargetDescriptorByTarget = new Map(
+  openFileTargetDescriptors.map((descriptor) => [descriptor.target, descriptor])
+);
+async function availableOpenFileTargets() {
+  const availability = await Promise.all(
+    openFileTargetDescriptors.map(
+      async (descriptor) => descriptor.appName && !await resolveAppPath(descriptor.appName) ? null : descriptor
+    )
+  );
+  return availability.filter((descriptor) => descriptor !== null).map(({ label, target }) => ({ label, target }));
+}
+async function openLocalPath(filePath, target = "default") {
+  const descriptor = openFileTargetDescriptorByTarget.get(target);
+  const openPath = descriptor?.opensFolder ? path6.dirname(filePath) : filePath;
+  const appName = descriptor?.appName;
+  if (!appName) {
+    await open(openPath, { wait: false });
+    return;
+  }
+  const appPath = await resolveAppPath(appName);
+  if (appPath) {
+    await execFileAsync("open", ["-a", appPath, openPath]);
+    return;
+  }
+  await open(openPath, { app: { name: appName }, wait: false });
+}
+async function resolveAppPath(appName) {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  const appNames = Array.isArray(appName) ? appName : [appName];
+  for (const name of appNames) {
+    for (const root of applicationRoots) {
+      const appPath = path6.join(root, `${name}.app`);
+      try {
+        await access(appPath);
+        return appPath;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+
+// src/server/source-peek.ts
+import { readFile as readFile3 } from "fs/promises";
+import path7 from "path";
+import { execa as execa2 } from "execa";
+var MODULE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+var PATH_CONFIG_FILES = ["tsconfig.json", "jsconfig.json"];
+var IGNORED_SEARCH_PATHS = ["node_modules", "dist", "build", "coverage", ".git"];
+var IDENTIFIER_PATTERN = "[A-Za-z_$][\\w$]*";
+var SOURCE_PEEK_CONTEXT_LINES = 520;
+var SOURCE_PEEK_TARGET_CONTEXT_LINES = 240;
+async function resolveSourcePeek({
+  column,
+  line,
+  repoRoot,
+  sourceFilePath,
+  sourceRef,
+  symbol
+}) {
+  const sourceContent = await readRepoText(repoRoot, sourceRef, sourceFilePath);
+  const sourceLines = splitFileLines2(sourceContent);
+  const reference = referenceTokenAt(sourceLines[line - 1] ?? "", column, symbol);
+  const imports = parseImportBindings(sourceContent);
+  const aliasConfig = await loadPathAliasConfig(repoRoot);
+  const importedCandidates = candidateImportsForReference(imports, reference);
+  for (const candidate of importedCandidates) {
+    const resolved = await resolveImportedTarget({
+      aliasConfig,
+      importedName: candidate.targetSymbol,
+      matchReason: "import",
+      moduleSpecifier: candidate.moduleSpecifier,
+      repoRoot,
+      sourceFilePath,
+      sourceRef,
+      symbol
+    });
+    if (resolved) {
+      return resolved;
+    }
+  }
+  const sameFileMatch = findDefinition(sourceContent, symbol);
+  if (sameFileMatch) {
+    return responseForMatch({
+      column: sameFileMatch.column,
+      content: sourceContent,
+      filePath: sourceFilePath,
+      line: sameFileMatch.line,
+      matchReason: "same-file",
+      symbol,
+      targetSymbol: symbol
+    });
+  }
+  const searched = await searchRepoDefinition(repoRoot, sourceRef, symbol);
+  if (searched) {
+    return responseForMatch({
+      ...searched,
+      matchReason: "repo-search",
+      symbol,
+      targetSymbol: symbol
+    });
+  }
+  throw new Error(`No definition found for ${symbol}`);
+}
+async function resolveImportedTarget({
+  aliasConfig,
+  importedName,
+  matchReason,
+  moduleSpecifier,
+  repoRoot,
+  sourceFilePath,
+  sourceRef,
+  symbol
+}) {
+  const moduleFile = await firstExistingModuleFile(
+    repoRoot,
+    sourceRef,
+    moduleCandidates(repoRoot, aliasConfig, sourceFilePath, moduleSpecifier)
+  );
+  if (!moduleFile) {
+    return null;
+  }
+  const targetMatch = findDefinition(moduleFile.content, importedName);
+  if (targetMatch) {
+    return responseForMatch({
+      column: targetMatch.column,
+      content: moduleFile.content,
+      filePath: moduleFile.filePath,
+      line: targetMatch.line,
+      matchReason,
+      symbol,
+      targetSymbol: importedName
+    });
+  }
+  const reExported = await resolveReExport({
+    aliasConfig,
+    content: moduleFile.content,
+    depth: 0,
+    repoRoot,
+    sourceFilePath: moduleFile.filePath,
+    sourceRef,
+    symbol,
+    targetSymbol: importedName
+  });
+  if (reExported) {
+    return reExported;
+  }
+  if (importedName === "default") {
+    const fallbackLine = firstMeaningfulLine(moduleFile.content);
+    return responseForMatch({
+      column: 0,
+      content: moduleFile.content,
+      filePath: moduleFile.filePath,
+      line: fallbackLine,
+      matchReason: "module",
+      symbol,
+      targetSymbol: importedName
+    });
+  }
+  return null;
+}
+async function resolveReExport({
+  aliasConfig,
+  content,
+  depth,
+  repoRoot,
+  sourceFilePath,
+  sourceRef,
+  symbol,
+  targetSymbol
+}) {
+  if (depth > 3) {
+    return null;
+  }
+  for (const binding of parseReExportBindings(content)) {
+    if (binding.exportedName !== "*" && binding.exportedName !== targetSymbol) {
+      continue;
+    }
+    const nextTarget = binding.importedName === "*" ? targetSymbol : binding.importedName;
+    const moduleFile = await firstExistingModuleFile(
+      repoRoot,
+      sourceRef,
+      moduleCandidates(repoRoot, aliasConfig, sourceFilePath, binding.moduleSpecifier)
+    );
+    if (!moduleFile) {
+      continue;
+    }
+    const match = findDefinition(moduleFile.content, nextTarget);
+    if (match) {
+      return responseForMatch({
+        column: match.column,
+        content: moduleFile.content,
+        filePath: moduleFile.filePath,
+        line: match.line,
+        matchReason: "import",
+        symbol,
+        targetSymbol: nextTarget
+      });
+    }
+    const nested = await resolveReExport({
+      aliasConfig,
+      content: moduleFile.content,
+      depth: depth + 1,
+      repoRoot,
+      sourceFilePath: moduleFile.filePath,
+      sourceRef,
+      symbol,
+      targetSymbol: nextTarget
+    });
+    if (nested) {
+      return nested;
+    }
+  }
+  return null;
+}
+async function searchRepoDefinition(repoRoot, sourceRef, symbol) {
+  const grepPattern = definitionGrepPattern(symbol);
+  const args = ["grep", "-n", "-I", "-E", grepPattern];
+  if (sourceRef) {
+    args.push(sourceRef);
+  }
+  args.push("--", ".");
+  for (const ignoredPath of IGNORED_SEARCH_PATHS) {
+    args.push(`:!${ignoredPath}`);
+  }
+  let output = "";
+  try {
+    output = (await execa2("git", args, { cwd: repoRoot })).stdout;
+  } catch (error) {
+    if (isExitCode(error, 1)) {
+      return null;
+    }
+    throw error;
+  }
+  for (const rawLine of output.split("\n")) {
+    const parsed = parseGrepLine(rawLine, sourceRef);
+    if (!parsed) {
+      continue;
+    }
+    const content = await readRepoText(repoRoot, sourceRef, parsed.filePath).catch(() => null);
+    if (!content) {
+      continue;
+    }
+    const match = findDefinition(content, symbol);
+    if (!match) {
+      continue;
+    }
+    return {
+      column: match.column,
+      content,
+      filePath: parsed.filePath,
+      line: match.line
+    };
+  }
+  return null;
+}
+async function readRepoText(repoRoot, ref, filePath) {
+  if (ref === null) {
+    return readFile3(path7.resolve(repoRoot, filePath), "utf8");
+  }
+  return (await execa2("git", ["show", `${ref}:${filePath}`], { cwd: repoRoot })).stdout;
+}
+function responseForMatch({
+  column,
+  content,
+  filePath,
+  line,
+  matchReason,
+  symbol,
+  targetSymbol
+}) {
+  const limited = limitContentAroundLine(content, line);
+  return {
+    symbol,
+    targetSymbol,
+    filePath,
+    startLine: limited.startLine,
+    line,
+    column,
+    language: languageForPath(filePath),
+    content: limited.content,
+    truncated: limited.truncated,
+    matchReason
+  };
+}
+function limitContentAroundLine(content, line) {
+  if (Buffer.byteLength(content, "utf8") <= SOURCE_PEEK_MAX_BYTES) {
+    return { content, startLine: 1, truncated: false };
+  }
+  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;
+    } else {
+      endIndex -= 1;
+    }
+    limitedContent = lines.slice(startIndex, endIndex).join("\n");
+  }
+  if (Buffer.byteLength(limitedContent, "utf8") > SOURCE_PEEK_MAX_BYTES) {
+    limitedContent = truncateUtf8(limitedContent, SOURCE_PEEK_MAX_BYTES);
+  }
+  return {
+    content: limitedContent,
+    startLine: startIndex + 1,
+    truncated: true
+  };
+}
+function truncateUtf8(value, maxBytes) {
+  const buffer = Buffer.from(value, "utf8");
+  if (buffer.byteLength <= maxBytes) {
+    return value;
+  }
+  return buffer.subarray(0, maxBytes).toString("utf8").replace(/\uFFFD$/, "");
+}
+function candidateImportsForReference(imports, reference) {
+  if (reference.namespace) {
+    return imports.filter(
+      (binding) => binding.kind === "namespace" && binding.localName === reference.namespace
+    ).map((binding) => ({
+      moduleSpecifier: binding.moduleSpecifier,
+      targetSymbol: reference.symbol
+    }));
+  }
+  return imports.filter((binding) => binding.localName === reference.symbol).map((binding) => ({
+    moduleSpecifier: binding.moduleSpecifier,
+    targetSymbol: binding.importedName
+  }));
+}
+function referenceTokenAt(line, column, symbol) {
+  let start = Math.min(Math.max(column, 0), line.length);
+  if (line.slice(start, start + symbol.length) !== symbol) {
+    const beforeOrAt = line.lastIndexOf(symbol, start);
+    start = beforeOrAt >= 0 ? beforeOrAt : line.indexOf(symbol);
+  }
+  if (start < 0) {
+    return { namespace: null, symbol };
+  }
+  const namespaceMatch = line.slice(0, start).match(/([A-Za-z_$][\w$]*)\s*\.\s*$/);
+  return {
+    namespace: namespaceMatch?.[1] ?? null,
+    symbol
+  };
+}
+function parseImportBindings(content) {
+  const bindings = [];
+  const importRegex = /^\s*import\s+(?:type\s+)?([^;]*?)\s+from\s+['"]([^'"]+)['"];?/gm;
+  let match = importRegex.exec(content);
+  while (match !== null) {
+    const body = match[1]?.trim() ?? "";
+    const moduleSpecifier = match[2] ?? "";
+    for (const part of splitImportParts(body)) {
+      if (part.startsWith("{") && part.endsWith("}")) {
+        bindings.push(
+          ...parseNamedBindings(part).map((binding) => ({
+            ...binding,
+            kind: "named",
+            moduleSpecifier
+          }))
+        );
+        continue;
+      }
+      const namespaceMatch = part.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
+      if (namespaceMatch?.[1]) {
+        bindings.push({
+          importedName: "*",
+          kind: "namespace",
+          localName: namespaceMatch[1],
+          moduleSpecifier
+        });
+        continue;
+      }
+      if (new RegExp(`^${IDENTIFIER_PATTERN}$`).test(part)) {
+        bindings.push({
+          importedName: "default",
+          kind: "default",
+          localName: part,
+          moduleSpecifier
+        });
+      }
+    }
+    match = importRegex.exec(content);
+  }
+  return bindings;
+}
+function parseReExportBindings(content) {
+  const bindings = [];
+  const exportRegex = /^\s*export\s+(?:type\s+)?(\*|\{[\s\S]*?\})\s+from\s+['"]([^'"]+)['"];?/gm;
+  let match = exportRegex.exec(content);
+  while (match !== null) {
+    const body = match[1] ?? "";
+    const moduleSpecifier = match[2] ?? "";
+    if (body === "*") {
+      bindings.push({ exportedName: "*", importedName: "*", moduleSpecifier });
+      match = exportRegex.exec(content);
+      continue;
+    }
+    bindings.push(
+      ...parseNamedBindings(body).map((binding) => ({
+        exportedName: binding.localName,
+        importedName: binding.importedName,
+        moduleSpecifier
+      }))
+    );
+    match = exportRegex.exec(content);
+  }
+  return bindings;
+}
+function parseNamedBindings(body) {
+  return body.slice(1, -1).split(",").map((part) => part.trim().replace(/^type\s+/, "")).filter(Boolean).map((part) => {
+    const aliasMatch = part.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
+    if (aliasMatch?.[1] && aliasMatch[2]) {
+      return { importedName: aliasMatch[1], localName: aliasMatch[2] };
+    }
+    return new RegExp(`^${IDENTIFIER_PATTERN}$`).test(part) ? { importedName: part, localName: part } : null;
+  }).filter((binding) => Boolean(binding));
+}
+function splitImportParts(body) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < body.length; index += 1) {
+    const char = body[index];
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth = Math.max(0, depth - 1);
+    } else if (char === "," && depth === 0) {
+      parts.push(body.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  parts.push(body.slice(start).trim());
+  return parts.filter(Boolean);
+}
+async function loadPathAliasConfig(repoRoot) {
+  for (const configFile of PATH_CONFIG_FILES) {
+    const rawConfig = await readFile3(path7.join(repoRoot, configFile), "utf8").catch(() => null);
+    if (!rawConfig) {
+      continue;
+    }
+    const parsed = parseJsonConfig(rawConfig);
+    if (!parsed) {
+      continue;
+    }
+    const compilerOptions = asRecord(parsed.compilerOptions);
+    const baseUrlValue = compilerOptions ? compilerOptions.baseUrl : null;
+    const baseUrl = typeof baseUrlValue === "string" ? path7.resolve(repoRoot, baseUrlValue) : repoRoot;
+    const paths = asRecord(compilerOptions?.paths);
+    const aliases = paths ? Object.entries(paths).flatMap(
+      ([pattern, replacements]) => Array.isArray(replacements) ? [
+        {
+          pattern,
+          replacements: replacements.filter(
+            (replacement) => typeof replacement === "string"
+          )
+        }
+      ] : []
+    ) : [];
+    return { aliases, baseUrl };
+  }
+  return { aliases: [], baseUrl: null };
+}
+function parseJsonConfig(rawConfig) {
+  try {
+    return JSON.parse(stripJsonComments(rawConfig).replace(/,\s*([}\]])/g, "$1"));
+  } catch {
+    return null;
+  }
+}
+function stripJsonComments(input) {
+  return input.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+}
+function moduleCandidates(repoRoot, aliasConfig, sourceFilePath, moduleSpecifier) {
+  const roots = [];
+  if (moduleSpecifier.startsWith(".")) {
+    roots.push(path7.resolve(repoRoot, path7.dirname(sourceFilePath), moduleSpecifier));
+  } else {
+    roots.push(...aliasCandidateRoots(repoRoot, aliasConfig, moduleSpecifier));
+    if (aliasConfig.baseUrl) {
+      roots.push(path7.resolve(aliasConfig.baseUrl, moduleSpecifier));
+    }
+  }
+  const candidates = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    for (const candidate of expandModuleRoot(root)) {
+      const relativePath = repoRelativePath(repoRoot, candidate);
+      if (relativePath) {
+        candidates.add(relativePath);
+      }
+    }
+  }
+  return [...candidates];
+}
+function aliasCandidateRoots(repoRoot, aliasConfig, moduleSpecifier) {
+  const roots = [];
+  for (const alias of aliasConfig.aliases) {
+    const wildcardIndex = alias.pattern.indexOf("*");
+    const matched = wildcardIndex >= 0 ? matchWildcardPattern(alias.pattern, wildcardIndex, moduleSpecifier) : alias.pattern === moduleSpecifier ? "" : null;
+    if (matched === null) {
+      continue;
+    }
+    for (const replacement of alias.replacements) {
+      roots.push(
+        path7.resolve(
+          aliasConfig.baseUrl ?? repoRoot,
+          wildcardIndex >= 0 ? replacement.replace("*", matched) : replacement
+        )
+      );
+    }
+  }
+  return roots;
+}
+function matchWildcardPattern(pattern, wildcardIndex, value) {
+  const prefix = pattern.slice(0, wildcardIndex);
+  const suffix = pattern.slice(wildcardIndex + 1);
+  if (!value.startsWith(prefix) || !value.endsWith(suffix)) {
+    return null;
+  }
+  return value.slice(prefix.length, value.length - suffix.length);
+}
+function expandModuleRoot(root) {
+  const candidates = [];
+  if (path7.extname(root)) {
+    candidates.push(root);
+  } else {
+    for (const extension of MODULE_EXTENSIONS) {
+      candidates.push(`${root}${extension}`);
+    }
+    for (const extension of MODULE_EXTENSIONS) {
+      candidates.push(path7.join(root, `index${extension}`));
+    }
+  }
+  return candidates;
+}
+async function firstExistingModuleFile(repoRoot, sourceRef, candidates) {
+  for (const filePath of candidates) {
+    const content = await readRepoText(repoRoot, sourceRef, filePath).catch(() => null);
+    if (content !== null) {
+      return { content, filePath };
+    }
+  }
+  return null;
+}
+function findDefinition(content, symbol) {
+  const lines = splitFileLines2(content);
+  const patterns = definitionPatterns(symbol);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (!patterns.some((pattern) => pattern.test(line))) {
+      continue;
+    }
+    return {
+      column: Math.max(0, line.indexOf(symbol === "default" ? "default" : symbol)),
+      line: index + 1
+    };
+  }
+  return null;
+}
+function definitionPatterns(symbol) {
+  if (symbol === "default") {
+    return [/^\s*export\s+default\b/];
+  }
+  const escaped = escapeRegex(symbol);
+  return [
+    new RegExp(`^\\s*(?:export\\s+)?(?:declare\\s+)?(?:async\\s+)?function\\s+${escaped}\\b`),
+    new RegExp(`^\\s*(?:export\\s+)?(?:declare\\s+)?(?:const|let|var)\\s+${escaped}\\b`),
+    new RegExp(
+      `^\\s*(?:export\\s+)?(?:declare\\s+)?(?:class|interface|type|enum)\\s+${escaped}\\b`
+    ),
+    new RegExp(`^\\s*export\\s+default\\s+(?:async\\s+)?function\\s+${escaped}\\b`),
+    new RegExp(`^\\s*export\\s+default\\s+class\\s+${escaped}\\b`)
+  ];
+}
+function definitionGrepPattern(symbol) {
+  const escaped = escapeExtendedGrep(symbol);
+  return [
+    `^[[:space:]]*(export[[:space:]]+)?(declare[[:space:]]+)?(async[[:space:]]+)?function[[:space:]]+${escaped}([^[:alnum:]_$]|$)`,
+    `^[[:space:]]*(export[[:space:]]+)?(declare[[:space:]]+)?(const|let|var)[[:space:]]+${escaped}([^[:alnum:]_$]|$)`,
+    `^[[:space:]]*(export[[:space:]]+)?(declare[[:space:]]+)?(class|interface|type|enum)[[:space:]]+${escaped}([^[:alnum:]_$]|$)`
+  ].join("|");
+}
+function firstMeaningfulLine(content) {
+  const lines = splitFileLines2(content);
+  const index = lines.findIndex((line) => line.trim() !== "");
+  return index >= 0 ? index + 1 : 1;
+}
+function parseGrepLine(rawLine, sourceRef) {
+  const line = sourceRef ? rawLine.slice(sourceRef.length + 1) : rawLine;
+  const firstColon = line.indexOf(":");
+  const secondColon = line.indexOf(":", firstColon + 1);
+  if (firstColon < 0 || secondColon < 0) {
+    return null;
+  }
+  const lineNumber = Number(line.slice(firstColon + 1, secondColon));
+  if (!Number.isFinite(lineNumber)) {
+    return null;
+  }
+  return {
+    filePath: line.slice(0, firstColon),
+    line: lineNumber
+  };
+}
+function repoRelativePath(repoRoot, absolutePath) {
+  const relativePath = path7.relative(repoRoot, absolutePath);
+  if (!relativePath || relativePath.startsWith("..") || path7.isAbsolute(relativePath)) {
+    return null;
+  }
+  return relativePath.split(path7.sep).join("/");
+}
+function splitFileLines2(contents) {
+  const lines = contents.replace(/\r\n/g, "\n").split("\n");
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+  return lines;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function isExitCode(error, exitCode) {
+  return typeof error === "object" && error !== null && "exitCode" in error ? error.exitCode === exitCode : false;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeExtendedGrep(value) {
+  return value.replace(/[.[*^$()+?{}|\\]/g, "\\$&");
 }
 
 // src/server/store.ts
 import { createHash } from "crypto";
-import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
-import path6 from "path";
+import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import path8 from "path";
 import { ulid } from "ulid";
 
 // src/shared/cleanup.ts
-import { readdir, readFile as readFile3, rm as rm3 } from "fs/promises";
+import { readdir, readFile as readFile4, 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;
@@ -869,7 +1611,7 @@ function normalizeRetentionDays(value) {
 async function cleanupCandidate(reviewId, artifactDir, cutoff, skipped) {
   let raw;
   try {
-    raw = await readFile3(globalReviewMetaFile(reviewId), "utf8");
+    raw = await readFile4(globalReviewMetaFile(reviewId), "utf8");
   } catch (error) {
     if (isFileNotFound(error)) {
       skipped.push({ reviewId, artifactDir, reason: "missing metadata" });
@@ -949,7 +1691,7 @@ async function persistedTurnCleanupState(reviewId, artifactDir, skipped) {
 async function readPersistedTurnMeta(reviewId, turnDirName, artifactDir, skipped) {
   let raw;
   try {
-    raw = await readFile3(globalReviewTurnMetaFile(reviewId, turnDirName), "utf8");
+    raw = await readFile4(globalReviewTurnMetaFile(reviewId, turnDirName), "utf8");
   } catch (error) {
     skipped.push({
       reviewId,
@@ -1476,7 +2218,7 @@ var ReviewStore = class {
     const metaPath = globalReviewMetaFile(id);
     let metaRaw;
     try {
-      metaRaw = await readFile4(metaPath, "utf8");
+      metaRaw = await readFile5(metaPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return this.loadReviewFromTurnsOnly(id);
@@ -1558,8 +2300,8 @@ var ReviewStore = class {
     let diffRaw;
     try {
       [metaRaw, diffRaw] = await Promise.all([
-        readFile4(metaPath, "utf8"),
-        readFile4(diffPath, "utf8")
+        readFile5(metaPath, "utf8"),
+        readFile5(diffPath, "utf8")
       ]);
     } catch (error) {
       if (isFileNotFound(error)) {
@@ -1589,7 +2331,7 @@ var ReviewStore = class {
     const diffPath = globalReviewDiffFile(id);
     let diffRaw;
     try {
-      diffRaw = await readFile4(diffPath, "utf8");
+      diffRaw = await readFile5(diffPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return null;
@@ -1769,9 +2511,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 ?? 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,
+    feedbackPath: feedback ? meta.feedbackPath ?? path8.join(meta.artifactDir, "feedback.json") : void 0,
+    markdownPath: feedback ? meta.markdownPath ?? path8.join(meta.artifactDir, "feedback.md") : void 0,
+    resolvedPath: resolution ? meta.resolvedPath ?? path8.join(meta.artifactDir, "resolved.json") : void 0,
     diff,
     ...feedback ? { feedback } : {},
     ...resolution ? { resolution } : {}
@@ -1804,7 +2546,7 @@ function requiredPath(value, label) {
 async function readOptionalJsonFile(filePath, guard, label) {
   let raw;
   try {
-    raw = await readFile4(filePath, "utf8");
+    raw = await readFile5(filePath, "utf8");
   } catch (error) {
     if (isFileNotFound(error)) {
       return void 0;
@@ -1849,6 +2591,10 @@ function createApp(origin2, options = {}) {
     };
     return c.json(response);
   });
+  app.get("/api/open-targets", async (c) => {
+    const response = { targets: await availableOpenFileTargets() };
+    return c.json(response);
+  });
   app.get("/api/reviews", async (c) => {
     const response = { reviews: await reviewStore.list() };
     return c.json(response);
@@ -2075,7 +2821,7 @@ function createApp(origin2, options = {}) {
       return c.json({ error: "turn not found" }, 404);
     }
     const diffPayload = turn?.diff ?? existing.diff;
-    const repoRoot = path7.resolve(diffPayload.cwd);
+    const repoRoot = path9.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);
@@ -2110,6 +2856,129 @@ function createApp(origin2, options = {}) {
       return c.json({ error: `context is unavailable: ${formatError(error)}` }, 409);
     }
   });
+  app.post("/api/reviews/:id/source-peek", 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, isSourcePeekRequest, "source peek 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") ?? (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 source peek is not available" }, 409);
+    }
+    if (body.side === "L" && reviewFile.isNew) {
+      return c.json({ error: "new files do not have an old-side source" }, 409);
+    }
+    if (body.side === "R" && reviewFile.isDeleted) {
+      return c.json({ error: "deleted files do not have a new-side source" }, 409);
+    }
+    const sourceFilePath = body.side === "L" ? body.oldPath ?? body.filePath : body.filePath;
+    const sourceRef = body.side === "L" ? source.oldRef : source.newRef;
+    try {
+      return c.json(
+        await resolveSourcePeek({
+          repoRoot,
+          sourceFilePath,
+          sourceRef,
+          symbol: body.symbol,
+          line: body.line,
+          column: body.column
+        })
+      );
+    } catch (error) {
+      return c.json({ error: `source peek 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);
+    if (!existing) {
+      return c.json({ error: "review not found" }, 404);
+    }
+    const parsed = await readJsonBody(c, isFileContentRequest, "file content request");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    const { filePath, scope = "review", turnId } = parsed.body;
+    if (!filePath || filePath.includes("\0") || path9.isAbsolute(filePath)) {
+      return c.json({ error: "filePath must be a repo-relative path" }, 400);
+    }
+    const repoRoot = path9.resolve(existing.diff.cwd);
+    const requestedAbsolutePath = path9.resolve(repoRoot, filePath);
+    if (!isPathWithin(repoRoot, requestedAbsolutePath)) {
+      return c.json({ error: "filePath must stay within the review cwd" }, 400);
+    }
+    const turn = turnId ? await reviewStore.getTurn(id, turnId) : null;
+    if (turnId && !turn) {
+      return c.json({ error: "turn not found" }, 404);
+    }
+    if (scope === "review") {
+      const diffPayload = turn?.diff ?? existing.diff;
+      const reviewFiles = [
+        ...diffPayload.files,
+        ...(diffPayload.commitDiffs ?? []).flatMap((commitDiff) => commitDiff.files)
+      ].filter((file) => file.path === filePath);
+      if (reviewFiles.length === 0) {
+        return c.json({ error: "file is not part of this review" }, 404);
+      }
+      if (reviewFiles.every((file) => file.isDeleted)) {
+        return c.json({ error: "deleted files cannot be copied" }, 409);
+      }
+      if (reviewFiles.some((file) => file.isBinary)) {
+        return c.json({ error: "binary file contents cannot be copied" }, 409);
+      }
+    }
+    let realRepoRoot;
+    let realFilePath;
+    try {
+      [realRepoRoot, realFilePath] = await Promise.all([
+        realpath(repoRoot),
+        realpath(requestedAbsolutePath)
+      ]);
+    } catch (error) {
+      if (isFileNotFound(error)) {
+        return c.json({ error: "file no longer exists on disk" }, 404);
+      }
+      throw error;
+    }
+    if (!isPathWithin(realRepoRoot, realFilePath)) {
+      return c.json({ error: "filePath must stay within the review cwd" }, 400);
+    }
+    const fileStats = await stat(realFilePath);
+    if (!fileStats.isFile()) {
+      return c.json({ error: "path is not a file" }, 409);
+    }
+    const response = {
+      content: await readFile6(realFilePath, "utf8"),
+      filePath
+    };
+    return c.json(response);
+  });
   app.post("/api/reviews/:id/files/open", async (c) => {
     const id = c.req.param("id");
     const existing = await reviewStore.get(id);
@@ -2120,12 +2989,12 @@ function createApp(origin2, options = {}) {
     if (!parsed.ok) {
       return parsed.response;
     }
-    const { filePath, turnId } = parsed.body;
-    if (!filePath || filePath.includes("\0") || path7.isAbsolute(filePath)) {
+    const { filePath, scope = "review", target, turnId } = parsed.body;
+    if (!filePath || filePath.includes("\0") || path9.isAbsolute(filePath)) {
       return c.json({ error: "filePath must be a repo-relative path" }, 400);
     }
-    const repoRoot = path7.resolve(existing.diff.cwd);
-    const requestedAbsolutePath = path7.resolve(repoRoot, filePath);
+    const repoRoot = path9.resolve(existing.diff.cwd);
+    const requestedAbsolutePath = path9.resolve(repoRoot, filePath);
     if (!isPathWithin(repoRoot, requestedAbsolutePath)) {
       return c.json({ error: "filePath must stay within the review cwd" }, 400);
     }
@@ -2133,16 +3002,18 @@ function createApp(origin2, options = {}) {
     if (turnId && !turn) {
       return c.json({ error: "turn not found" }, 404);
     }
-    const diffPayload = turn?.diff ?? existing.diff;
-    const reviewFiles = [
-      ...diffPayload.files,
-      ...(diffPayload.commitDiffs ?? []).flatMap((commitDiff) => commitDiff.files)
-    ].filter((file) => file.path === filePath);
-    if (reviewFiles.length === 0) {
-      return c.json({ error: "file is not part of this review" }, 404);
-    }
-    if (reviewFiles.every((file) => file.isDeleted)) {
-      return c.json({ error: "deleted files cannot be opened locally" }, 409);
+    if (scope === "review") {
+      const diffPayload = turn?.diff ?? existing.diff;
+      const reviewFiles = [
+        ...diffPayload.files,
+        ...(diffPayload.commitDiffs ?? []).flatMap((commitDiff) => commitDiff.files)
+      ].filter((file) => file.path === filePath);
+      if (reviewFiles.length === 0) {
+        return c.json({ error: "file is not part of this review" }, 404);
+      }
+      if (reviewFiles.every((file) => file.isDeleted)) {
+        return c.json({ error: "deleted files cannot be opened locally" }, 409);
+      }
     }
     let realRepoRoot;
     let realFilePath;
@@ -2165,7 +3036,7 @@ function createApp(origin2, options = {}) {
       return c.json({ error: "path is not a file" }, 409);
     }
     try {
-      await openLocalPath(realFilePath);
+      target ? await openLocalPath(realFilePath, target) : await openLocalPath(realFilePath);
     } catch (error) {
       return c.json({ error: `could not open file: ${formatError(error)}` }, 500);
     }
@@ -2241,13 +3112,13 @@ function createApp(origin2, options = {}) {
 }
 async function serveAsset(c) {
   const requestPath = new URL(c.req.url).pathname.replace(/^\/assets\//, "");
-  const normalized = path7.normalize(requestPath).replace(/^(\.\.(\/|\\|$))+/, "");
-  const assetPath = path7.join(webRoot, "assets", normalized);
+  const normalized = path9.normalize(requestPath).replace(/^(\.\.(\/|\\|$))+/, "");
+  const assetPath = path9.join(webRoot, "assets", normalized);
   try {
-    const body = await readFile5(assetPath);
+    const body = await readFile6(assetPath);
     return new Response(body, {
       headers: {
-        "content-type": mimeTypes[path7.extname(assetPath)] ?? "application/octet-stream"
+        "content-type": mimeTypes[path9.extname(assetPath)] ?? "application/octet-stream"
       }
     });
   } catch (error) {
@@ -2259,7 +3130,7 @@ async function serveAsset(c) {
 }
 async function serveIndex() {
   try {
-    const body = await readFile5(path7.join(webRoot, "index.html"));
+    const body = await readFile6(path9.join(webRoot, "index.html"));
     return new Response(body, {
       headers: { "content-type": "text/html; charset=utf-8" }
     });
@@ -2273,7 +3144,7 @@ async function serveIndex() {
 function serveRootFile(fileName, contentType) {
   return async () => {
     try {
-      const body = await readFile5(path7.join(webRoot, fileName));
+      const body = await readFile6(path9.join(webRoot, fileName));
       return new Response(body, {
         headers: { "content-type": contentType }
       });
@@ -2305,8 +3176,8 @@ async function readJsonBody(c, guard, label) {
   }
 }
 function isPathWithin(parentPath, childPath) {
-  const relative = path7.relative(parentPath, childPath);
-  return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
+  const relative = path9.relative(parentPath, childPath);
+  return relative === "" || !relative.startsWith("..") && !path9.isAbsolute(relative);
 }
 async function resolveContextSource(diffPayload, source) {
   if (source.mode === "turn") {
@@ -2354,10 +3225,10 @@ async function resolveContextSource(diffPayload, source) {
   };
 }
 function validateContextPath(repoRoot, filePath, label) {
-  if (!filePath || filePath.includes("\0") || path7.isAbsolute(filePath)) {
+  if (!filePath || filePath.includes("\0") || path9.isAbsolute(filePath)) {
     return `${label} must be a repo-relative path`;
   }
-  const requestedAbsolutePath = path7.resolve(repoRoot, filePath);
+  const requestedAbsolutePath = path9.resolve(repoRoot, filePath);
   if (!isPathWithin(repoRoot, requestedAbsolutePath)) {
     return `${label} must stay within the review cwd`;
   }