octocode-cli 1.2.6 → 1.2.7

package/skills/octocode-code-engineer/src/analysis/dependency-summary.ts

@@ -0,0 +1,257 @@
+import { dependencyProfileToRecord } from './dependencies.js';
+import { isTestFile } from '../common/utils.js';
+
+import type {
+  AnalysisOptions,
+  CriticalPath,
+  Cycle,
+  DependencyState,
+  DependencySummary,
+  FileCriticality,
+  ModuleCount,
+  WalkResult,
+} from '../types/index.js';
+
+export function buildDependencySummary(
+  dependencyState: DependencyState,
+  fileCriticalityByPath: Map<string, FileCriticality>,
+  options: AnalysisOptions
+): DependencySummary {
+  const allFiles = [...dependencyState.files].sort();
+  let totalEdges = 0;
+  let unresolvedEdgeCount = 0;
+  const outgoingCounts: ModuleCount[] = [];
+  const inboundCounts: ModuleCount[] = [];
+
+  for (const file of allFiles) {
+    totalEdges += dependencyState.outgoing.get(file)?.size || 0;
+    const record = dependencyProfileToRecord(file, dependencyState);
+    const crit = fileCriticalityByPath.get(file) || { score: 1 };
+    outgoingCounts.push({
+      file,
+      count: record.outboundCount,
+      score: crit.score,
+    });
+    inboundCounts.push({ file, count: record.inboundCount, score: crit.score });
+    unresolvedEdgeCount += record.unresolvedDependencyCount;
+  }
+
+  const roots = allFiles.filter(file => {
+    const inCount = (dependencyState.incoming.get(file) || new Set()).size;
+    return inCount === 0;
+  });
+
+  const leaves = allFiles.filter(file => {
+    const outCount = (dependencyState.outgoing.get(file) || new Set()).size;
+    return outCount === 0;
+  });
+
+  const testOnlyModules = allFiles
+    .filter(file => !isTestFile(file))
+    .filter(file => {
+      const prodIn = dependencyState.incomingFromProduction.get(file);
+      const testIn = dependencyState.incomingFromTests.get(file);
+      return (!prodIn || prodIn.size === 0) && testIn && testIn.size > 0;
+    })
+    .map(file => ({
+      ...dependencyProfileToRecord(file, dependencyState),
+    }))
+    .sort((a, b) => a.file.localeCompare(b.file));
+
+  const criticalNodes = allFiles
+    .map(file => ({
+      ...dependencyProfileToRecord(file, dependencyState),
+      ...(fileCriticalityByPath.get(file) || ({} as Partial<FileCriticality>)),
+    }))
+    .filter(
+      node =>
+        (node.score || 0) > 12 ||
+        node.outboundCount > 5 ||
+        node.inboundCount > 8
+    )
+    .sort(
+      (a, b) =>
+        (b.score || 0) +
+        b.inboundCount * 0.8 +
+        b.outboundCount * 0.4 -
+        ((a.score || 0) + a.inboundCount * 0.8 + a.outboundCount * 0.4)
+    )
+    .slice(0, 150)
+    .map(node => ({
+      ...node,
+      score: Math.round(node.score || 0),
+      riskBand:
+        (node.score || 0) >= 60
+          ? 'high'
+          : (node.score || 0) >= 30
+            ? 'medium'
+            : 'low',
+    }));
+
+  const cycles = computeDependencyCycles(dependencyState);
+  const criticalPaths = computeDependencyCriticalPaths(
+    dependencyState,
+    fileCriticalityByPath,
+    options
+  );
+
+  return {
+    totalModules: allFiles.length,
+    totalEdges,
+    unresolvedEdgeCount,
+    externalDependencyFiles: [...dependencyState.externalCounts.keys()].length,
+    rootsCount: roots.length,
+    leavesCount: leaves.length,
+    roots: roots.slice(0, 20),
+    leaves: leaves.slice(0, 20),
+    criticalModules: criticalNodes.slice(
+      0,
+      20
+    ) as import('../types/index.js').CriticalModule[],
+    testOnlyModules: testOnlyModules.slice(0, 50),
+    unresolvedSample:
+      unresolvedEdgeCount > 0
+        ? [...dependencyState.unresolvedCounts.keys()].slice(0, 40)
+        : [],
+    outgoingTop: outgoingCounts.sort((a, b) => b.count - a.count).slice(0, 20),
+    inboundTop: inboundCounts.sort((a, b) => b.count - a.count).slice(0, 20),
+    cycles: cycles.slice(0, 20),
+    criticalPaths: criticalPaths.slice(0, Math.max(1, options.deepLinkTopN)),
+  };
+}
+
+export function computeDependencyCycles(
+  dependencyState: DependencyState
+): Cycle[] {
+  const cycles: Cycle[] = [];
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const activeStack: string[] = [];
+  const seenCycles = new Set<string>();
+
+  const canonicalizeCycle = (cyclePath: string[]): string => {
+    const rotated = [...cyclePath];
+    let best = rotated.slice();
+    for (let i = 1; i < rotated.length; i++) {
+      const candidate = [...rotated.slice(i), ...rotated.slice(0, i)];
+      if (candidate.join(' => ') < best.join(' => ')) {
+        best = candidate;
+      }
+    }
+    return best.join(' => ');
+  };
+
+  const visit = (node: string): void => {
+    if (visited.has(node)) return;
+    if (visiting.has(node)) return;
+
+    visiting.add(node);
+    activeStack.push(node);
+
+    const outgoing = dependencyState.outgoing.get(node) || new Set();
+    for (const dep of outgoing) {
+      const idx = activeStack.indexOf(dep);
+      if (idx !== -1) {
+        const rawCycle = [...activeStack.slice(idx), dep];
+        const normalized = canonicalizeCycle(rawCycle);
+        if (!seenCycles.has(normalized)) {
+          seenCycles.add(normalized);
+          cycles.push({
+            path: rawCycle,
+            nodeCount: rawCycle.length - 1,
+          });
+        }
+        continue;
+      }
+
+      if (dependencyState.files.has(dep)) {
+        visit(dep);
+      }
+    }
+
+    activeStack.pop();
+    visiting.delete(node);
+    visited.add(node);
+  };
+
+  for (const node of dependencyState.files) {
+    visit(node);
+  }
+
+  return cycles.sort((a, b) => b.nodeCount - a.nodeCount);
+}
+
+export function computeDependencyCriticalPaths(
+  dependencyState: DependencyState,
+  fileCriticalityByPath: Map<string, FileCriticality>,
+  options: AnalysisOptions
+): CriticalPath[] {
+  const memo = new Map<string, WalkResult>();
+  const visiting = new Set<string>();
+
+  const nodeScore = (file: string): number => {
+    const entry = fileCriticalityByPath.get(file);
+    return entry ? entry.score : 1;
+  };
+
+  const walk = (file: string): WalkResult => {
+    if (memo.has(file)) return memo.get(file)!;
+    if (visiting.has(file)) {
+      return {
+        path: [file],
+        score: nodeScore(file) * 0.5,
+        containsCycle: true,
+      };
+    }
+
+    visiting.add(file);
+    const edges = dependencyState.outgoing.get(file) || new Set();
+    let bestPath: WalkResult = {
+      path: [file],
+      score: nodeScore(file),
+      containsCycle: false,
+    };
+
+    for (const dep of edges) {
+      if (!dependencyState.files.has(dep)) continue;
+      const candidate = walk(dep);
+      const candidateScore = nodeScore(file) + candidate.score;
+      if (
+        candidateScore > bestPath.score ||
+        (candidateScore === bestPath.score &&
+          candidate.path.length > bestPath.path.length)
+      ) {
+        bestPath = {
+          path: [file, ...candidate.path],
+          score: candidateScore,
+          containsCycle: candidate.containsCycle,
+        };
+      }
+    }
+
+    visiting.delete(file);
+    memo.set(file, bestPath);
+    return bestPath;
+  };
+
+  const all: CriticalPath[] = [];
+  for (const file of dependencyState.files) {
+    const pathEntry = walk(file);
+    all.push({
+      start: file,
+      path: pathEntry.path,
+      score: Math.round(pathEntry.score),
+      length: pathEntry.path.length,
+      containsCycle: pathEntry.containsCycle,
+    });
+  }
+
+  return all
+    .filter(item => item.length > 1)
+    .sort((a, b) => {
+      const byScore = b.score - a.score;
+      if (byScore !== 0) return byScore;
+      return b.length - a.length;
+    })
+    .slice(0, Math.max(1, options.deepLinkTopN));
+}

