oma-coding-agent 1.1.4

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

@@ -0,0 +1,193 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, ApiKey, AssistantMessage, Message, Model } from "@oh-my-pi/pi-ai";
+import { completeSimple } from "@oh-my-pi/pi-ai";
+import { prompt } from "@oh-my-pi/pi-utils";
+import fileObserverSystemPrompt from "../../commit/prompts/file-observer-system.md" with { type: "text" };
+import fileObserverUserPrompt from "../../commit/prompts/file-observer-user.md" with { type: "text" };
+import type { FileDiff, FileObservation } from "../../commit/types";
+import { isExcludedFile } from "../../commit/utils/exclusions";
+import { toReasoningEffort } from "../../thinking";
+import { truncateToTokenLimit } from "./utils";
+
+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: ApiKey;
+	thinkingLevel?: ThinkingLevel;
+	files: FileDiff[];
+	config?: {
+		maxFileTokens?: number;
+		maxConcurrency?: number;
+		timeoutMs?: number;
+		maxRetries?: number;
+		retryBackoffMs?: number;
+	};
+}
+
+export async function runMapPhase({
+	model,
+	apiKey,
+	thinkingLevel,
+	files,
+	config,
+}: MapPhaseInput): Promise<FileObservation[]> {
+	const filtered = files.filter(file => !isExcludedFile(file.filename));
+	const systemPrompt = prompt.render(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 userContent = prompt.render(fileObserverUserPrompt, {
+			filename: file.filename,
+			diff: truncated,
+			context_header: contextHeader,
+		});
+		const request = {
+			systemPrompt: [systemPrompt],
+			messages: [{ role: "user", content: userContent, timestamp: Date.now() }] as Message[],
+		};
+
+		const response = await withRetry(
+			() =>
+				completeSimple(model, request, {
+					apiKey,
+					maxTokens: 400,
+					reasoning: toReasoningEffort(thinkingLevel),
+					signal: AbortSignal.timeout(timeoutMs),
+				}),
+			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(`[…${sorted.length - toShow.length} files elided…]`);
+	}
+
+	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;
+}

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

@@ -0,0 +1,49 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
+import { completeSimple } from "@oh-my-pi/pi-ai";
+import { prompt } from "@oh-my-pi/pi-utils";
+import reduceSystemPrompt from "../../commit/prompts/reduce-system.md" with { type: "text" };
+import reduceUserPrompt from "../../commit/prompts/reduce-user.md" with { type: "text" };
+import type { ConventionalAnalysis, FileObservation } from "../../commit/types";
+import { toReasoningEffort } from "../../thinking";
+import { createConventionalAnalysisTool, parseConventionalAnalysisResponse } from "../shared-llm";
+
+const ReduceTool = createConventionalAnalysisTool("Synthesize file observations into a conventional commit analysis.");
+
+export interface ReducePhaseInput {
+	model: Model<Api>;
+	apiKey: ApiKey;
+	thinkingLevel?: ThinkingLevel;
+	observations: FileObservation[];
+	stat: string;
+	scopeCandidates: string;
+	typesDescription?: string;
+}
+
+export async function runReducePhase({
+	model,
+	apiKey,
+	thinkingLevel,
+	observations,
+	stat,
+	scopeCandidates,
+	typesDescription,
+}: ReducePhaseInput): Promise<ConventionalAnalysis> {
+	const userContent = prompt.render(reduceUserPrompt, {
+		types_description: typesDescription,
+		observations: observations.flatMap(obs => obs.observations.map(line => `- ${obs.file}: ${line}`)).join("\n"),
+		stat,
+		scope_candidates: scopeCandidates,
+	});
+	const response = await completeSimple(
+		model,
+		{
+			systemPrompt: [prompt.render(reduceSystemPrompt)],
+			messages: [{ role: "user", content: userContent, timestamp: Date.now() }],
+			tools: [ReduceTool],
+		},
+		{ apiKey, maxTokens: 2400, reasoning: toReasoningEffort(thinkingLevel) },
+	);
+
+	return parseConventionalAnalysisResponse(response, ReduceTool);
+}

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

@@ -0,0 +1,9 @@
+export function estimateTokens(text: string): number {
+	return Math.ceil(text.length / 4);
+}
+
+export function truncateToTokenLimit(text: string, maxTokens: number): string {
+	const maxChars = maxTokens * 4;
+	if (text.length <= maxChars) return text;
+	return `${text.slice(0, maxChars)}\n[…${text.length - maxChars}ch elided…]`;
+}

package/src/commit/message.ts

@@ -0,0 +1,11 @@
+import type { ConventionalAnalysis } from "./types";
+
+export function formatCommitMessage(analysis: ConventionalAnalysis, summary: string): string {
+	const scopePart = analysis.scope ? `(${analysis.scope})` : "";
+	const header = `${analysis.type}${scopePart}: ${summary}`;
+	const bodyLines = analysis.details.map(detail => `- ${detail.text.trim()}`);
+	if (bodyLines.length === 0) {
+		return header;
+	}
+	return `${header}\n\n${bodyLines.join("\n")}`;
+}

package/src/commit/model-selection.ts

@@ -0,0 +1,89 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
+import type { ApiKeyResolverRegistry } from "../config/api-key-resolver";
+import {
+	getModelMatchPreferences,
+	type ModelLookupRegistry,
+	parseModelPattern,
+	resolveModelRoleValue,
+	resolveRoleSelection,
+} from "../config/model-resolver";
+import { MODEL_ROLE_IDS } from "../config/model-roles";
+import type { Settings } from "../config/settings";
+import MODEL_PRIO from "../priority.json" with { type: "json" };
+
+export interface ResolvedCommitModel {
+	model: Model<Api>;
+	/**
+	 * Resolver for the model's bearer: re-resolves on 401 / usage-limit so the
+	 * whole commit pipeline (analysis, map/reduce, changelog) inherits the
+	 * central force-refresh + account-rotation policy.
+	 */
+	apiKey: ApiKey;
+	thinkingLevel?: ThinkingLevel;
+}
+
+type CommitModelRegistry = ModelLookupRegistry &
+	ApiKeyResolverRegistry & {
+		getApiKey: (model: Model<Api>) => Promise<string | undefined>;
+	};
+
+export async function resolvePrimaryModel(
+	override: string | undefined,
+	settings: Settings,
+	modelRegistry: CommitModelRegistry,
+): Promise<ResolvedCommitModel> {
+	const available = modelRegistry.getAvailable();
+	const matchPreferences = getModelMatchPreferences(settings);
+	const resolved = override
+		? resolveModelRoleValue(override, available, { settings, matchPreferences, modelRegistry })
+		: resolveRoleSelection(["commit", "smol", ...MODEL_ROLE_IDS], settings, available, modelRegistry);
+	const model = resolved?.model;
+	if (!model) {
+		throw new Error("No model available for commit generation");
+	}
+	const apiKey = await modelRegistry.getApiKey(model);
+	if (!apiKey) {
+		throw new Error(`No API key available for model ${model.provider}/${model.id}`);
+	}
+	return {
+		model,
+		apiKey: modelRegistry.resolver(model),
+		thinkingLevel: resolved?.thinkingLevel,
+	};
+}
+
+export async function resolveSmolModel(
+	settings: Settings,
+	modelRegistry: CommitModelRegistry,
+	fallbackModel: Model<Api>,
+	fallbackApiKey: ApiKey,
+): Promise<ResolvedCommitModel> {
+	const available = modelRegistry.getAvailable();
+	const resolvedSmol = resolveRoleSelection(["smol"], settings, available, modelRegistry);
+	if (resolvedSmol?.model) {
+		const apiKey = await modelRegistry.getApiKey(resolvedSmol.model);
+		if (apiKey) {
+			return {
+				model: resolvedSmol.model,
+				apiKey: modelRegistry.resolver(resolvedSmol.model),
+				thinkingLevel: resolvedSmol.thinkingLevel,
+			};
+		}
+	}
+
+	const matchPreferences = getModelMatchPreferences(settings);
+	for (const pattern of MODEL_PRIO.smol) {
+		const candidate = parseModelPattern(pattern, available, matchPreferences, { modelRegistry }).model;
+		if (!candidate) continue;
+		const apiKey = await modelRegistry.getApiKey(candidate);
+		if (apiKey) {
+			return {
+				model: candidate,
+				apiKey: modelRegistry.resolver(candidate),
+			};
+		}
+	}
+
+	return { model: fallbackModel, apiKey: fallbackApiKey };
+}

package/src/commit/pipeline.ts

@@ -0,0 +1,243 @@
+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 { getProjectDir, logger, prompt } from "@oh-my-pi/pi-utils";
+import { ModelRegistry } from "../config/model-registry";
+import { Settings } from "../config/settings";
+import { discoverAuthStorage } from "../sdk";
+import { loadProjectContextFiles } from "../system-prompt";
+import * as git from "../utils/git";
+import { runAgenticCommit } from "./agentic";
+import {
+	extractScopeCandidates,
+	generateConventionalAnalysis,
+	generateSummary,
+	validateAnalysis,
+	validateSummary,
+} from "./analysis";
+import { runChangelogFlow } from "./changelog";
+import { runMapReduceAnalysis, shouldUseMapReduce } from "./map-reduce";
+import { formatCommitMessage } from "./message";
+import { resolvePrimaryModel, resolveSmolModel } from "./model-selection";
+import summaryRetryPrompt from "./prompts/summary-retry.md" with { type: "text" };
+import typesDescriptionPrompt from "./prompts/types-description.md" with { type: "text" };
+import type { CommitCommandArgs, ConventionalAnalysis } from "./types";
+
+const SUMMARY_MAX_CHARS = 72;
+const RECENT_COMMITS_COUNT = 8;
+let typesDescription: string | undefined;
+const TYPES_DESCRIPTION = (): string => (typesDescription ??= prompt.render(typesDescriptionPrompt));
+
+/**
+ * Execute the omp commit pipeline for staged changes.
+ */
+export async function runCommitCommand(args: CommitCommandArgs): Promise<void> {
+	if (args.legacy) {
+		return runLegacyCommitCommand(args);
+	}
+	return runAgenticCommit(args);
+}
+
+async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
+	const cwd = getProjectDir();
+	const settings = await Settings.init();
+	const commitSettings = settings.getGroup("commit");
+	const authStorage = await discoverAuthStorage();
+	const modelRegistry = new ModelRegistry(authStorage);
+	await modelRegistry.refresh();
+
+	const {
+		model: primaryModel,
+		apiKey: primaryApiKey,
+		thinkingLevel: primaryThinkingLevel,
+	} = await resolvePrimaryModel(args.model, settings, modelRegistry);
+	const {
+		model: smolModel,
+		apiKey: smolApiKey,
+		thinkingLevel: smolThinkingLevel,
+	} = await resolveSmolModel(settings, modelRegistry, primaryModel, primaryApiKey);
+
+	let stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
+	if (stagedFiles.length === 0) {
+		process.stdout.write("No staged changes detected, staging all changes...\n");
+		await git.stage.files(cwd);
+		stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
+	}
+	if (stagedFiles.length === 0) {
+		process.stderr.write("No changes to commit.\n");
+		return;
+	}
+
+	if (!args.noChangelog) {
+		await runChangelogFlow({
+			cwd,
+			model: primaryModel,
+			apiKey: primaryApiKey,
+			thinkingLevel: primaryThinkingLevel,
+			stagedFiles,
+			dryRun: args.dryRun,
+			maxDiffChars: commitSettings.changelogMaxDiffChars,
+		});
+	}
+
+	const diff = await git.diff(cwd, { cached: true });
+	const stat = await git.diff(cwd, { stat: true, cached: true });
+	const numstat = await git.diff.numstat(cwd, { cached: true });
+	const scopeCandidates = extractScopeCandidates(numstat).scopeCandidates;
+	const recentCommits = await git.log.subjects(cwd, RECENT_COMMITS_COUNT);
+	const contextFiles = await loadProjectContextFiles({ cwd });
+	const formattedContextFiles = contextFiles.map(file => ({
+		path: path.relative(cwd, file.path),
+		content: file.content,
+	}));
+
+	const analysis = await generateAnalysis({
+		diff,
+		stat,
+		scopeCandidates,
+		recentCommits,
+		contextFiles: formattedContextFiles,
+		userContext: args.context,
+		primaryModel,
+		primaryApiKey,
+		primaryThinkingLevel,
+		smolModel,
+		smolApiKey,
+		smolThinkingLevel,
+		commitSettings,
+	});
+
+	const analysisValidation = validateAnalysis(analysis);
+	if (!analysisValidation.valid) {
+		logger.warn("commit analysis validation failed", { errors: analysisValidation.errors });
+	}
+
+	const summary = await generateSummaryWithRetry({
+		analysis,
+		stat,
+		model: primaryModel,
+		apiKey: primaryApiKey,
+		thinkingLevel: primaryThinkingLevel,
+		userContext: args.context,
+	});
+
+	const commitMessage = formatCommitMessage(analysis, summary.summary);
+
+	if (args.dryRun) {
+		process.stdout.write("\nGenerated commit message:\n");
+		process.stdout.write(`${commitMessage}\n`);
+		return;
+	}
+
+	await git.commit(cwd, commitMessage);
+	process.stdout.write("Commit created.\n");
+	if (args.push) {
+		await git.push(cwd);
+		process.stdout.write("Pushed to remote.\n");
+	}
+}
+
+async function generateAnalysis(input: {
+	diff: string;
+	stat: string;
+	scopeCandidates: string;
+	recentCommits: string[];
+	contextFiles: Array<{ path: string; content: string }>;
+	userContext?: string;
+	primaryModel: Model<Api>;
+	primaryApiKey: ApiKey;
+	primaryThinkingLevel?: ThinkingLevel;
+	smolModel: Model<Api>;
+	smolApiKey: ApiKey;
+	smolThinkingLevel?: ThinkingLevel;
+	commitSettings: {
+		mapReduceEnabled: boolean;
+		mapReduceMinFiles: number;
+		mapReduceMaxFileTokens: number;
+		mapReduceTimeoutMs: number;
+		mapReduceMaxConcurrency: number;
+		changelogMaxDiffChars: number;
+	};
+}): Promise<ConventionalAnalysis> {
+	if (
+		shouldUseMapReduce(input.diff, {
+			enabled: input.commitSettings.mapReduceEnabled,
+			minFiles: input.commitSettings.mapReduceMinFiles,
+			maxFileTokens: input.commitSettings.mapReduceMaxFileTokens,
+		})
+	) {
+		process.stdout.write("Large diff detected, using map-reduce analysis...\n");
+		return runMapReduceAnalysis({
+			model: input.primaryModel,
+			apiKey: input.primaryApiKey,
+			thinkingLevel: input.primaryThinkingLevel,
+			smolModel: input.smolModel,
+			smolApiKey: input.smolApiKey,
+			smolThinkingLevel: input.smolThinkingLevel,
+			diff: input.diff,
+			stat: input.stat,
+			scopeCandidates: input.scopeCandidates,
+			typesDescription: TYPES_DESCRIPTION(),
+			settings: {
+				enabled: input.commitSettings.mapReduceEnabled,
+				minFiles: input.commitSettings.mapReduceMinFiles,
+				maxFileTokens: input.commitSettings.mapReduceMaxFileTokens,
+				maxConcurrency: input.commitSettings.mapReduceMaxConcurrency,
+				timeoutMs: input.commitSettings.mapReduceTimeoutMs,
+			},
+		});
+	}
+
+	return generateConventionalAnalysis({
+		model: input.primaryModel,
+		apiKey: input.primaryApiKey,
+		thinkingLevel: input.primaryThinkingLevel,
+		contextFiles: input.contextFiles,
+		userContext: input.userContext,
+		typesDescription: TYPES_DESCRIPTION(),
+		recentCommits: input.recentCommits,
+		scopeCandidates: input.scopeCandidates,
+		stat: input.stat,
+		diff: input.diff,
+	});
+}
+
+async function generateSummaryWithRetry(input: {
+	analysis: ConventionalAnalysis;
+	stat: string;
+	model: Model<Api>;
+	apiKey: ApiKey;
+	thinkingLevel?: ThinkingLevel;
+	userContext?: string;
+}): Promise<{ summary: string }> {
+	let context = input.userContext;
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		const result = await generateSummary({
+			model: input.model,
+			apiKey: input.apiKey,
+			thinkingLevel: input.thinkingLevel,
+			commitType: input.analysis.type,
+			scope: input.analysis.scope,
+			details: input.analysis.details.map(detail => detail.text),
+			stat: input.stat,
+			maxChars: SUMMARY_MAX_CHARS,
+			userContext: context,
+		});
+		const validation = validateSummary(result.summary, SUMMARY_MAX_CHARS);
+		if (validation.valid) {
+			return result;
+		}
+		if (attempt === 2) {
+			return result;
+		}
+		context = buildRetryContext(input.userContext, validation.errors);
+	}
+	throw new Error("Summary generation failed");
+}
+
+function buildRetryContext(base: string | undefined, errors: string[]): string {
+	return prompt.render(summaryRetryPrompt, {
+		base_context: base,
+		errors: errors.join("; "),
+	});
+}