@oh-my-pi/pi-coding-agent 8.0.20 → 8.1.0

package/src/commit/git/diff.ts

@@ -0,0 +1,148 @@
+import type { DiffHunk, FileDiff, FileHunks, NumstatEntry } from "@oh-my-pi/pi-coding-agent/commit/types";
+
+export function parseNumstat(output: string): NumstatEntry[] {
+	const entries: NumstatEntry[] = [];
+	for (const line of output.split("\n")) {
+		if (!line.trim()) continue;
+		const parts = line.split("\t");
+		if (parts.length < 3) continue;
+		const [addedRaw, deletedRaw, pathRaw] = parts;
+		const additions = Number.parseInt(addedRaw, 10);
+		const deletions = Number.parseInt(deletedRaw, 10);
+		const path = extractPathFromRename(pathRaw);
+		entries.push({
+			path,
+			additions: Number.isNaN(additions) ? 0 : additions,
+			deletions: Number.isNaN(deletions) ? 0 : deletions,
+		});
+	}
+	return entries;
+}
+
+export function parseFileDiffs(diff: string): FileDiff[] {
+	const sections: FileDiff[] = [];
+	const parts = diff.split("\ndiff --git ");
+	for (let index = 0; index < parts.length; index += 1) {
+		const part = index === 0 ? parts[index] : `diff --git ${parts[index]}`;
+		if (!part.trim()) continue;
+		const lines = part.split("\n");
+		const header = lines[0] ?? "";
+		const match = header.match(/diff --git a\/(.+?) b\/(.+)$/);
+		if (!match) continue;
+		const filename = match[2];
+		const content = part;
+		const isBinary = lines.some((line) => line.startsWith("Binary files "));
+		let additions = 0;
+		let deletions = 0;
+		for (const line of lines) {
+			if (line.startsWith("+++") || line.startsWith("---")) continue;
+			if (line.startsWith("+")) additions += 1;
+			else if (line.startsWith("-")) deletions += 1;
+		}
+		sections.push({
+			filename,
+			content,
+			additions,
+			deletions,
+			isBinary,
+		});
+	}
+	return sections;
+}
+
+export function parseDiffHunks(diff: string): FileHunks[] {
+	const files = parseFileDiffs(diff);
+	return files.map((file) => parseFileHunks(file));
+}
+
+export function parseFileHunks(fileDiff: FileDiff): FileHunks {
+	if (fileDiff.isBinary) {
+		return { filename: fileDiff.filename, isBinary: true, hunks: [] };
+	}
+
+	const lines = fileDiff.content.split("\n");
+	const hunks: DiffHunk[] = [];
+	let current: DiffHunk | null = null;
+	let buffer: string[] = [];
+	let index = 0;
+
+	for (const line of lines) {
+		if (line.startsWith("@@")) {
+			if (current) {
+				current.content = buffer.join("\n");
+				hunks.push(current);
+			}
+			const headerData = parseHunkHeader(line);
+			current = {
+				index,
+				header: line,
+				oldStart: headerData.oldStart,
+				oldLines: headerData.oldLines,
+				newStart: headerData.newStart,
+				newLines: headerData.newLines,
+				content: "",
+			};
+			buffer = [line];
+			index += 1;
+			continue;
+		}
+		if (current) {
+			buffer.push(line);
+		}
+	}
+
+	if (current) {
+		current.content = buffer.join("\n");
+		hunks.push(current);
+	}
+
+	return {
+		filename: fileDiff.filename,
+		isBinary: fileDiff.isBinary,
+		hunks,
+	};
+}
+
+function extractPathFromRename(pathPart: string): string {
+	const braceStart = pathPart.indexOf("{");
+	if (braceStart !== -1) {
+		const arrowPos = pathPart.indexOf(" => ", braceStart);
+		if (arrowPos !== -1) {
+			const braceEnd = pathPart.indexOf("}", arrowPos);
+			if (braceEnd !== -1) {
+				const prefix = pathPart.slice(0, braceStart);
+				const newName = pathPart.slice(arrowPos + 4, braceEnd).trim();
+				return `${prefix}${newName}`;
+			}
+		}
+	}
+
+	if (pathPart.includes(" => ")) {
+		const parts = pathPart.split(" => ");
+		return parts[1]?.trim() ?? pathPart.trim();
+	}
+
+	return pathPart.trim();
+}
+
+function parseHunkHeader(line: string): {
+	oldStart: number;
+	oldLines: number;
+	newStart: number;
+	newLines: number;
+} {
+	const match = line.match(/@@\s-([0-9]+)(?:,([0-9]+))?\s\+([0-9]+)(?:,([0-9]+))?\s@@/);
+	if (!match) {
+		return { oldStart: 0, oldLines: 0, newStart: 0, newLines: 0 };
+	}
+	const oldStart = Number.parseInt(match[1] ?? "0", 10);
+	const oldLines = Number.parseInt(match[2] ?? "1", 10);
+	const newStart = Number.parseInt(match[3] ?? "0", 10);
+	const newLines = Number.parseInt(match[4] ?? "1", 10);
+	return {
+		oldStart: Number.isNaN(oldStart) ? 0 : oldStart,
+		oldLines: Number.isNaN(oldLines) ? 0 : oldLines,
+		newStart: Number.isNaN(newStart) ? 0 : newStart,
+		newLines: Number.isNaN(newLines) ? 0 : newLines,
+	};
+}

