codedeep-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Danh Hung
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,177 @@
+# codedeep-mcp
+
+[![CI](https://github.com/planexhq/codedeep-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/planexhq/codedeep-mcp/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/codedeep-mcp.svg)](https://www.npmjs.com/package/codedeep-mcp)
+[![MCP spec](https://img.shields.io/badge/MCP_spec-2025--11--25-0a7ea4.svg)](https://modelcontextprotocol.io/specification/2025-11-25)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+[![node](https://img.shields.io/badge/node-%E2%89%A520-brightgreen.svg)](https://nodejs.org)
+
+An MCP server that gives AI coding agents structural understanding of codebases.
+
+**One tool call replaces 5-10 Grep-Read cycles.**
+
+codedeep-mcp parses your code with [tree-sitter](https://tree-sitter.github.io/tree-sitter/), builds a symbol index, and exposes 6 tools over the [Model Context Protocol](https://modelcontextprotocol.io/) that answer structural questions directly: find symbols, trace callers, assess blast radius, search by structure.
+
+## Why
+
+AI coding agents explore codebases with text tools (grep, file reads). This works but is expensive:
+
+- "Find all callers of X" requires 5+ grep-read cycles and returns false positives
+- "What breaks if I change this?" requires exhaustive manual search
+- Grep can't tell `user` the variable from `User` the class from `user()` the function
+
+codedeep-mcp solves this by parsing code into symbols and relationships, then answering structural questions in a single call.
+
+## Tools
+
+| Tool | Purpose | Example |
+|------|---------|---------|
+| `overview` | Orient in an unfamiliar codebase | Language breakdown, entry points, structure |
+| `find_symbol` | AST-aware symbol lookup | Find function by name — matches definitions, not text |
+| `get_context` | Full context for a symbol | Body + callers/callees + imports + co-change & complexity |
+| `find_references` | Cross-file usage search | Who calls this function, and from where? |
+| `impact` | Depth-N blast radius | Transitive upstream callers, grouped by hop |
+| `search_structure` | Keyword and structural search | Find by name/signature (all languages), or AST pattern (TS/JS) |
+
+## Quick Start
+
+### Claude Code
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "codedeep-mcp": {
+      "command": "npx",
+      "args": ["codedeep-mcp"]
+    }
+  }
+}
+```
+
+### Cursor / Windsurf / Other MCP Clients
+
+Any MCP client that supports stdio transport works. Configure it to run `npx codedeep-mcp`.
+
+> **Note:** `npx codedeep-mcp` is a stdio server — it won't produce visible
+> output when run directly. It communicates via JSON-RPC with the MCP client.
+
+## How It Works
+
+```
+Your Code  ──>  tree-sitter (parse)  ──>  In-Memory Index  ──>  MCP Tools
+                                               │
+                                          Git (optional)
+                                          LSP (planned)
+```
+
+**Structural index (always, instant):**
+tree-sitter parses every file into an AST. Symbols, call relationships,
+and imports are extracted and indexed in memory — with per-language call
+resolution tuned for precision (an explicit 0-wrong-kind-edge goal), not
+just text matching. Works on any repo with zero configuration.
+
+**Complexity metrics (all 14 languages):**
+Per-symbol cyclomatic and cognitive complexity, computed at index time and
+pinned for behavioral comparability to McCabe / the Cognitive Complexity
+whitepaper / open-source analyzers (SonarJS, sonar-java, gocyclo+gocognit,
+rust-code-analysis, …). Shown on `find_symbol` / `get_context`.
+
+**Git enrichment (when in a git repo):**
+Commit frequency identifies hotspot files; co-change analysis reveals
+behavioral coupling (files that change together); and a risk score
+(churn × coupling × complexity) ranks the most change-prone, tangled hubs.
+
+**Planned — LSP semantic tier:**
+LSP integration (tsserver, pyright, gopls, …) for compiler-precise
+cross-file references and type info is designed but **not yet shipped** —
+cross-file edges today are AST name-matches.
+
+## Example
+
+````
+> find_symbol({ name: "authenticate" })
+
+src/auth/middleware.ts:42-67 | function | exported
+async function authenticate(req: Request, res: Response, next: NextFunction): Promise<void>
+Validates the JWT token and attaches user to request
+References: ~5
+Fan-out: 2
+Complexity: cyc 3 / cog 1 [structural]
+
+> get_context({ file: "src/auth/middleware.ts", symbol: "authenticate" })
+
+src/auth/middleware.ts:42-67 | function | exported
+async function authenticate(req: Request, res: Response, next: NextFunction): Promise<void>
+Validates the JWT token and attaches user to request
+
+### Body
+```typescript
+async function authenticate(req: Request, res: Response, next: NextFunction): Promise<void> {
+  const token = extractToken(req);
+  const payload = verify(token);
+  req.user = payload as User;
+  next();
+}
+```
+
+### Callers
+- src/routes/api.ts:67 — handleRequest() [structural]
+- src/routes/webhook.ts:23 — verifyWebhook() [structural]
+
+(get_context also emits ### Callees and ### Coupling sections here, omitted for brevity)
+
+### Imports
+- jsonwebtoken: verify, decode
+- ./types: User, AuthToken
+
+### Co-change Partners (2 behavioral)
+- src/auth/types.ts  78% confidence (9 shared commits)
+- tests/auth.test.ts  64% confidence (7 shared commits)
+````
+
+## Supported Languages
+
+**14 languages**, each with tree-sitter symbol/reference extraction **and**
+cyclomatic + cognitive complexity:
+
+TypeScript / JS · Python · Java · Go · Rust · Swift · Kotlin · Dart · C# ·
+PHP · Ruby · C++ · C · Objective-C
+
+A planned LSP tier (see *How It Works*) will add compiler-precise cross-file
+resolution per language.
+
+## Configuration
+
+Optional `.codedeep/config.json` in your project root:
+
+```jsonc
+{
+  "exclude": ["vendor/**", "generated/**"],
+  "languages": ["typescript", "python"],
+  "maxFiles": 100000,
+  "maxFileSize": 1048576,
+  "watch": true,
+  "gitEnabled": true,
+  "gitWindow": 180
+}
+```
+
+All fields are optional. Works with no config file.
+
+Add `.codedeep/` to your `.gitignore` — the index cache is stored there.
+
+Environment variables: `CODEDEEP_CACHE_DIR`, `CODEDEEP_EXCLUDE`, `CODEDEEP_GIT`, `CODEDEEP_GIT_WINDOW`, `CODEDEEP_WATCH`, `CODEDEEP_DEBUG`.
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/config.js

@@ -0,0 +1,223 @@
+import { createHash } from 'node:crypto';
+import { constants as fsConstants, readFileSync } from 'node:fs';
+import { access, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { toPosix } from './indexer/scanner.js';
+import { errMsg, log } from './logger.js';
+const DEFAULT_EXCLUDES = [
+    'node_modules',
+    '.git',
+    '.codedeep',
+    '__pycache__',
+    '.venv',
+    'dist',
+    'build',
+    'vendor',
+    '.next',
+    '.nuxt',
+    'target',
+    '__generated__',
+    '*.min.js',
+    '*.bundle.js',
+];
+const DEFAULT_LANGUAGES = ['typescript', 'tsx', 'javascript', 'python', 'java', 'go', 'rust', 'swift', 'kotlin', 'dart', 'csharp', 'php', 'ruby', 'cpp', 'c', 'objc'];
+const DEFAULT_MAX_FILES = 100_000;
+const DEFAULT_MAX_FILE_SIZE = 1_048_576;
+const DEFAULT_GIT_WINDOW = 180;
+function readFileConfig(root) {
+    const path = join(root, '.codedeep', 'config.json');
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return {};
+        log.warn(`config: failed to read ${path}: ${err.message}; using defaults`);
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        log.warn(`config: failed to parse ${path}: ${err.message}; using defaults`);
+        return {};
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        log.warn(`config: ${path} is not a JSON object; using defaults`);
+        return {};
+    }
+    return parsed;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    if (!value.every((v) => typeof v === 'string'))
+        return undefined;
+    return value;
+}
+function asNonNegativeInt(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0)
+        return undefined;
+    return Math.floor(value);
+}
+// A 0-day git window is meaningless (empty analysis marked fresh), so the
+// git window requires >= 1, unlike maxFiles/maxFileSize where 0 is valid.
+function asPositiveInt(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 1)
+        return undefined;
+    return Math.floor(value);
+}
+function asNonBlankString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function asBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function parseEnvBool(name) {
+    const raw = process.env[name]?.trim().toLowerCase();
+    if (raw === undefined || raw === '')
+        return undefined;
+    if (raw === '0' || raw === 'false')
+        return false;
+    if (raw === '1' || raw === 'true')
+        return true;
+    log.warn(`config: ${name}=${raw} not recognized; expected 0/1/true/false`);
+    return undefined;
+}
+function parseEnvGitWindow() {
+    const raw = process.env.CODEDEEP_GIT_WINDOW?.trim();
+    if (raw === undefined || raw === '')
+        return undefined;
+    const parsed = asPositiveInt(Number(raw));
+    if (parsed === undefined) {
+        log.warn(`config: CODEDEEP_GIT_WINDOW=${raw} not recognized; expected a positive integer (days)`);
+    }
+    return parsed;
+}
+function parseEnvExclude() {
+    const raw = process.env.CODEDEEP_EXCLUDE;
+    if (!raw)
+        return [];
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+// When cacheDir lives inside projectRoot, the scanner must skip it.
+// Otherwise persist() bumps cache/index.json's mtime, the next
+// indexChanged() sees the divergence, re-indexes the cache, and writes
+// it again — a self-feeding loop. Push both `<rel>` (so walk()'s
+// dir-prune triggers) and `<rel>/**` (so file-level matchExclude in
+// scanner.ts and indexer.indexFile catches children of multi-segment
+// paths picomatch wouldn't auto-expand).
+function computeCacheDirExcludes(root, cacheDir) {
+    const rel = relative(root, cacheDir);
+    if (rel.length === 0)
+        return [];
+    if (rel === '..' || rel.startsWith(`..${sep}`))
+        return [];
+    if (isAbsolute(rel))
+        return [];
+    const posixRel = toPosix(rel);
+    return [posixRel, `${posixRel}/**`];
+}
+export function loadConfig(projectRoot = process.cwd()) {
+    const root = resolve(projectRoot);
+    const fileCfg = readFileConfig(root);
+    const fileExclude = asStringArray(fileCfg.exclude) ?? [];
+    const fileLanguages = asStringArray(fileCfg.languages);
+    const fileMaxFiles = asNonNegativeInt(fileCfg.maxFiles);
+    const fileMaxFileSize = asNonNegativeInt(fileCfg.maxFileSize);
+    const fileCacheDir = asNonBlankString(fileCfg.cacheDir);
+    const envCacheDir = asNonBlankString(process.env.CODEDEEP_CACHE_DIR);
+    const envExclude = parseEnvExclude();
+    const cacheDirRaw = envCacheDir ?? fileCacheDir ?? join(root, '.codedeep', 'cache');
+    const resolvedCacheDir = resolve(root, cacheDirRaw);
+    // cacheDir === root produces no excludes, so <root>/index.json is admitted
+    // as an unknown source and re-indexed on every save (loop). Other invalid
+    // inputs degrade to defaults; this one corrupts the index, so fail loud.
+    // Default path is structurally non-root, guard only explicit input.
+    if ((envCacheDir ?? fileCacheDir) && relative(root, resolvedCacheDir) === '') {
+        throw new Error(`cacheDir resolves to the project root (${resolvedCacheDir}); ` +
+            `set CODEDEEP_CACHE_DIR or .codedeep/config.json "cacheDir" to a subdirectory or external path`);
+    }
+    const cacheDirExcludes = computeCacheDirExcludes(root, resolvedCacheDir);
+    const merged = [
+        ...DEFAULT_EXCLUDES,
+        ...fileExclude,
+        ...envExclude,
+        ...cacheDirExcludes,
+    ]
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const exclude = Array.from(new Set(merged));
+    const cfg = {
+        projectRoot: root,
+        exclude: Object.freeze(exclude),
+        languages: Object.freeze(fileLanguages ?? [...DEFAULT_LANGUAGES]),
+        maxFiles: fileMaxFiles ?? DEFAULT_MAX_FILES,
+        maxFileSize: fileMaxFileSize ?? DEFAULT_MAX_FILE_SIZE,
+        cacheDir: resolvedCacheDir,
+        watch: parseEnvBool('CODEDEEP_WATCH') ?? asBoolean(fileCfg.watch) ?? true,
+        gitEnabled: parseEnvBool('CODEDEEP_GIT') ?? asBoolean(fileCfg.gitEnabled) ?? true,
+        gitWindow: parseEnvGitWindow() ?? asPositiveInt(fileCfg.gitWindow) ?? DEFAULT_GIT_WINDOW,
+    };
+    return Object.freeze(cfg);
+}
+export function defaultCacheDir(projectRoot) {
+    return resolve(projectRoot, '.codedeep', 'cache');
+}
+export function fallbackCacheDir(projectRoot) {
+    const hash = createHash('sha1').update(projectRoot).digest('hex').slice(0, 16);
+    return join(homedir(), '.cache', 'codedeep', hash);
+}
+// Ensures the configured cacheDir is writable. When the path equals the
+// project-default and is not usable (read-only repo, EROFS mount, or a
+// `.codedeep`-is-a-file FS conflict), falls back silently to
+// ~/.cache/codedeep/<sha1(projectRoot)>/. Explicit user overrides fail loudly
+// so they know their CODEDEEP_CACHE_DIR / cacheDir is broken instead of being
+// silently ignored.
+export async function resolveCacheDir(config) {
+    const isDefault = config.cacheDir === defaultCacheDir(config.projectRoot);
+    try {
+        await mkdir(config.cacheDir, { recursive: true });
+        // mkdir({recursive:true}) is idempotent, so a pre-existing cacheDir can
+        // slip through with restrictive permissions. Probe W+X explicitly:
+        // creating files inside a dir requires both bits per POSIX, so W alone
+        // admits modes like 0o200 / 0o600 where open(O_CREAT) still fails.
+        await access(config.cacheDir, fsConstants.W_OK | fsConstants.X_OK);
+        return config.cacheDir;
+    }
+    catch (err) {
+        const code = err?.code;
+        // ENOTDIR/EEXIST cover default-path FS conflicts (e.g. `.codedeep` is a
+        // regular file). Explicit overrides still throw so misconfig surfaces.
+        const canFallback = code === 'EACCES' ||
+            code === 'EROFS' ||
+            code === 'EPERM' ||
+            code === 'ENOTDIR' ||
+            code === 'EEXIST';
+        if (!canFallback || !isDefault)
+            throw err;
+        const fallback = fallbackCacheDir(config.projectRoot);
+        log.warn(`config: ${config.cacheDir} not usable (${code}); falling back to ${fallback}`);
+        try {
+            await mkdir(fallback, { recursive: true });
+            await access(fallback, fsConstants.W_OK | fsConstants.X_OK);
+        }
+        catch (fallbackErr) {
+            const wrapped = new Error(`Cache fallback ${fallback} is also not writable: ${errMsg(fallbackErr)}. ` +
+                `Set CODEDEEP_CACHE_DIR to a writable directory.`);
+            wrapped.code = fallbackErr?.code;
+            wrapped.cause = fallbackErr;
+            throw wrapped;
+        }
+        return fallback;
+    }
+}

package/dist/git/analyzer.js

@@ -0,0 +1,177 @@
+// The bulk git-log pass: one parse of `git log --name-only` output builds
+// BOTH per-file commit counts (hotspots / commitFrequency) and the
+// co-change pair matrix. Pure functions, no I/O — the GitService owns the
+// subprocess; tests feed canned stdout strings.
+//
+// Output format contract (verified against real git):
+//   --pretty=format:%x00%ct --name-only
+// emits, per commit, a NUL byte, the committer epoch-seconds, a newline,
+// then one path per line (blank-line separated from the next record):
+//   \0<epoch>\n<path>\n<path>\n\n\0<epoch>\n<path>\n
+// NUL can never appear in %ct output or in a path line, so splitting
+// stdout on NUL yields exactly one chunk per commit. We deliberately do
+// NOT print %H or %s: this pass needs only boundaries and timestamps,
+// and omitting the subject removes the entire weird-subject parsing
+// class. core.quotepath=false (prepended by GitRunner) keeps non-ASCII
+// paths literal; a pathological newline-containing filename just becomes
+// a non-matching line that the membership filters discard.
+import { posix } from 'node:path';
+import { log } from '../logger.js';
+// Delegated to git via --max-count; also asserted parse-side so a huge
+// repo can't blow the pair map regardless of what git returns.
+export const GIT_COMMIT_CAP = 10_000;
+// Commits touching more than this many files (vendored-dep updates, mass
+// renames, formatting sweeps) are skipped ENTIRELY — both for pairs and
+// for counts. Using one filtered stream for numerators AND denominators
+// keeps confidence <= 1 as an invariant.
+export const MAX_FILES_PER_COMMIT = 30;
+// A pair must share at least this many commits to register as coupling.
+export const MIN_SHARED_COMMITS = 3;
+// Per-file partner lists are truncated to this many strongest partners
+// to bound persisted cache size.
+export const COCHANGES_PER_FILE_CAP = 20;
+// Tools render top 10; the extra headroom serves the search boost and
+// survives files dropping out of the index between analyses.
+export const HOTSPOTS_KEPT = 50;
+// Bounds transient memory for the pair accumulation (worst case ~40 MB).
+// git log is newest-first, so when the cap hits, the most recent (most
+// relevant) pairs are already in the map; we stop inserting NEW keys but
+// keep incrementing existing ones.
+const PAIR_MAP_CAP = 250_000;
+export function buildLogArgs(windowDays, now = Date.now()) {
+    const since = new Date(now - windowDays * 86_400_000).toISOString();
+    return [
+        'log',
+        '--no-merges',
+        // Rename detection is heuristic and git-version-dependent; with it
+        // disabled a rename is a plain delete+add, so the old path simply
+        // stops accruing and the new path starts fresh. Deterministic.
+        '--no-renames',
+        '--name-only',
+        `--max-count=${GIT_COMMIT_CAP}`,
+        `--since=${since}`,
+        '--pretty=format:%x00%ct',
+    ];
+}
+// `pathPrefix` handles project roots that are a SUBDIRECTORY of the git
+// toplevel (monorepo packages): git log emits repo-relative paths
+// ('packages/app/src/x.ts') while index keys are project-relative
+// ('src/x.ts'). Paths under the prefix are stripped to index-relative;
+// paths OUTSIDE it are rewritten project-relative too ('../'-prefixed
+// via posix.relative) — index keys never start with '..', so an outside
+// file like the toplevel package.json can never collide with the
+// package's own package.json key (it would silently merge counts and
+// fabricate co-change pairs otherwise). Outside paths only ever serve
+// as confidence denominators and partner values.
+// Pass '' (the default) when the project root IS the toplevel.
+export function analyzeLog(stdout, isIndexed, pathPrefix = '') {
+    const counts = new Map();
+    const pairs = new Map();
+    let commitCount = 0;
+    let pairCapWarned = false;
+    for (const chunk of stdout.split('\u0000')) {
+        if (commitCount >= GIT_COMMIT_CAP)
+            break;
+        if (chunk.length === 0)
+            continue; // leading separator before the first record
+        const lines = chunk.split('\n');
+        const timestampSec = Number(lines[0]?.trim());
+        if (!Number.isFinite(timestampSec))
+            continue; // garbled record — drop, never throw
+        const timestampMs = timestampSec * 1000;
+        const files = new Set();
+        for (let i = 1; i < lines.length; i++) {
+            let path = lines[i].replace(/\r$/, '');
+            if (path.length === 0)
+                continue;
+            if (pathPrefix.length > 0) {
+                path = path.startsWith(pathPrefix)
+                    ? path.slice(pathPrefix.length)
+                    : posix.relative(pathPrefix, path);
+            }
+            if (path.length > 0)
+                files.add(path);
+        }
+        if (files.size === 0)
+            continue; // empty commit
+        if (files.size > MAX_FILES_PER_COMMIT)
+            continue;
+        commitCount++;
+        for (const path of files) {
+            counts.set(path, (counts.get(path) ?? 0) + 1);
+        }
+        const sorted = [...files].sort();
+        // Hoisted out of the O(k²) pair loop: per-pair isIndexed calls would
+        // re-resolve each path up to k-1 times.
+        const indexedFlags = sorted.map(isIndexed);
+        for (let i = 0; i < sorted.length; i++) {
+            for (let j = i + 1; j < sorted.length; j++) {
+                if (!indexedFlags[i] && !indexedFlags[j])
+                    continue;
+                const key = `${sorted[i]}\u0000${sorted[j]}`;
+                const existing = pairs.get(key);
+                if (existing) {
+                    existing.shared++;
+                }
+                else if (pairs.size < PAIR_MAP_CAP) {
+                    // Newest-first log order: first sighting IS the most recent.
+                    pairs.set(key, { shared: 1, lastSeen: timestampMs });
+                }
+                else if (!pairCapWarned) {
+                    pairCapWarned = true;
+                    log.debug(`git: co-change pair map hit ${PAIR_MAP_CAP} entries; older pairs ignored`);
+                }
+            }
+        }
+    }
+    const cochanges = new Map();
+    for (const [key, accum] of pairs) {
+        if (accum.shared < MIN_SHARED_COMMITS)
+            continue;
+        const sep = key.indexOf('\u0000');
+        const fileA = key.slice(0, sep);
+        const fileB = key.slice(sep + 1);
+        const commitsA = counts.get(fileA);
+        const commitsB = counts.get(fileB);
+        if (!commitsA || !commitsB)
+            continue; // defensive; both sides were counted
+        const record = {
+            fileA,
+            fileB,
+            sharedCommits: accum.shared,
+            confidenceAB: accum.shared / commitsA,
+            confidenceBA: accum.shared / commitsB,
+            lastSeen: accum.lastSeen,
+        };
+        if (isIndexed(fileA))
+            pushTo(cochanges, fileA, record);
+        if (isIndexed(fileB))
+            pushTo(cochanges, fileB, record);
+    }
+    for (const [path, list] of cochanges) {
+        list.sort((a, b) => b.sharedCommits - a.sharedCommits ||
+            comparePaths(partnerOf(a, path), partnerOf(b, path)));
+        if (list.length > COCHANGES_PER_FILE_CAP) {
+            cochanges.set(path, list.slice(0, COCHANGES_PER_FILE_CAP));
+        }
+    }
+    const hotspots = [...counts.entries()]
+        .filter(([path]) => isIndexed(path))
+        .sort((a, b) => b[1] - a[1] || comparePaths(a[0], b[0]))
+        .slice(0, HOTSPOTS_KEPT)
+        .map(([path]) => path);
+    return { counts, cochanges, hotspots, commitCount };
+}
+export function partnerOf(record, selfPath) {
+    return record.fileA === selfPath ? record.fileB : record.fileA;
+}
+function comparePaths(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function pushTo(map, key, value) {
+    const list = map.get(key);
+    if (list)
+        list.push(value);
+    else
+        map.set(key, [value]);
+}