Fixes.

Author: cpojer

bin/walkthrough-guide.md

@@ -39,10 +39,9 @@ choose.
 - **`support[]`** — changed hunks that should stay off the main path. Use it for generated files,
   lockfiles, snapshots, docs-only changes, and repeated mechanical edits unless they are essential
   to review. Codiff adds any omitted live-diff hunks to support. Generated-like files are one
-  synthetic hunk per changed section; never split them, use `reason: "Generated files"` for
-  generated-only support items so they render together, but keep behavior-relevant snapshots or
-  artifacts on the main path. Codiff also recognizes `linguist-generated` and `gitlab-generated`
-  attributes from `.gitattributes`.
+  synthetic hunk per changed section; never split them. Codiff groups generated-only support items
+  automatically, but keep behavior-relevant snapshots or artifacts on the main path. Codiff also
+  recognizes `linguist-generated` and `gitlab-generated` attributes from `.gitattributes`.
 - **`changeType?` / `commitNote?`** — optional commit composer metadata for committable
   walkthroughs.
 - **`commit?`** — for working-tree walkthroughs, include `title` and `body` when there is enough

core/__tests__/ReviewCodeView-scroll.test.tsx

@@ -172,6 +172,25 @@ test('generated files are collapsed by default and can be explicitly expanded pe
   }
 });
 