package/src/commit/git/errors.ts

@@ -0,0 +1,11 @@
+export class GitError extends Error {
+	readonly command: string;
+	readonly stderr: string;
+
+	constructor(command: string, stderr: string) {
+		super(`${command} failed: ${stderr || "unknown error"}`);
+		this.command = command;
+		this.stderr = stderr;
+		this.name = "GitError";
+	}
+}

package/src/commit/git/index.ts

@@ -0,0 +1,217 @@
+import { randomUUID } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	parseDiffHunks,
+	parseFileDiffs,
+	parseFileHunks,
+	parseNumstat,
+} from "@oh-my-pi/pi-coding-agent/commit/git/diff";
+import { GitError } from "@oh-my-pi/pi-coding-agent/commit/git/errors";
+import { commit, push, resetStaging, runGitCommand, stageFiles } from "@oh-my-pi/pi-coding-agent/commit/git/operations";
+import type { FileDiff, FileHunks, NumstatEntry } from "@oh-my-pi/pi-coding-agent/commit/types";
+import { logger } from "@oh-my-pi/pi-utils";
+
+export type HunkSelection = {
+	path: string;
+	hunks: { type: "all" } | { type: "indices"; indices: number[] } | { type: "lines"; start: number; end: number };
+};
+
+export class ControlledGit {
+	constructor(private readonly cwd: string) {}
+
+	async getDiff(staged: boolean): Promise<string> {
+		const args = staged ? ["diff", "--cached"] : ["diff"];
+		const result = await runGitCommand(this.cwd, args);
+		this.ensureSuccess(result, "git diff");
+		return result.stdout;
+	}
+
+	async getDiffForFiles(files: string[], staged = true): Promise<string> {
+		const args = staged ? ["diff", "--cached", "--", ...files] : ["diff", "--", ...files];
+		const result = await runGitCommand(this.cwd, args);
+		this.ensureSuccess(result, "git diff (files)");
+		return result.stdout;
+	}
+
+	async getChangedFiles(staged: boolean): Promise<string[]> {
+		const args = staged ? ["diff", "--cached", "--name-only"] : ["diff", "--name-only"];
+		const result = await runGitCommand(this.cwd, args);
+		this.ensureSuccess(result, "git diff --name-only");
+		return result.stdout
+			.split("\n")
+			.map((line) => line.trim())
+			.filter(Boolean);
+	}
+
+	async getStat(staged: boolean): Promise<string> {
+		const args = staged ? ["diff", "--cached", "--stat"] : ["diff", "--stat"];
+		const result = await runGitCommand(this.cwd, args);
+		this.ensureSuccess(result, "git diff --stat");
+		return result.stdout;
+	}
+
+	async getStatForFiles(files: string[], staged = true): Promise<string> {
+		const args = staged ? ["diff", "--cached", "--stat", "--", ...files] : ["diff", "--stat", "--", ...files];
+		const result = await runGitCommand(this.cwd, args);
+		this.ensureSuccess(result, "git diff --stat (files)");
+		return result.stdout;
+	}
+
+	async getNumstat(staged: boolean): Promise<NumstatEntry[]> {
+		const args = staged ? ["diff", "--cached", "--numstat"] : ["diff", "--numstat"];
+		const result = await runGitCommand(this.cwd, args);
+		this.ensureSuccess(result, "git diff --numstat");
+		return parseNumstat(result.stdout);
+	}
+
+	async getRecentCommits(count: number): Promise<string[]> {
+		const result = await runGitCommand(this.cwd, ["log", `-n${count}`, "--pretty=format:%s"]);
+		this.ensureSuccess(result, "git log");
+		return result.stdout
+			.split("\n")
+			.map((line) => line.trim())
+			.filter(Boolean);
+	}
+
+	async getStagedFiles(): Promise<string[]> {
+		const result = await runGitCommand(this.cwd, ["diff", "--cached", "--name-only"]);
+		this.ensureSuccess(result, "git diff --cached --name-only");
+		return result.stdout
+			.split("\n")
+			.map((line) => line.trim())
+			.filter(Boolean);
+	}
+
+	async getUntrackedFiles(): Promise<string[]> {
+		const result = await runGitCommand(this.cwd, ["ls-files", "--others", "--exclude-standard"]);
+		this.ensureSuccess(result, "git ls-files --others --exclude-standard");
+		return result.stdout
+			.split("\n")
+			.map((line) => line.trim())
+			.filter(Boolean);
+	}
+
+	async stageAll(): Promise<void> {
+		const result = await stageFiles(this.cwd, []);
+		this.ensureSuccess(result, "git add -A");
+	}
+
+	async stageFiles(files: string[]): Promise<void> {
+		const result = await stageFiles(this.cwd, files);
+		this.ensureSuccess(result, "git add");
+	}
+
+	async stageHunks(selections: HunkSelection[]): Promise<void> {
+		if (selections.length === 0) return;
+		const diff = await this.getDiff(false);
+		const fileDiffs = parseFileDiffs(diff);
+		const fileDiffMap = new Map(fileDiffs.map((entry) => [entry.filename, entry]));
+		const patchParts: string[] = [];
+		for (const selection of selections) {
+			const fileDiff = fileDiffMap.get(selection.path);
+			if (!fileDiff) {
+				throw new GitError("git apply --cached", `No diff found for ${selection.path}`);
+			}
+			if (fileDiff.isBinary) {
+				if (selection.hunks.type !== "all") {
+					throw new GitError("git apply --cached", `Cannot select hunks for binary file ${selection.path}`);
+				}
+				patchParts.push(fileDiff.content);
+				continue;
+			}
+
+			if (selection.hunks.type === "all") {
+				patchParts.push(fileDiff.content);
+				continue;
+			}
+
+			const fileHunks = parseFileHunks(fileDiff);
+			const selectedHunks = selectHunks(fileHunks, selection.hunks);
+			if (selectedHunks.length === 0) {
+				throw new GitError("git apply --cached", `No hunks selected for ${selection.path}`);
+			}
+			const header = extractFileHeader(fileDiff.content);
+			const filePatch = [header, ...selectedHunks.map((hunk) => hunk.content)].join("\n");
+			patchParts.push(filePatch);
+		}
+
+		const patch = joinPatch(patchParts);
+		if (!patch.trim()) return;
+		const tempPath = join(tmpdir(), `omp-hunks-${randomUUID()}.patch`);
+		try {
+			await Bun.write(tempPath, patch);
+			const result = await runGitCommand(this.cwd, ["apply", "--cached", "--binary", tempPath]);
+			this.ensureSuccess(result, "git apply --cached");
+		} finally {
+			await rm(tempPath, { force: true });
+		}
+	}
+
+	async resetStaging(files: string[] = []): Promise<void> {
+		const result = await resetStaging(this.cwd, files);
+		this.ensureSuccess(result, "git reset");
+	}
+
+	async commit(message: string): Promise<void> {
+		const result = await commit(this.cwd, message);
+		this.ensureSuccess(result, "git commit");
+	}
+
+	async push(): Promise<void> {
+		const result = await push(this.cwd);
+		this.ensureSuccess(result, "git push");
+	}
+
+	parseDiffFiles(diff: string): FileDiff[] {
+		return parseFileDiffs(diff);
+	}
+
+	parseDiffHunks(diff: string): FileHunks[] {
+		return parseDiffHunks(diff);
+	}
+
+	async getHunks(files: string[], staged = true): Promise<FileHunks[]> {
+		const diff = await this.getDiffForFiles(files, staged);
+		return this.parseDiffHunks(diff);
+	}
+
+	private ensureSuccess(result: { exitCode: number; stderr: string }, label: string): void {
+		if (result.exitCode !== 0) {
+			logger.error("commit git command failed", { label, stderr: result.stderr });
+			throw new GitError(label, result.stderr);
+		}
+	}
+}
+
+function extractFileHeader(diff: string): string {
+	const lines = diff.split("\n");
+	const headerLines: string[] = [];
+	for (const line of lines) {
+		if (line.startsWith("@@")) break;
+		headerLines.push(line);
+	}
+	return headerLines.join("\n");
+}
+
+function joinPatch(parts: string[]): string {
+	return parts
+		.map((part) => (part.endsWith("\n") ? part : `${part}\n`))
+		.join("\n")
+		.trimEnd()
+		.concat("\n");
+}
+
+function selectHunks(file: FileHunks, selector: HunkSelection["hunks"]): FileHunks["hunks"] {
+	if (selector.type === "indices") {
+		const wanted = new Set(selector.indices.map((value) => Math.max(1, Math.floor(value))));
+		return file.hunks.filter((hunk) => wanted.has(hunk.index + 1));
+	}
+	if (selector.type === "lines") {
+		const start = Math.floor(selector.start);
+		const end = Math.floor(selector.end);
+		return file.hunks.filter((hunk) => hunk.newStart <= end && hunk.newStart + hunk.newLines - 1 >= start);
+	}
+	return file.hunks;
+}

