@wahack/pi-coding-agent 15.11.0

package/src/commit/changelog/index.ts

@@ -0,0 +1,234 @@
+import * as path from "node:path";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
+import { CHANGELOG_CATEGORIES } from "../../commit/types";
+import * as git from "../../utils/git";
+import { detectChangelogBoundaries } from "./detect";
+import { generateChangelogEntries } from "./generate";
+import { parseUnreleasedSection } from "./parse";
+
+const CHANGELOG_SECTIONS = CHANGELOG_CATEGORIES;
+
+const DEFAULT_MAX_DIFF_CHARS = 120_000;
+
+export interface ChangelogFlowInput {
+	cwd: string;
+	model: Model<Api>;
+	apiKey: ApiKey;
+	thinkingLevel?: ThinkingLevel;
+	stagedFiles: string[];
+	dryRun: boolean;
+	maxDiffChars?: number;
+	onProgress?: (message: string) => void;
+}
+
+export interface ChangelogProposalInput {
+	cwd: string;
+	proposals: Array<{
+		path: string;
+		entries: Record<string, string[]>;
+		deletions?: Record<string, string[]>;
+	}>;
+	dryRun: boolean;
+	onProgress?: (message: string) => void;
+}
+
+/**
+ * Update CHANGELOG.md entries for staged changes.
+ */
+export async function runChangelogFlow({
+	cwd,
+	model,
+	apiKey,
+	thinkingLevel,
+	stagedFiles,
+	dryRun,
+	maxDiffChars,
+	onProgress,
+}: ChangelogFlowInput): Promise<string[]> {
+	if (stagedFiles.length === 0) return [];
+	onProgress?.("Detecting changelog boundaries...");
+	const boundaries = await detectChangelogBoundaries(cwd, stagedFiles);
+	if (boundaries.length === 0) return [];
+
+	const updated: string[] = [];
+	for (const boundary of boundaries) {
+		onProgress?.(`Generating entries for ${boundary.changelogPath}…`);
+		const diff = await git.diff(cwd, { cached: true, files: boundary.files });
+		if (!diff.trim()) continue;
+		const stat = await git.diff(cwd, { stat: true, cached: true, files: boundary.files });
+		const diffForPrompt = truncateDiff(diff, maxDiffChars ?? DEFAULT_MAX_DIFF_CHARS);
+		const changelogContent = await Bun.file(boundary.changelogPath).text();
+		let unreleased: { startLine: number; endLine: number; entries: Record<string, string[]> };
+		try {
+			unreleased = parseUnreleasedSection(changelogContent);
+		} catch (error) {
+			logger.warn("commit changelog parse skipped", { path: boundary.changelogPath, error: String(error) });
+			continue;
+		}
+		const existingEntries = formatExistingEntries(unreleased.entries);
+		const isPackageChangelog = path.resolve(boundary.changelogPath) !== path.resolve(cwd, "CHANGELOG.md");
+		const generated = await generateChangelogEntries({
+			model,
+			apiKey,
+			thinkingLevel,
+			changelogPath: boundary.changelogPath,
+			isPackageChangelog,
+			existingEntries: existingEntries || undefined,
+			stat,
+			diff: diffForPrompt,
+		});
+		if (Object.keys(generated.entries).length === 0) continue;
+
+		const updatedContent = applyChangelogEntries(changelogContent, unreleased, generated.entries);
+		if (!dryRun) {
+			await Bun.write(boundary.changelogPath, updatedContent);
+			await git.stage.files(cwd, [path.relative(cwd, boundary.changelogPath)]);
+		}
+		updated.push(boundary.changelogPath);
+	}
+
+	return updated;
+}
+
+/**
+ * Apply changelog entries provided by the commit agent.
+ */
+export async function applyChangelogProposals({
+	cwd,
+	proposals,
+	dryRun,
+	onProgress,
+}: ChangelogProposalInput): Promise<string[]> {
+	const updated: string[] = [];
+	for (const proposal of proposals) {
+		if (
+			Object.keys(proposal.entries).length === 0 &&
+			(!proposal.deletions || Object.keys(proposal.deletions).length === 0)
+		)
+			continue;
+		onProgress?.(`Applying entries for ${proposal.path}…`);
+		const exists = await Bun.file(proposal.path).exists();
+		if (!exists) {
+			logger.warn("commit changelog path missing", { path: proposal.path });
+			continue;
+		}
+		const changelogContent = await Bun.file(proposal.path).text();
+		let unreleased: { startLine: number; endLine: number; entries: Record<string, string[]> };
+		try {
+			unreleased = parseUnreleasedSection(changelogContent);
+		} catch (error) {
+			logger.warn("commit changelog parse skipped", { path: proposal.path, error: String(error) });
+			continue;
+		}
+		const normalized = normalizeEntries(proposal.entries);
+		const normalizedDeletions = proposal.deletions ? normalizeEntries(proposal.deletions) : undefined;
+		if (Object.keys(normalized).length === 0 && !normalizedDeletions) continue;
+		const updatedContent = applyChangelogEntries(changelogContent, unreleased, normalized, normalizedDeletions);
+		if (!dryRun) {
+			await Bun.write(proposal.path, updatedContent);
+			await git.stage.files(cwd, [path.relative(cwd, proposal.path)]);
+		}
+		updated.push(proposal.path);
+	}
+
+	return updated;
+}
+
+function truncateDiff(diff: string, maxChars: number): string {
+	if (diff.length <= maxChars) return diff;
+	return `${diff.slice(0, maxChars)}\n... (truncated)`;
+}
+
+function formatExistingEntries(entries: Record<string, string[]>): string {
+	const lines: string[] = [];
+	for (const section of CHANGELOG_SECTIONS) {
+		const values = entries[section] ?? [];
+		if (values.length === 0) continue;
+		lines.push(`${section}:`);
+		for (const value of values) {
+			lines.push(`- ${value}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+function applyChangelogEntries(
+	content: string,
+	unreleased: { startLine: number; endLine: number; entries: Record<string, string[]> },
+	entries: Record<string, string[]>,
+	deletions?: Record<string, string[]>,
+): string {
+	const lines = content.split("\n");
+	const before = lines.slice(0, unreleased.startLine + 1);
+	const after = lines.slice(unreleased.endLine);
+
+	let base = unreleased.entries;
+	if (deletions) {
+		base = applyDeletions(base, deletions);
+	}
+	const merged = mergeEntries(base, entries);
+	const sectionLines = renderUnreleasedSections(merged);
+	return [...before, ...sectionLines, ...after].join("\n");
+}
+
+function applyDeletions(
+	existing: Record<string, string[]>,
+	deletions: Record<string, string[]>,
+): Record<string, string[]> {
+	const result: Record<string, string[]> = {};
+	for (const [section, items] of Object.entries(existing)) {
+		const toDelete = new Set((deletions[section] ?? []).map(d => d.toLowerCase()));
+		const filtered = items.filter(item => !toDelete.has(item.toLowerCase()));
+		if (filtered.length > 0) {
+			result[section] = filtered;
+		}
+	}
+	return result;
+}
+
+function mergeEntries(
+	existing: Record<string, string[]>,
+	incoming: Record<string, string[]>,
+): Record<string, string[]> {
+	const merged: Record<string, string[]> = { ...existing };
+	for (const [section, items] of Object.entries(incoming)) {
+		const current = merged[section] ?? [];
+		const lower = new Set(current.map(item => item.toLowerCase()));
+		for (const item of items) {
+			if (!lower.has(item.toLowerCase())) {
+				current.push(item);
+			}
+		}
+		merged[section] = current;
+	}
+	return merged;
+}
+
+function renderUnreleasedSections(entries: Record<string, string[]>): string[] {
+	const lines: string[] = [""];
+	for (const section of CHANGELOG_SECTIONS) {
+		const items = entries[section] ?? [];
+		if (items.length === 0) continue;
+		lines.push(`### ${section}`);
+		for (const item of items) {
+			lines.push(`- ${item}`);
+		}
+		lines.push("");
+	}
+	if (lines[lines.length - 1] === "") {
+		lines.pop();
+	}
+	return lines;
+}
+
+function normalizeEntries(entries: Record<string, string[]>): Record<string, string[]> {
+	const result: Record<string, string[]> = {};
+	for (const [section, items] of Object.entries(entries)) {
+		const trimmed = items.map(item => item.trim().replace(/\.$/, "")).filter(item => item.length > 0);
+		if (trimmed.length === 0) continue;
+		result[section] = Array.from(new Set(trimmed.map(item => item.trim())));
+	}
+	return result;
+}

package/src/commit/changelog/parse.ts

@@ -0,0 +1,44 @@
+import type { UnreleasedSection } from "../../commit/types";
+
+const UNRELEASED_PATTERN = /^##\s+\[?Unreleased\]?/i;
+const SECTION_PATTERN = /^###\s+(.*)$/;
+
+export function parseUnreleasedSection(content: string): UnreleasedSection {
+	const lines = content.split("\n");
+	const startIndex = lines.findIndex(line => UNRELEASED_PATTERN.test(line.trim()));
+	if (startIndex === -1) {
+		throw new Error("No [Unreleased] section found in changelog");
+	}
+
+	let endIndex = lines.length;
+	for (let i = startIndex + 1; i < lines.length; i += 1) {
+		if (lines[i]?.startsWith("## ")) {
+			endIndex = i;
+			break;
+		}
+	}
+
+	const sectionLines = lines.slice(startIndex + 1, endIndex);
+	const entries: Record<string, string[]> = {};
+	let currentSection: string | null = null;
+	for (const line of sectionLines) {
+		const sectionMatch = line.match(SECTION_PATTERN);
+		if (sectionMatch) {
+			currentSection = sectionMatch[1]?.trim() || null;
+			if (currentSection) {
+				entries[currentSection] = entries[currentSection] ?? [];
+			}
+			continue;
+		}
+
+		if (!currentSection) continue;
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("-")) continue;
+		const entry = trimmed.replace(/^[-*]\s*/, "");
+		if (entry) {
+			entries[currentSection]?.push(entry);
+		}
+	}
+
+	return { startLine: startIndex, endLine: endIndex, entries };
+}

package/src/commit/cli.ts

@@ -0,0 +1,85 @@
+import chalk from "chalk";
+import type { CommitCommandArgs } from "./types";
+
+const FLAG_ALIASES = new Map<string, string>([
+	["-c", "--context"],
+	["-m", "--model"],
+]);
+
+export function parseCommitArgs(args: string[]): CommitCommandArgs | undefined {
+	if (args.length === 0 || args[0] !== "commit") {
+		return undefined;
+	}
+
+	const result: CommitCommandArgs = {
+		push: false,
+		dryRun: false,
+		noChangelog: false,
+	};
+
+	for (let i = 1; i < args.length; i += 1) {
+		const raw = args[i] ?? "";
+		const flag = FLAG_ALIASES.get(raw) ?? raw;
+		switch (flag) {
+			case "--push":
+				result.push = true;
+				break;
+			case "--dry-run":
+				result.dryRun = true;
+				break;
+			case "--no-changelog":
+				result.noChangelog = true;
+				break;
+			case "--legacy":
+				result.legacy = true;
+				break;
+			case "--context": {
+				const value = args[i + 1];
+				if (!value || value.startsWith("-")) {
+					process.stderr.write(`${chalk.red("Error: --context requires a value")}\n`);
+					process.exit(1);
+				}
+				result.context = value;
+				i += 1;
+				break;
+			}
+			case "--model": {
+				const value = args[i + 1];
+				if (!value || value.startsWith("-")) {
+					process.stderr.write(`${chalk.red("Error: --model requires a value")}\n`);
+					process.exit(1);
+				}
+				result.model = value;
+				i += 1;
+				break;
+			}
+			case "--help":
+			case "-h":
+				break;
+			default:
+				if (flag.startsWith("-")) {
+					process.stderr.write(`${chalk.red(`Error: Unknown flag ${flag}`)}\n`);
+					process.exit(1);
+				}
+		}
+	}
+
+	return result;
+}
+
+export function printCommitHelp(): void {
+	const lines = [
+		"Usage:",
+		"  omp commit [options]",
+		"",
+		"Options:",
+		"  --push           Push after committing",
+		"  --dry-run        Preview without committing",
+		"  --no-changelog   Skip changelog updates",
+		"  --legacy         Use legacy deterministic pipeline",
+		"  --context, -c    Additional context for the model",
+		"  --model, -m      Override model selection",
+		"  --help, -h       Show this help message",
+	];
+	process.stdout.write(`${lines.join("\n")}\n`);
+}

package/src/commit/git/diff.ts

@@ -0,0 +1,148 @@
+import type { DiffHunk, FileDiff, FileHunks, NumstatEntry } from "../../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/index.ts

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

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

@@ -0,0 +1,69 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
+import { $env } from "@oh-my-pi/pi-utils";
+import { parseFileDiffs } from "../../commit/git/diff";
+import type { ConventionalAnalysis } from "../../commit/types";
+import { isExcludedFile } from "../../commit/utils/exclusions";
+import { runMapPhase } from "./map-phase";
+import { runReducePhase } from "./reduce-phase";
+import { estimateTokens } from "./utils";
+
+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: ApiKey;
+	thinkingLevel?: ThinkingLevel;
+	smolModel: Model<Api>;
+	smolApiKey: ApiKey;
+	smolThinkingLevel?: ThinkingLevel;
+	diff: string;
+	stat: string;
+	scopeCandidates: string;
+	typesDescription?: string;
+	settings?: MapReduceSettings;
+}
+
+export function shouldUseMapReduce(diff: string, settings?: MapReduceSettings): boolean {
+	if ($env.PI_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,
+		thinkingLevel: input.smolThinkingLevel,
+		files: fileDiffs,
+		config: input.settings,
+	});
+	return runReducePhase({
+		model: input.model,
+		apiKey: input.apiKey,
+		thinkingLevel: input.thinkingLevel,
+		observations,
+		stat: input.stat,
+		scopeCandidates: input.scopeCandidates,
+		typesDescription: input.typesDescription,
+	});
+}