diffsplain 0.5.0 → 0.7.0

package/scripts/build-diff-data.mjs

@@ -3,14 +3,20 @@
 import { execFileSync, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import {
+  closeSync,
+  constants,
   existsSync,
+  fstatSync,
+  lstatSync,
   mkdirSync,
+  openSync,
   readFileSync,
+  readlinkSync,
   renameSync,
   statSync,
   writeFileSync,
 } from 'node:fs';
-import { dirname, relative, resolve } from 'node:path';
+import { basename, dirname, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { summaryPath } from './summary-path.mjs';
 
@@ -26,6 +32,10 @@ const option = (name) => {
   if (!value || value.startsWith('--')) fail(`${name} needs a value`);
   return value;
 };
+const options = (name) =>
+  args.flatMap((argument, index) =>
+    argument === name && args[index + 1] ? [args[index + 1]] : [],
+  );
 const has = (name) => args.includes(name);
 
 if (has('--help')) {
@@ -52,7 +62,7 @@ Options:
 
 const repo = resolve(option('--repo') || process.cwd());
 const output = resolve(option('--output') || '.cache/diff-data.json');
-const excludedOutput = option('--exclude-output');
+const excludedOutputs = options('--exclude-output');
 const baseOption = option('--base');
 const headOption = option('--head');
 const prOption = option('--pr');
@@ -79,7 +89,18 @@ const cacheRoot = cacheOption
   : resolve(projectRoot, '.cache/git');
 const remoteMode = Boolean(prOption || branchOption);
 const watching = has('--watch');
+const watchContent = has('--watch-content');
 const ignoreSummaryWatch = has('--ignore-summary-watch');
+const noSummaries = has('--no-summaries');
+const interval = (name, fallback) => {
+  const value = Number(process.env[name]);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+};
+const watchInterval = interval('DIFFSPLAIN_WATCH_INTERVAL_MS', 2_000);
+const remoteRefreshInterval = interval(
+  'DIFFSPLAIN_REMOTE_REFRESH_INTERVAL_MS',
+  30_000,
+);
 
 if (prOption && branchOption) fail('--pr and --branch cannot be used together');
 if (prOption && (baseOption || headOption)) fail('--pr cannot be used with --base or --head');
@@ -109,11 +130,13 @@ const repoPath = (file) => {
   const path = relative(repo, file).replaceAll('\\', '/');
   return path && path !== '..' && !path.startsWith('../') ? path : undefined;
 };
+const summariesRepoPath = repoPath(summariesPath);
 const excludedPaths = new Set(
   [
-    repoPath(summariesPath),
+    summariesRepoPath,
+    summariesRepoPath ? `${summariesRepoPath}.lock` : undefined,
     repoPath(output),
-    excludedOutput ? repoPath(resolve(excludedOutput)) : undefined,
+    ...excludedOutputs.map((path) => repoPath(resolve(path))),
   ].filter(Boolean),
 );
 
@@ -176,6 +199,22 @@ const completeChangeSummary = (value) =>
   completeText(value.why) &&
   completeList(value.highlights) &&
   completeList(value.risks);
+const failedFileRecords = (value) =>
+  Array.isArray(value)
+    ? value
+        .filter(
+          (item) =>
+            item &&
+            typeof item.path === 'string' &&
+            item.path.trim() &&
+            typeof item.reason === 'string' &&
+            item.reason.trim(),
+        )
+        .map((item) => ({
+          path: item.path.trim(),
+          reason: item.reason.trim(),
+        }))
+    : [];
 
 function fileSummary(path, value) {
   return {
@@ -311,12 +350,24 @@ function normalizeBranch(value, remoteName) {
 }
 
 function resolveRemote() {
-  const configured = tryRepo(['remote', 'get-url', remoteOption]);
-  if (configured) return { name: remoteOption, url: configured };
+  const configured = tryRepo([
+    'config',
+    '--get-all',
+    `remote.${remoteOption}.url`,
+  ])
+    .split('\n')
+    .find(Boolean);
+  if (configured) {
+    return {
+      name: remoteOption,
+      url: configured,
+      fetchUrl: tryRepo(['remote', 'get-url', remoteOption]) || configured,
+    };
+  }
   if (remoteOption === 'origin') {
     throw new Error(`Git remote "origin" was not found in ${repo}`);
   }
-  return { name: remoteOption, url: remoteOption };
+  return { name: remoteOption, url: remoteOption, fetchUrl: remoteOption };
 }
 
 function bareCache(remoteUrl) {
@@ -387,6 +438,34 @@ function remoteDefaultBranch(remoteUrl) {
   return remoteDefaultBranchInfo(remoteUrl).name;
 }
 
+function remoteContainsCommits(remoteUrl, commits) {
+  let raw;
+  try {
+    raw = runRepo(['ls-remote', remoteUrl]);
+  } catch {
+    return false;
+  }
+  const tips = [
+    ...new Set(
+      raw
+        .split('\n')
+        .map((line) => line.trim().split(/\s+/, 1)[0])
+        .filter(Boolean),
+    ),
+  ];
+  return commits.every((commit) =>
+    tips.some((tip) => {
+      if (tip === commit) return true;
+      const result = spawnSync(
+        'git',
+        ['-C', repo, 'merge-base', '--is-ancestor', commit, tip],
+        { stdio: 'ignore' },
+      );
+      return result.status === 0;
+    }),
+  );
+}
+
 function localDefaultBranch(remote) {
   if (baseOption) return { name: baseOption };
 
@@ -506,7 +585,7 @@ function resolveBranchTarget() {
   const remote = resolveRemote();
   const branch = normalizeBranch(branchOption, remote.name);
   const baseBranch = normalizeBranch(
-    baseOption || remoteDefaultBranch(remote.url),
+    baseOption || remoteDefaultBranch(remote.fetchUrl),
     remote.name,
   );
   const cache = bareCache(remote.url);
@@ -516,7 +595,7 @@ function resolveBranchTarget() {
     .slice(0, 16);
   const baseRef = `refs/diffsplain/branch/${key}/base`;
   const headRef = `refs/diffsplain/branch/${key}/head`;
-  fetchInto(cache, remote.url, [
+  fetchInto(cache, remote.fetchUrl, [
     `+refs/heads/${baseBranch}:${baseRef}`,
     `+refs/heads/${branch}:${headRef}`,
   ]);
@@ -535,6 +614,7 @@ function resolveBranchTarget() {
     remote,
     sourceRepositoryUrl: repository?.webUrl,
     baseRepositoryUrl: repository?.webUrl,
+    comparisonCommitsOnRemote: true,
     target: {
       kind: 'branch',
       remote: remote.name,
@@ -562,7 +642,7 @@ function resolvePullRequestTarget() {
     .slice(0, 16);
   const baseRef = `refs/diffsplain/pr/${key}/base`;
   const headRef = `refs/diffsplain/pr/${key}/head`;
-  fetchInto(cache, remote.url, [
+  fetchInto(cache, remote.fetchUrl, [
     `+refs/heads/${pr.baseRefName}:${baseRef}`,
     `+refs/pull/${pr.number}/head:${headRef}`,
   ]);
@@ -600,6 +680,7 @@ function resolvePullRequestTarget() {
         pr.url.replace(/\/pull\/\d+(?:\/.*)?$/, ''),
     baseRepositoryUrl:
       repository?.webUrl || pr.url.replace(/\/pull\/\d+(?:\/.*)?$/, ''),
+    comparisonCommitsOnRemote: true,
     target: {
       kind: 'pull-request',
       remote: remote.name,
@@ -646,6 +727,9 @@ function resolveCheckoutTarget() {
   const repository = githubRepository(remoteUrl);
   const headLabel = branch || currentHead;
   const hasCommittedChanges = mergeBaseOid !== currentHead;
+  const hasUncommittedChanges = Boolean(
+    tryRepo(['status', '--porcelain=v1', '-z']),
+  );
   const isDefaultBranchCheckout = branch === defaultBranch.name;
 
   return {
@@ -659,6 +743,12 @@ function resolveCheckoutTarget() {
     remote,
     sourceRepositoryUrl: repository?.webUrl,
     baseRepositoryUrl: repository?.webUrl,
+    comparisonCommitsOnRemote:
+      !hasUncommittedChanges &&
+      Boolean(
+        remote?.url &&
+          remoteContainsCommits(remote.url, [mergeBaseOid, currentHead]),
+      ),
     target: {
       kind: 'checkout',
       ...(remote ? { remote: remote.name } : {}),
@@ -712,6 +802,12 @@ function resolveLocalTarget() {
     baseRepositoryUrl: worktree
       ? undefined
       : githubRepository(remoteUrl)?.webUrl,
+    comparisonCommitsOnRemote:
+      !worktree &&
+      Boolean(
+        remoteUrl &&
+          remoteContainsCommits(remoteUrl, [resolvedBase, resolvedHead]),
+      ),
     target: worktree
       ? { kind: 'worktree', base: { ref: 'HEAD', oid: currentHead || null } }
       : {
@@ -812,6 +908,13 @@ function githubFileUrl(repositoryUrl, ref, path) {
   return `${repositoryUrl}/blob/${encodeURIComponent(ref)}/${filePath}`;
 }
 
+function githubComparisonUrl(repositoryUrl, base, head) {
+  if (!repositoryUrl || !base || !head || head === 'WORKTREE') {
+    return undefined;
+  }
+  return `${repositoryUrl}/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`;
+}
+
 function build() {
   const localWorkspace =
     tryRepo(['rev-parse', '--is-inside-work-tree']) === 'true';
@@ -820,7 +923,7 @@ function build() {
   }
   const target = resolveTarget();
   const remoteRepository = githubRepository(target.remote?.url);
-  const summaryDoc = readJson(summariesPath, {}) || {};
+  const summaryDoc = noSummaries ? {} : readJson(summariesPath, {}) || {};
   const allTrackedFiles = parseNameStatus(
     target.runGit([
       'diff',
@@ -887,6 +990,13 @@ function build() {
       file.status === 'deleted' ? target.base : target.head,
       file.path,
     );
+    const comparisonUrl = githubComparisonUrl(
+      target.comparisonCommitsOnRemote
+        ? target.sourceRepositoryUrl
+        : undefined,
+      target.base,
+      target.head,
+    );
     return {
       path: file.path,
       ...(file.oldPath ? { oldPath: file.oldPath } : {}),
@@ -899,6 +1009,7 @@ function build() {
       patch: textPatch,
       snippet: binary ? '' : compactSnippet(textPatch),
       ...(sourceUrl ? { sourceUrl } : {}),
+      ...(comparisonUrl ? { comparisonUrl } : {}),
     };
   });
 
@@ -926,39 +1037,64 @@ function build() {
     )
     .digest('hex');
   const generatedFor =
+    !noSummaries &&
     typeof summaryDoc.meta?.reviewFingerprint === 'string'
       ? summaryDoc.meta.reviewFingerprint
       : undefined;
-  const summariesAreFresh = !generatedFor || generatedFor === reviewFingerprint;
+  const summariesAreFresh =
+    !noSummaries && (!generatedFor || generatedFor === reviewFingerprint);
   const sourceSummaries = summariesAreFresh ? summaryDoc : {};
+  const failedFiles = summariesAreFresh
+    ? failedFileRecords(summaryDoc.meta?.failedFiles)
+    : [];
+  const summaryErrors = summariesAreFresh
+    ? cleanList(summaryDoc.meta?.errors)
+    : [];
+  const failureByPath = new Map(
+    failedFiles.map((failure) => [failure.path, failure.reason]),
+  );
+  const emptyReviewComplete =
+    filesWithoutSummaries.length === 0 &&
+    generatedFor === reviewFingerprint &&
+    sourceSummaries.meta?.status === 'complete';
   const summariesAreComplete =
     summariesAreFresh &&
-    completeChangeSummary(sourceSummaries.change) &&
-    filesWithoutSummaries.every((file) =>
-      completeFileSummary(sourceSummaries.files?.[file.path]),
-    );
-  const completedFiles = filesWithoutSummaries.filter((file) =>
-    completeFileSummary(sourceSummaries.files?.[file.path]),
-  ).length;
+    failedFiles.length === 0 &&
+    summaryErrors.length === 0 &&
+    (emptyReviewComplete ||
+      (completeChangeSummary(sourceSummaries.change) &&
+        filesWithoutSummaries.every((file) =>
+          completeFileSummary(sourceSummaries.files?.[file.path]),
+        )));
+  const completedFiles = noSummaries
+    ? 0
+    : filesWithoutSummaries.filter((file) =>
+        completeFileSummary(sourceSummaries.files?.[file.path]),
+      ).length;
   const storedStatus = summaryDoc.meta?.status;
-  const noteStatus = summariesAreComplete
-    ? 'complete'
-    : !summariesAreFresh
-      ? 'stale'
-      : ['generating', 'failed'].includes(storedStatus)
-        ? storedStatus
-        : 'idle';
+  const noteStatus = noSummaries
+    ? 'idle'
+    : summariesAreComplete
+      ? 'complete'
+      : !summariesAreFresh
+        ? 'stale'
+        : ['generating', 'failed'].includes(storedStatus)
+          ? storedStatus
+          : 'idle';
   const files = filesWithoutSummaries.map((file) => ({
     ...file,
     summary: fileSummary(file.path, sourceSummaries.files?.[file.path]),
     noteReady: Boolean(
       completeFileSummary(sourceSummaries.files?.[file.path]),
     ),
+    ...(failureByPath.has(file.path)
+      ? { noteFailure: failureByPath.get(file.path) }
+      : {}),
   }));
   const change = changeSummary(sourceSummaries.change, target.changeDefaults);
   const content = {
     repo: {
-      name: remoteRepository?.name || repo.split('/').pop(),
+      name: remoteRepository?.name || basename(repo),
       root: localWorkspace ? repo : target.remote?.url || repo,
       base: target.base,
       head: target.head,
@@ -979,9 +1115,14 @@ function build() {
       status: noteStatus,
       completedFiles,
       totalFiles: filesWithoutSummaries.length,
+      ...(failedFiles.length ? { failedFiles } : {}),
+      ...(summaryErrors.length ? { errors: summaryErrors } : {}),
       ...(typeof summaryDoc.meta?.model === 'string'
         ? { model: summaryDoc.meta.model }
         : {}),
+      ...(typeof summaryDoc.meta?.agent === 'string'
+        ? { agent: summaryDoc.meta.agent }
+        : {}),
       ...(typeof summaryDoc.meta?.reasoning === 'string'
         ? { reasoning: summaryDoc.meta.reasoning }
         : {}),
@@ -1011,9 +1152,52 @@ function build() {
   return true;
 }
 
+function untrackedFileKind(stat) {
+  if (stat.isFile()) return 'file';
+  if (stat.isSymbolicLink()) return 'symlink';
+  if (stat.isDirectory()) return 'directory';
+  return 'other';
+}
+
+function fingerprintUntrackedPath(content, path) {
+  const absolutePath = resolve(repo, path);
+  const stat = lstatSync(absolutePath, { bigint: true });
+  content.update(path);
+  content.update('\0');
+  content.update(untrackedFileKind(stat));
+  content.update('\0');
+  content.update(String(stat.size));
+  content.update('\0');
+  content.update(String(stat.mtimeNs));
+  content.update('\0');
+  if (stat.isFile()) {
+    const descriptor = openSync(
+      absolutePath,
+      constants.O_RDONLY | constants.O_NOFOLLOW,
+    );
+    try {
+      const opened = fstatSync(descriptor, { bigint: true });
+      if (
+        !opened.isFile()
+        || opened.dev !== stat.dev
+        || opened.ino !== stat.ino
+      ) {
+        throw new Error(`${path} changed while its fingerprint was read`);
+      }
+      content.update(readFileSync(descriptor));
+    } finally {
+      closeSync(descriptor);
+    }
+    content.update('\0');
+  } else if (stat.isSymbolicLink()) {
+    content.update(readlinkSync(absolutePath));
+    content.update('\0');
+  }
+}
+
 function fingerprint() {
   let summariesTime = '';
-  if (!ignoreSummaryWatch) {
+  if (!ignoreSummaryWatch && !noSummaries) {
     try {
       summariesTime = String(statSync(summariesPath).mtimeMs);
     } catch {}
@@ -1026,9 +1210,26 @@ function fingerprint() {
       summariesTime,
     ].join('|');
   }
+  const content = createHash('sha256');
+  content.update(
+    tryRepo(['diff', '--no-ext-diff', '--no-textconv', '--binary', 'HEAD', '--']),
+  );
+  const untracked = tryRepo([
+    'ls-files',
+    '--others',
+    '--exclude-standard',
+    '-z',
+  ])
+    .split('\0')
+    .filter((path) => path && !excludedPaths.has(path))
+    .sort();
+  for (const path of untracked) {
+    fingerprintUntrackedPath(content, path);
+  }
   return [
     tryRepo(['rev-parse', 'HEAD']),
     tryRepo(['status', '--porcelain=v1', '--untracked-files=all']),
+    content.digest('hex'),
     summariesTime,
   ].join('|');
 }
@@ -1040,25 +1241,45 @@ const refresh = () => {
     return true;
   } catch (error) {
     console.error(error.message);
-    if (!watching) process.exitCode = 1;
+    process.exitCode = 1;
     return false;
   }
 };
 
 const started = refresh();
 if (watching && started) {
-  let last = fingerprint();
+  let last;
   let remoteWait = 0;
-  setInterval(() => {
-    const next = fingerprint();
-    remoteWait += 2_000;
-    const remoteDue = remoteMode && remoteWait >= 30_000;
-    if (next !== last || remoteDue) {
-      last = next;
-      remoteWait = 0;
-      refresh();
+  let watcher;
+  const stopWatching = (error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    if (watcher) clearInterval(watcher);
+  };
+  const poll = () => {
+    try {
+      const next = fingerprint();
+      if (last === undefined) {
+        last = next;
+        return true;
+      }
+      remoteWait += watchInterval;
+      const remoteDue = remoteMode && remoteWait >= remoteRefreshInterval;
+      if (next !== last || remoteDue || watchContent) {
+        last = next;
+        remoteWait = 0;
+        if (!refresh()) {
+          clearInterval(watcher);
+          return false;
+        }
+      }
+      return true;
+    } catch (error) {
+      stopWatching(error);
+      return false;
     }
-  }, 2_000);
+  };
+  if (poll()) watcher = setInterval(poll, watchInterval);
 } else if (watching) {
   process.exitCode = 1;
 }