package/src/commit/git/operations.ts

@@ -0,0 +1,53 @@
+import { $ } from "bun";
+
+interface GitResult {
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+}
+
+export async function runGitCommand(cwd: string, args: string[]): Promise<GitResult> {
+	const result = await $`git ${args}`.cwd(cwd).quiet().nothrow();
+	const stdout = result.text();
+	const stderr = result.stderr?.toString() ?? "";
+	return {
+		exitCode: result.exitCode ?? 0,
+		stdout,
+		stderr,
+	};
+}
+
+export async function stageFiles(cwd: string, files: string[]): Promise<GitResult> {
+	const args = files.length === 0 ? ["add", "-A"] : ["add", "--", ...files];
+	return runGitCommand(cwd, args);
+}
+
+export async function resetStaging(cwd: string, files: string[]): Promise<GitResult> {
+	const args = files.length === 0 ? ["reset"] : ["reset", "--", ...files];
+	return runGitCommand(cwd, args);
+}
+
+export async function push(cwd: string): Promise<GitResult> {
+	return runGitCommand(cwd, ["push"]);
+}
+
+export async function commit(cwd: string, message: string): Promise<GitResult> {
+	const child = Bun.spawn(["git", "commit", "-F", "-"], {
+		cwd,
+		stdin: Buffer.from(message),
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(child.stdout).text(),
+		new Response(child.stderr).text(),
+		child.exited,
+	]);
+
+	return {
+		exitCode: exitCode ?? 0,
+		stdout: stdout.trim(),
+		stderr: stderr.trim(),
+	};
+}