package/skills/octocode-code-engineer/src/analysis/discovery.test.ts

@@ -0,0 +1,420 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  collectFiles,
+  fileSummaryWithFindings,
+  listWorkspacePackages,
+  safeRead,
+} from './discovery.js';
+import { DEFAULT_OPTS } from '../types/index.js';
+
+import type { AnalysisOptions, FileEntry } from '../types/index.js';
+
+describe('discovery', () => {
+  describe('collectFiles', () => {
+    let tmpDir: string;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'discovery-collect-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('collects .ts, .tsx, .js, .jsx, .mjs, .cjs files', () => {
+      fs.writeFileSync(path.join(tmpDir, 'a.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'b.tsx'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'c.js'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'd.jsx'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'e.mjs'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'f.cjs'), '', 'utf8');
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(6);
+      expect(files.some(f => f.endsWith('a.ts'))).toBe(true);
+      expect(files.some(f => f.endsWith('b.tsx'))).toBe(true);
+      expect(files.some(f => f.endsWith('c.js'))).toBe(true);
+      expect(files.some(f => f.endsWith('d.jsx'))).toBe(true);
+      expect(files.some(f => f.endsWith('e.mjs'))).toBe(true);
+      expect(files.some(f => f.endsWith('f.cjs'))).toBe(true);
+    });
+
+    it('skips .d.ts files', () => {
+      fs.writeFileSync(path.join(tmpDir, 'types.d.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'index.ts'), '', 'utf8');
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(1);
+      expect(files.some(f => f.endsWith('index.ts'))).toBe(true);
+      expect(files.some(f => f.endsWith('types.d.ts'))).toBe(false);
+    });
+
+    it('skips symlinks', () => {
+      const realFile = path.join(tmpDir, 'real.ts');
+      fs.writeFileSync(realFile, '', 'utf8');
+      fs.symlinkSync(realFile, path.join(tmpDir, 'link.ts'));
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(1);
+      expect(files.some(f => f.endsWith('real.ts'))).toBe(true);
+      expect(files.some(f => f.endsWith('link.ts'))).toBe(false);
+    });
+
+    it('skips directories in ignoreDirs', () => {
+      const skipDir = path.join(tmpDir, 'skipme');
+      fs.mkdirSync(skipDir, { recursive: true });
+      fs.writeFileSync(path.join(skipDir, 'nested.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'root.ts'), '', 'utf8');
+
+      const opts: AnalysisOptions = {
+        ...DEFAULT_OPTS,
+        root: tmpDir,
+        ignoreDirs: new Set(['skipme']),
+      };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(1);
+      expect(files.some(f => f.endsWith('root.ts'))).toBe(true);
+      expect(files.some(f => f.includes('skipme'))).toBe(false);
+    });
+
+    it('excludes test files when includeTests is false', () => {
+      fs.writeFileSync(path.join(tmpDir, 'foo.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'foo.test.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'foo.spec.ts'), '', 'utf8');
+      fs.mkdirSync(path.join(tmpDir, '__tests__'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, '__tests__', 'bar.ts'), '', 'utf8');
+
+      const opts: AnalysisOptions = {
+        ...DEFAULT_OPTS,
+        root: tmpDir,
+        includeTests: false,
+      };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(1);
+      expect(files.some(f => f.endsWith('foo.ts'))).toBe(true);
+      expect(files.some(f => f.endsWith('foo.test.ts'))).toBe(false);
+      expect(files.some(f => f.endsWith('foo.spec.ts'))).toBe(false);
+      expect(files.some(f => f.includes('__tests__'))).toBe(false);
+    });
+
+    it('includes test files when includeTests is true', () => {
+      fs.writeFileSync(path.join(tmpDir, 'foo.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'foo.test.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'foo.spec.ts'), '', 'utf8');
+      fs.mkdirSync(path.join(tmpDir, '__tests__'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, '__tests__', 'bar.ts'), '', 'utf8');
+
+      const opts: AnalysisOptions = {
+        ...DEFAULT_OPTS,
+        root: tmpDir,
+        includeTests: true,
+      };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(4);
+      expect(files.some(f => f.endsWith('foo.ts'))).toBe(true);
+      expect(files.some(f => f.endsWith('foo.test.ts'))).toBe(true);
+      expect(files.some(f => f.endsWith('foo.spec.ts'))).toBe(true);
+      expect(
+        files.some(f => f.includes('__tests__') && f.endsWith('bar.ts'))
+      ).toBe(true);
+    });
+
+    it('walks nested directories', () => {
+      fs.mkdirSync(path.join(tmpDir, 'src', 'utils'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'index.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'src', 'app.ts'), '', 'utf8');
+      fs.writeFileSync(
+        path.join(tmpDir, 'src', 'utils', 'helper.ts'),
+        '',
+        'utf8'
+      );
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(3);
+      expect(files.some(f => f.endsWith('index.ts'))).toBe(true);
+      expect(files.some(f => f.endsWith('app.ts'))).toBe(true);
+      expect(files.some(f => f.endsWith('helper.ts'))).toBe(true);
+    });
+
+    it('skips non-allowed extensions', () => {
+      fs.writeFileSync(path.join(tmpDir, 'a.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'b.txt'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'c.json'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'd.css'), '', 'utf8');
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(1);
+      expect(files.some(f => f.endsWith('a.ts'))).toBe(true);
+    });
+
+    it('handles empty directories', () => {
+      fs.mkdirSync(path.join(tmpDir, 'empty'), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, 'only.ts'), '', 'utf8');
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(1);
+      expect(files.some(f => f.endsWith('only.ts'))).toBe(true);
+    });
+
+    it('returns sorted file paths', () => {
+      fs.writeFileSync(path.join(tmpDir, 'z.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'a.ts'), '', 'utf8');
+      fs.writeFileSync(path.join(tmpDir, 'm.ts'), '', 'utf8');
+
+      const opts: AnalysisOptions = { ...DEFAULT_OPTS, root: tmpDir };
+      const files = collectFiles(tmpDir, opts);
+
+      expect(files).toHaveLength(3);
+      const basenames = files.map(f => path.basename(f));
+      expect(basenames).toEqual(
+        [...basenames].sort((a, b) => a.localeCompare(b))
+      );
+    });
+  });
+
+  describe('safeRead', () => {
+    let tmpDir: string;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'discovery-saferead-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('reads existing file content', () => {
+      const filePath = path.join(tmpDir, 'hello.ts');
+      const content = 'const x = 1;\nconsole.log(x);';
+      fs.writeFileSync(filePath, content, 'utf8');
+
+      expect(safeRead(filePath)).toBe(content);
+    });
+
+    it('returns null for non-existent file', () => {
+      const filePath = path.join(tmpDir, 'does-not-exist.ts');
+      expect(safeRead(filePath)).toBeNull();
+    });
+
+    it('returns null when given a directory path', () => {
+      const dirPath = path.join(tmpDir, 'adir');
+      fs.mkdirSync(dirPath, { recursive: true });
+
+      expect(safeRead(dirPath)).toBeNull();
+    });
+  });
+
+  describe('listWorkspacePackages', () => {
+    let tmpDir: string;
+    let packagesDir: string;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'discovery-packages-'));
+      packagesDir = path.join(tmpDir, 'packages');
+      fs.mkdirSync(packagesDir, { recursive: true });
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('lists packages with valid package.json', () => {
+      fs.mkdirSync(path.join(packagesDir, 'pkg-a'), { recursive: true });
+      fs.mkdirSync(path.join(packagesDir, 'pkg-b'), { recursive: true });
+      fs.writeFileSync(
+        path.join(packagesDir, 'pkg-a', 'package.json'),
+        JSON.stringify({ name: 'pkg-a' }),
+        'utf8'
+      );
+      fs.writeFileSync(
+        path.join(packagesDir, 'pkg-b', 'package.json'),
+        JSON.stringify({ name: 'pkg-b' }),
+        'utf8'
+      );
+
+      const packages = listWorkspacePackages(tmpDir, packagesDir);
+
+      expect(packages).toHaveLength(2);
+      expect(packages.map(p => p.name)).toContain('pkg-a');
+      expect(packages.map(p => p.name)).toContain('pkg-b');
+      expect(packages.map(p => p.folder)).toContain('pkg-a');
+      expect(packages.map(p => p.folder)).toContain('pkg-b');
+    });
+
+    it('skips directories without package.json', () => {
+      fs.mkdirSync(path.join(packagesDir, 'has-pkg'), { recursive: true });
+      fs.mkdirSync(path.join(packagesDir, 'no-pkg'), { recursive: true });
+      fs.writeFileSync(
+        path.join(packagesDir, 'has-pkg', 'package.json'),
+        JSON.stringify({ name: 'has-pkg' }),
+        'utf8'
+      );
+
+      const packages = listWorkspacePackages(tmpDir, packagesDir);
+
+      expect(packages).toHaveLength(1);
+      expect(packages[0].name).toBe('has-pkg');
+    });
+
+    it('skips invalid JSON in package.json', () => {
+      fs.mkdirSync(path.join(packagesDir, 'valid'), { recursive: true });
+      fs.mkdirSync(path.join(packagesDir, 'invalid'), { recursive: true });
+      fs.writeFileSync(
+        path.join(packagesDir, 'valid', 'package.json'),
+        JSON.stringify({ name: 'valid' }),
+        'utf8'
+      );
+      fs.writeFileSync(
+        path.join(packagesDir, 'invalid', 'package.json'),
+        '{ invalid json }',
+        'utf8'
+      );
+
+      const packages = listWorkspacePackages(tmpDir, packagesDir);
+
+      expect(packages).toHaveLength(1);
+      expect(packages[0].name).toBe('valid');
+    });
+
+    it('skips package.json without name field', () => {
+      fs.mkdirSync(path.join(packagesDir, 'no-name'), { recursive: true });
+      fs.writeFileSync(
+        path.join(packagesDir, 'no-name', 'package.json'),
+        JSON.stringify({ version: '1.0.0' }),
+        'utf8'
+      );
+
+      const packages = listWorkspacePackages(tmpDir, packagesDir);
+
+      expect(packages).toHaveLength(0);
+    });
+
+    it('returns sorted results by folder name', () => {
+      fs.mkdirSync(path.join(packagesDir, 'pkg-z'), { recursive: true });
+      fs.mkdirSync(path.join(packagesDir, 'pkg-a'), { recursive: true });
+      fs.mkdirSync(path.join(packagesDir, 'pkg-m'), { recursive: true });
+      fs.writeFileSync(
+        path.join(packagesDir, 'pkg-z', 'package.json'),
+        JSON.stringify({ name: 'pkg-z' }),
+        'utf8'
+      );
+      fs.writeFileSync(
+        path.join(packagesDir, 'pkg-a', 'package.json'),
+        JSON.stringify({ name: 'pkg-a' }),
+        'utf8'
+      );
+      fs.writeFileSync(
+        path.join(packagesDir, 'pkg-m', 'package.json'),
+        JSON.stringify({ name: 'pkg-m' }),
+        'utf8'
+      );
+
+      const packages = listWorkspacePackages(tmpDir, packagesDir);
+
+      expect(packages).toHaveLength(3);
+      expect(packages.map(p => p.folder)).toEqual(['pkg-a', 'pkg-m', 'pkg-z']);
+    });
+
+    it('returns empty array when packageRoot does not exist', () => {
+      const packages = listWorkspacePackages(
+        tmpDir,
+        path.join(tmpDir, 'nonexistent')
+      );
+      expect(packages).toEqual([]);
+    });
+  });
+
+  describe('fileSummaryWithFindings', () => {
+    function makeFileEntry(override: Partial<FileEntry> = {}): FileEntry {
+      return {
+        package: 'pkg',
+        file: 'src/file.ts',
+        parseEngine: 'typescript',
+        nodeCount: 1,
+        kindCounts: {},
+        functions: [],
+        flows: [],
+        dependencyProfile: {
+          internalDependencies: [],
+          externalDependencies: [],
+          unresolvedDependencies: [],
+          declaredExports: [],
+          importedSymbols: [],
+          reExports: [],
+        },
+        ...override,
+      };
+    }
+
+    it('merges issueIds into entries', () => {
+      const entries: FileEntry[] = [
+        makeFileEntry({ file: 'src/a.ts' }),
+        makeFileEntry({ file: 'src/b.ts' }),
+      ];
+      const byFile = new Map<string, string[]>([
+        ['src/a.ts', ['issue-1', 'issue-2']],
+        ['src/b.ts', ['issue-3']],
+      ]);
+
+      const result = fileSummaryWithFindings(entries, byFile);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].file).toBe('src/a.ts');
+      expect(result[0].issueIds).toEqual(['issue-1', 'issue-2']);
+      expect(result[1].file).toBe('src/b.ts');
+      expect(result[1].issueIds).toEqual(['issue-3']);
+    });
+
+    it('returns empty issueIds for entries without findings', () => {
+      const entries: FileEntry[] = [
+        makeFileEntry({ file: 'src/a.ts' }),
+        makeFileEntry({ file: 'src/b.ts' }),
+      ];
+      const byFile = new Map<string, string[]>([['src/a.ts', ['issue-1']]]);
+
+      const result = fileSummaryWithFindings(entries, byFile);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].issueIds).toEqual(['issue-1']);
+      expect(result[1].issueIds).toEqual([]);
+    });
+
+    it('handles empty byFile map', () => {
+      const entries: FileEntry[] = [makeFileEntry({ file: 'src/a.ts' })];
+      const byFile = new Map<string, string[]>();
+
+      const result = fileSummaryWithFindings(entries, byFile);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].issueIds).toEqual([]);
+    });
+
+    it('handles empty entries array', () => {
+      const byFile = new Map<string, string[]>([['src/a.ts', ['issue-1']]]);
+
+      const result = fileSummaryWithFindings([], byFile);
+
+      expect(result).toEqual([]);
+    });
+  });
+});