+test('explicit generated metadata can keep generated-looking paths expanded', async () => {
+  const file = {
+    ...createChangedFile('src/__generated__/api.ts'),
+    generated: false,
+  };
+  const view = await renderReact(<ReviewCodeViewHarness files={[file]} />);
+
+  try {
+    await waitFor(() => {
+      expect(
+        view.container.querySelector('[aria-label="Collapse file"]')?.getAttribute('aria-expanded'),
+      ).toBe('true');
+      expect(view.container.querySelector('.codiff-generated-badge')).toBeNull();
+    });
+  } finally {
+    await view.cleanup();
+  }
+});
+
 test('switching edited Markdown back to a diff flushes and refreshes it first', async () => {
   const order: Array<string> = [];
   const initialFile = createLoadedMarkdownFile('# Edited\n', 'plan.md:initial');

core/__tests__/git-state.test.ts

@@ -31,11 +31,11 @@ type PullRequestFileContent = {
 };
 
 type GeneratedFilesModule = {
-  readGeneratedAttributePaths: (
+  readGeneratedAttributeStates: (
     repoRoot: string,
     paths: ReadonlyArray<string>,
     source?: string,
-  ) => Promise<ReadonlySet<string>>;
+  ) => Promise<ReadonlyMap<string, boolean>>;
 };
 
 type GitStateModule = {
@@ -125,7 +125,7 @@ type GitStateModule = {
 
 const execFileAsync = promisify(execFile);
 const require = createRequire(import.meta.url);
-const { readGeneratedAttributePaths } =
+const { readGeneratedAttributeStates } =
   require('../../electron/generated-files.cjs') as GeneratedFilesModule;
 const {
   collectResolvedReviewCommentIds,
@@ -193,20 +193,22 @@ test('readRepositoryState marks generated files from gitattributes and path heur
     await writeRepoFile(
       repo,
       '.gitattributes',
-      '*.gen.yaml gitlab-generated\n*.generated.txt linguist-generated\nignored.txt -linguist-generated\n',
+      '*.gen.yaml gitlab-generated\n*.generated.txt linguist-generated\nignored.txt -linguist-generated\npnpm-lock.yaml linguist-generated=false\nsrc/__generated__/** -gitlab-generated\n',
     );
     await writeRepoFile(repo, 'service.gen.yaml', 'generated\n');
     await writeRepoFile(repo, 'schema.generated.txt', 'generated\n');
     await writeRepoFile(repo, 'ignored.txt', 'source\n');
     await writeRepoFile(repo, 'pnpm-lock.yaml', 'lockfileVersion: 9\n');
+    await writeRepoFile(repo, 'src/__generated__/api.ts', 'export const api = 1;\n');
 
     const state = await readRepositoryState(repo);
     const generatedByPath = new Map(state.files.map((file) => [file.path, file.generated]));
 
     expect(generatedByPath.get('service.gen.yaml')).toBe(true);
     expect(generatedByPath.get('schema.generated.txt')).toBe(true);
-    expect(generatedByPath.get('pnpm-lock.yaml')).toBe(true);
-    expect(generatedByPath.get('ignored.txt')).toBeUndefined();
+    expect(generatedByPath.get('pnpm-lock.yaml')).toBe(false);
+    expect(generatedByPath.get('src/__generated__/api.ts')).toBe(false);
+    expect(generatedByPath.get('ignored.txt')).toBe(false);
   });
 });
 
@@ -226,12 +228,21 @@ test('commit reviews evaluate generated attributes from the reviewed commit', as
 
 test('historical generated attributes fall back to a temporary index without --source', async () => {
   await withRepo(async (repo) => {
-    await writeRepoFile(repo, '.gitattributes', '*.api.ts linguist-generated\n');
+    await writeRepoFile(
+      repo,
+      '.gitattributes',
+      '*.api.ts linguist-generated\npnpm-lock.yaml linguist-generated=false\n',
+    );
     await writeRepoFile(repo, 'client.api.ts', 'export const client = 1;\n');
+    await writeRepoFile(repo, 'pnpm-lock.yaml', 'lockfileVersion: 9\n');
     await commitAll(repo, 'generated client');
     const commit = (await git(repo, ['rev-parse', 'HEAD'])).trim();
 
-    await writeRepoFile(repo, '.gitattributes', '*.api.ts -linguist-generated\n');
+    await writeRepoFile(
+      repo,
+      '.gitattributes',
+      '*.api.ts -linguist-generated\npnpm-lock.yaml linguist-generated\n',
+    );
     const wrapperDirectory = await mkdtemp(join(tmpdir(), 'codiff-old-git-'));
     const wrapperPath = join(wrapperDirectory, 'git');
     await writeFile(
@@ -255,8 +266,17 @@ exec git "$@"
     process.env.CODIFF_TEST_ORIGINAL_PATH = originalPath ?? '';
     process.env.PATH = `${wrapperDirectory}:${originalPath ?? ''}`;
     try {
-      const generatedPaths = await readGeneratedAttributePaths(repo, ['client.api.ts'], commit);
-      expect(generatedPaths).toEqual(new Set(['client.api.ts']));
+      const generatedStates = await readGeneratedAttributeStates(
+        repo,
+        ['client.api.ts', 'pnpm-lock.yaml'],
+        commit,
+      );
+      expect(generatedStates).toEqual(
+        new Map([
+          ['client.api.ts', true],
+          ['pnpm-lock.yaml', false],
+        ]),
+      );
     } finally {
       if (originalPath == null) {
         delete process.env.PATH;

core/lib/narrative-walkthrough-diff.cjs

@@ -82,7 +82,7 @@ const isGeneratedWalkthroughPath = (path) => {
 
 /** @param {{generated?: boolean; path: string}} file */
 const isGeneratedWalkthroughFile = (file) =>
-  file.generated === true || isGeneratedWalkthroughPath(file.path);
+  file.generated ?? isGeneratedWalkthroughPath(file.path);
 
 /** @param {string} path */
 const getGeneratedWalkthroughSummary = (path) => {

core/lib/narrative-walkthrough-diff.js

@@ -82,7 +82,7 @@ const isGeneratedWalkthroughPath = (path) => {
 
 /** @param {{generated?: boolean; path: string}} file */
 const isGeneratedWalkthroughFile = (file) =>
-  file.generated === true || isGeneratedWalkthroughPath(file.path);
+  file.generated ?? isGeneratedWalkthroughPath(file.path);
 
 /** @param {string} path */
 const getGeneratedWalkthroughSummary = (path) => {

electron/__tests__/narrative-walkthrough.test.ts

@@ -534,6 +534,33 @@ test('repository digest collapses generated files to one synthetic hunk', () =>
   expect(prompt).not.toContain('"id":"h2"');
 });
 
+test('repository digest honors generated metadata that disables path heuristics', () => {
+  const prompt = buildNarrativeWalkthroughPrompt({
+    branch: 'main',
+    files: [
+      {
+        generated: false,
+        path: 'pnpm-lock.yaml',
+        sections: [
+          {
+            id: 'pnpm-lock.yaml:staged',
+            kind: 'staged',
+            patch: manyHunkPatch,
+          },
+        ],
+        status: 'modified',
+      },
+    ],
+    generatedAt: 1,
+    root: '/repo',
+    source: { type: 'working-tree' },
+  });
+
+  expect(prompt).not.toContain('"generated":true');
+  expect(prompt).toContain('"kind":"patch"');
+  expect(prompt).toContain('"id":"h2"');
+});
+
 test('repository digest exposes synthetic hunk ids for non-text sections', () => {
   const prompt = buildNarrativeWalkthroughPrompt({
     branch: 'main',

electron/generated-files.cjs

@@ -12,6 +12,9 @@ const GENERATED_ATTRIBUTES = ['linguist-generated', 'gitlab-generated'];
 const isGeneratedAttributeValue = (value) =>
   value !== 'unspecified' && value !== 'unset' && value !== 'false';
 
+/** @param {string} value */
+const isNotGeneratedAttributeValue = (value) => value === 'unset' || value === 'false';
+
 /** @param {import('../core/types.ts').ReviewSource} source */
 const getGeneratedAttributeSource = (source) =>
   source.type === 'commit'
@@ -25,17 +28,19 @@ const getGeneratedAttributeSource = (source) =>
           : undefined;
 
 /** @param {Buffer} output */
-const parseGeneratedAttributePaths = (output) => {
+const parseGeneratedAttributeStates = (output) => {
   const fields = output.toString('utf8').split('\0');
-  const generatedPaths = new Set();
+  const generatedStates = new Map();
   for (let index = 0; index + 2 < fields.length; index += 3) {
     const path = fields[index];
     const value = fields[index + 2];
     if (path && isGeneratedAttributeValue(value)) {
-      generatedPaths.add(path);
+      generatedStates.set(path, true);
+    } else if (path && isNotGeneratedAttributeValue(value) && generatedStates.get(path) !== true) {
+      generatedStates.set(path, false);
     }
   }
-  return generatedPaths;
+  return generatedStates;
 };
 
 /**
@@ -44,8 +49,8 @@ const parseGeneratedAttributePaths = (output) => {
  * @param {ReadonlyArray<string>} options
  * @param {NodeJS.ProcessEnv} [env]
  */
-const checkGeneratedAttributePaths = async (repoRoot, paths, options, env) =>
-  parseGeneratedAttributePaths(
+const checkGeneratedAttributeStates = async (repoRoot, paths, options, env) =>
+  parseGeneratedAttributeStates(
     await gitBufferWithInput(
       repoRoot,
       ['check-attr', ...options, '-z', '--stdin', ...GENERATED_ATTRIBUTES],
@@ -63,7 +68,7 @@ const checkGeneratedAttributePaths = async (repoRoot, paths, options, env) =>
  * @param {ReadonlyArray<string>} paths
  * @param {string} source
  */
-const readGeneratedAttributePathsFromTree = async (repoRoot, paths, source) => {
+const readGeneratedAttributeStatesFromTree = async (repoRoot, paths, source) => {
   const temporaryDirectory = await mkdtemp(join(tmpdir(), 'codiff-generated-files-'));
   const env = {
     ...process.env,
@@ -72,7 +77,7 @@ const readGeneratedAttributePathsFromTree = async (repoRoot, paths, source) => {
 
   try {
     await gitBufferWithInput(repoRoot, ['read-tree', source], Buffer.alloc(0), { env });
-    return await checkGeneratedAttributePaths(repoRoot, paths, ['--cached'], env);
+    return await checkGeneratedAttributeStates(repoRoot, paths, ['--cached'], env);
   } finally {
     await rm(temporaryDirectory, { force: true, recursive: true });
   }
@@ -83,49 +88,60 @@ const readGeneratedAttributePathsFromTree = async (repoRoot, paths, source) => {
  * @param {ReadonlyArray<string>} paths
  * @param {string | undefined} source
  */
-const readGeneratedAttributePaths = async (repoRoot, paths, source) => {
+const readGeneratedAttributeStates = async (repoRoot, paths, source) => {
   if (paths.length === 0) {
-    return new Set();
+    return new Map();
   }
 
   try {
-    return await checkGeneratedAttributePaths(repoRoot, paths, source ? ['--source', source] : []);
+    return await checkGeneratedAttributeStates(repoRoot, paths, source ? ['--source', source] : []);
   } catch {
     if (source) {
       try {
         // Git before 2.40 rejects `--source`; use its historical-tree fallback.
-        return await readGeneratedAttributePathsFromTree(repoRoot, paths, source);
+        return await readGeneratedAttributeStatesFromTree(repoRoot, paths, source);
       } catch {
         // Ignore invalid or unavailable historical sources.
       }
     }
-    return new Set();
+    return new Map();
   }
 };
 
+/**
+ * @param {import('../core/types.ts').RepositoryState} state
+ * @param {ReadonlyMap<string, boolean>} generatedAttributeStates
+ */
+const applyGeneratedAttributeStates = (state, generatedAttributeStates) => ({
+  ...state,
+  files: state.files.map((file) => {
+    const attributeState = generatedAttributeStates.get(file.path);
+    if (attributeState != null) {
+      return file.generated === attributeState ? file : { ...file, generated: attributeState };
+    }
+    if (file.generated != null) {
+      return file;
+    }
+    return isGeneratedWalkthroughPath(file.path) ? { ...file, generated: true } : file;
+  }),
+});
+
 /** @param {import('../core/types.ts').RepositoryState} state */
-const annotateGeneratedFiles = async (state) => {
-  const generatedAttributePaths = await readGeneratedAttributePaths(
-    state.root,
-    state.files.map((file) => file.path),
-    getGeneratedAttributeSource(state.source),
-  );
-  return {
-    ...state,
-    files: state.files.map((file) =>
-      file.generated ||
-      generatedAttributePaths.has(file.path) ||
-      isGeneratedWalkthroughPath(file.path)
-        ? { ...file, generated: true }
-        : file,
+const annotateGeneratedFiles = async (state) =>
+  applyGeneratedAttributeStates(
+    state,
+    await readGeneratedAttributeStates(
+      state.root,
+      state.files.map((file) => file.path),
+      getGeneratedAttributeSource(state.source),
     ),
-  };
-};
+  );
 
 module.exports = {
   GENERATED_ATTRIBUTES,
   annotateGeneratedFiles,
+  applyGeneratedAttributeStates,
   getGeneratedAttributeSource,
   isGeneratedAttributeValue,
-  readGeneratedAttributePaths,
+  readGeneratedAttributeStates,
 };

electron/git-state.cjs

@@ -79,8 +79,16 @@ const readRepositoryState = async (launchPath, source = { type: 'working-tree' }
                 eagerContents: false,
                 showWhitespace: options.showWhitespace,
               });
-  const branch = (await gitOrEmpty(state.root, ['symbolic-ref', '--short', 'HEAD'])).trim() || null;
-  return annotateGeneratedFiles({ ...state, branch });
+  const comparisonState =
+    source.type === 'commit' ||
+    source.type === 'range' ||
+    source.type === 'branch' ||
+    source.type === 'branch-diff';
+  const [branch, annotatedState] = await Promise.all([
+    gitOrEmpty(state.root, ['symbolic-ref', '--short', 'HEAD']),
+    comparisonState ? state : annotateGeneratedFiles(state),
+  ]);
+  return { ...annotatedState, branch: branch.trim() || null };
 };
 
 /**