package/src/commit/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Entry points for the omp commit command.
+ */
+
+export { runCommitCommand } from "@oh-my-pi/pi-coding-agent/commit/pipeline";

package/src/commit/map-reduce/index.ts

@@ -0,0 +1,63 @@
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { parseFileDiffs } from "@oh-my-pi/pi-coding-agent/commit/git/diff";
+import { runMapPhase } from "@oh-my-pi/pi-coding-agent/commit/map-reduce/map-phase";
+import { runReducePhase } from "@oh-my-pi/pi-coding-agent/commit/map-reduce/reduce-phase";
+import { estimateTokens } from "@oh-my-pi/pi-coding-agent/commit/map-reduce/utils";
+import type { ConventionalAnalysis } from "@oh-my-pi/pi-coding-agent/commit/types";
+import { isExcludedFile } from "@oh-my-pi/pi-coding-agent/commit/utils/exclusions";
+
+const MIN_FILES_FOR_MAP_REDUCE = 4;
+const MAX_FILE_TOKENS = 50_000;
+
+export interface MapReduceSettings {
+	enabled?: boolean;
+	minFiles?: number;
+	maxFileTokens?: number;
+	maxConcurrency?: number;
+	timeoutMs?: number;
+}
+
+export interface MapReduceInput {
+	model: Model<Api>;
+	apiKey: string;
+	smolModel: Model<Api>;
+	smolApiKey: string;
+	diff: string;
+	stat: string;
+	scopeCandidates: string;
+	typesDescription?: string;
+	settings?: MapReduceSettings;
+}
+
+export function shouldUseMapReduce(diff: string, settings?: MapReduceSettings): boolean {
+	if (process.env.OMP_COMMIT_MAP_REDUCE?.toLowerCase() === "false") return false;
+	if (settings?.enabled === false) return false;
+	const minFiles = settings?.minFiles ?? MIN_FILES_FOR_MAP_REDUCE;
+	const maxFileTokens = settings?.maxFileTokens ?? MAX_FILE_TOKENS;
+	const files = parseFileDiffs(diff).filter((file) => !isExcludedFile(file.filename));
+	const fileCount = files.length;
+	if (fileCount >= minFiles) return true;
+	return files.some((file) => estimateTokens(file.content) > maxFileTokens);
+}
+
+/**
+ * Run map-reduce analysis for large diffs using smol + primary models.
+ */
+
+export async function runMapReduceAnalysis(input: MapReduceInput): Promise<ConventionalAnalysis> {
+	const fileDiffs = parseFileDiffs(input.diff).filter((file) => !isExcludedFile(file.filename));
+	const observations = await runMapPhase({
+		model: input.smolModel,
+		apiKey: input.smolApiKey,
+		files: fileDiffs,
+		config: input.settings,
+	});
+	return runReducePhase({
+		model: input.model,
+		apiKey: input.apiKey,
+		observations,
+		stat: input.stat,
+		scopeCandidates: input.scopeCandidates,
+		typesDescription: input.typesDescription,
+	});
+}

package/src/commit/map-reduce/map-phase.ts

@@ -0,0 +1,193 @@
+import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import { completeSimple } from "@oh-my-pi/pi-ai";
+import { truncateToTokenLimit } from "@oh-my-pi/pi-coding-agent/commit/map-reduce/utils";
+import fileObserverSystemPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/file-observer-system.md" with {
+	type: "text",
+};
+import fileObserverUserPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/file-observer-user.md" with {
+	type: "text",
+};
+import type { FileDiff, FileObservation } from "@oh-my-pi/pi-coding-agent/commit/types";
+import { isExcludedFile } from "@oh-my-pi/pi-coding-agent/commit/utils/exclusions";
+import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
+
+const MAX_FILE_TOKENS = 50_000;
+const MAX_CONTEXT_FILES = 20;
+const MAX_CONCURRENCY = 5;
+const MAP_PHASE_TIMEOUT_MS = 120_000;
+const MAX_RETRIES = 3;
+const RETRY_BACKOFF_MS = 1000;
+
+export interface MapPhaseInput {
+	model: Model<Api>;
+	apiKey: string;
+	files: FileDiff[];
+	config?: {
+		maxFileTokens?: number;
+		maxConcurrency?: number;
+		timeoutMs?: number;
+		maxRetries?: number;
+		retryBackoffMs?: number;
+	};
+}
+
+export async function runMapPhase({ model, apiKey, files, config }: MapPhaseInput): Promise<FileObservation[]> {
+	const filtered = files.filter((file) => !isExcludedFile(file.filename));
+	const systemPrompt = renderPromptTemplate(fileObserverSystemPrompt);
+	const maxFileTokens = config?.maxFileTokens ?? MAX_FILE_TOKENS;
+	const maxConcurrency = config?.maxConcurrency ?? MAX_CONCURRENCY;
+	const timeoutMs = config?.timeoutMs ?? MAP_PHASE_TIMEOUT_MS;
+	const maxRetries = config?.maxRetries ?? MAX_RETRIES;
+	const retryBackoffMs = config?.retryBackoffMs ?? RETRY_BACKOFF_MS;
+	return runWithConcurrency(filtered, maxConcurrency, async (file) => {
+		if (file.isBinary) {
+			return {
+				file: file.filename,
+				observations: ["Binary file changed."],
+				additions: file.additions,
+				deletions: file.deletions,
+			};
+		}
+
+		const contextHeader = generateContextHeader(filtered, file.filename);
+		const truncated = truncateToTokenLimit(file.content, maxFileTokens);
+		const prompt = renderPromptTemplate(fileObserverUserPrompt, {
+			filename: file.filename,
+			diff: truncated,
+			context_header: contextHeader,
+		});
+
+		const response = await withRetry(
+			async () => {
+				const controller = new AbortController();
+				const timeout = setTimeout(() => controller.abort(), timeoutMs);
+				try {
+					return await completeSimple(
+						model,
+						{
+							systemPrompt: systemPrompt,
+							messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+						},
+						{ apiKey, maxTokens: 400, signal: controller.signal },
+					);
+				} finally {
+					clearTimeout(timeout);
+				}
+			},
+			maxRetries,
+			retryBackoffMs,
+		);
+
+		const observations = parseObservations(response);
+		return {
+			file: file.filename,
+			observations,
+			additions: file.additions,
+			deletions: file.deletions,
+		};
+	});
+}
+
+function parseObservations(message: AssistantMessage): string[] {
+	const text = message.content
+		.filter((content) => content.type === "text")
+		.map((content) => content.text)
+		.join("")
+		.trim();
+
+	if (!text) return [];
+
+	const lines = text
+		.split("\n")
+		.map((line) => line.trim())
+		.filter(Boolean)
+		.map((line) => line.replace(/^[-*]\s+/, ""))
+		.filter(Boolean);
+
+	return lines.slice(0, 5);
+}
+
+function generateContextHeader(files: FileDiff[], currentFile: string): string {
+	if (files.length > 100) {
+		return `(Large commit with ${files.length} total files)`;
+	}
+
+	const otherFiles = files.filter((file) => file.filename !== currentFile);
+	if (otherFiles.length === 0) return "";
+
+	const sorted = [...otherFiles].sort((a, b) => b.additions + b.deletions - (a.additions + a.deletions));
+	const toShow = sorted.length > MAX_CONTEXT_FILES ? sorted.slice(0, MAX_CONTEXT_FILES) : sorted;
+
+	const lines = ["OTHER FILES IN THIS CHANGE:"];
+	for (const file of toShow) {
+		const lineCount = file.additions + file.deletions;
+		const description = inferFileDescription(file);
+		lines.push(`- ${file.filename} (${lineCount} lines): ${description}`);
+	}
+
+	if (toShow.length < sorted.length) {
+		lines.push(`... and ${sorted.length - toShow.length} more files`);
+	}
+
+	return lines.join("\n");
+}
+
+function inferFileDescription(file: FileDiff): string {
+	const filenameLower = file.filename.toLowerCase();
+	if (filenameLower.includes("test")) return "test file";
+	if (filenameLower.endsWith(".md")) return "documentation";
+	if (
+		filenameLower.includes("config") ||
+		filenameLower.endsWith(".toml") ||
+		filenameLower.endsWith(".yaml") ||
+		filenameLower.endsWith(".yml")
+	) {
+		return "configuration";
+	}
+	if (filenameLower.includes("error")) return "error definitions";
+	if (filenameLower.includes("type")) return "type definitions";
+	if (filenameLower.endsWith("mod.rs") || filenameLower.endsWith("lib.rs")) return "module exports";
+	if (filenameLower.endsWith("main.rs") || filenameLower.endsWith("main.go") || filenameLower.endsWith("main.py")) {
+		return "entry point";
+	}
+
+	const content = file.content;
+	if (content.includes("interface ") || content.includes("type ")) return "type definitions";
+	if (content.includes("class ") || content.includes("function ") || content.includes("fn ")) return "implementation";
+	if (content.includes("async ") || content.includes("await")) return "async code";
+	return "source code";
+}
+
+async function runWithConcurrency<T, R>(
+	items: T[],
+	limit: number,
+	worker: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+	const results = new Array<R>(items.length);
+	let nextIndex = 0;
+	const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
+		while (true) {
+			const current = nextIndex;
+			nextIndex += 1;
+			if (current >= items.length) return;
+			results[current] = await worker(items[current] as T, current);
+		}
+	});
+	await Promise.all(runners);
+	return results;
+}
+
+async function withRetry<T>(fn: () => Promise<T>, attempts: number, backoffMs: number): Promise<T> {
+	let lastError: unknown;
+	for (let attempt = 0; attempt < attempts; attempt += 1) {
+		try {
+			return await fn();
+		} catch (error) {
+			lastError = error;
+			if (attempt < attempts - 1) {
+				await Bun.sleep(backoffMs * (attempt + 1));
+			}
+		}
+	}
+	throw lastError;
+}