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

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

@@ -0,0 +1,147 @@
+import type { Api, AssistantMessage, Model, ToolCall } from "@oh-my-pi/pi-ai";
+import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
+import reduceSystemPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/reduce-system.md" with { type: "text" };
+import reduceUserPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/reduce-user.md" with { type: "text" };
+import type { ChangelogCategory, ConventionalAnalysis, FileObservation } from "@oh-my-pi/pi-coding-agent/commit/types";
+import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
+import { Type } from "@sinclair/typebox";
+
+const ReduceTool = {
+	name: "create_conventional_analysis",
+	description: "Synthesize file observations into a conventional commit analysis.",
+	parameters: Type.Object({
+		type: Type.Union([
+			Type.Literal("feat"),
+			Type.Literal("fix"),
+			Type.Literal("refactor"),
+			Type.Literal("docs"),
+			Type.Literal("test"),
+			Type.Literal("chore"),
+			Type.Literal("style"),
+			Type.Literal("perf"),
+			Type.Literal("build"),
+			Type.Literal("ci"),
+			Type.Literal("revert"),
+		]),
+		scope: Type.Union([Type.String(), Type.Null()]),
+		details: Type.Array(
+			Type.Object({
+				text: Type.String(),
+				changelog_category: Type.Optional(
+					Type.Union([
+						Type.Literal("Added"),
+						Type.Literal("Changed"),
+						Type.Literal("Fixed"),
+						Type.Literal("Deprecated"),
+						Type.Literal("Removed"),
+						Type.Literal("Security"),
+						Type.Literal("Breaking Changes"),
+					]),
+				),
+				user_visible: Type.Optional(Type.Boolean()),
+			}),
+		),
+		issue_refs: Type.Array(Type.String()),
+	}),
+};
+
+export interface ReducePhaseInput {
+	model: Model<Api>;
+	apiKey: string;
+	observations: FileObservation[];
+	stat: string;
+	scopeCandidates: string;
+	typesDescription?: string;
+}
+
+export async function runReducePhase({
+	model,
+	apiKey,
+	observations,
+	stat,
+	scopeCandidates,
+	typesDescription,
+}: ReducePhaseInput): Promise<ConventionalAnalysis> {
+	const prompt = renderPromptTemplate(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: renderPromptTemplate(reduceSystemPrompt),
+			messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+			tools: [ReduceTool],
+		},
+		{ apiKey, maxTokens: 2400 },
+	);
+
+	return parseAnalysisResponse(response);
+}
+
+function parseAnalysisResponse(message: AssistantMessage): ConventionalAnalysis {
+	const toolCall = extractToolCall(message, "create_conventional_analysis");
+	if (toolCall) {
+		const parsed = validateToolCall([ReduceTool], toolCall) as {
+			type: ConventionalAnalysis["type"];
+			scope: string | null;
+			details: Array<{ text: string; changelog_category?: ChangelogCategory; user_visible?: boolean }>;
+			issue_refs: string[];
+		};
+		return normalizeAnalysis(parsed);
+	}
+	const text = extractTextContent(message);
+	const parsed = parseJsonPayload(text) as {
+		type: ConventionalAnalysis["type"];
+		scope: string | null;
+		details: Array<{ text: string; changelog_category?: ChangelogCategory; user_visible?: boolean }>;
+		issue_refs: string[];
+	};
+	return normalizeAnalysis(parsed);
+}
+
+function parseJsonPayload(text: string): unknown {
+	const trimmed = text.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+		return JSON.parse(trimmed) as unknown;
+	}
+	const match = trimmed.match(/\{[\s\S]*\}/);
+	if (!match) {
+		throw new Error("No JSON payload found in reduce response");
+	}
+	return JSON.parse(match[0]) as unknown;
+}
+
+function normalizeAnalysis(parsed: {
+	type: ConventionalAnalysis["type"];
+	scope: string | null;
+	details: Array<{ text: string; changelog_category?: ChangelogCategory; user_visible?: boolean }>;
+	issue_refs: string[];
+}): ConventionalAnalysis {
+	return {
+		type: parsed.type,
+		scope: parsed.scope?.trim() || null,
+		details: parsed.details.map((detail) => ({
+			text: detail.text.trim(),
+			changelogCategory: detail.user_visible ? detail.changelog_category : undefined,
+			userVisible: detail.user_visible ?? false,
+		})),
+		issueRefs: parsed.issue_refs ?? [],
+	};
+}
+
+function extractToolCall(message: AssistantMessage, name: string): ToolCall | undefined {
+	return message.content.find((content) => content.type === "toolCall" && content.name === name) as
+		| ToolCall
+		| undefined;
+}
+
+function extractTextContent(message: AssistantMessage): string {
+	return message.content
+		.filter((content) => content.type === "text")
+		.map((content) => content.text)
+		.join("")
+		.trim();
+}

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... (truncated)`;
+}

package/src/commit/message.ts

@@ -0,0 +1,11 @@
+import type { ConventionalAnalysis } from "@oh-my-pi/pi-coding-agent/commit/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,84 @@
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import {
+	parseModelPattern,
+	parseModelString,
+	SMOL_MODEL_PRIORITY,
+} from "@oh-my-pi/pi-coding-agent/config/model-resolver";
+import type { SettingsManager } from "@oh-my-pi/pi-coding-agent/config/settings-manager";
+
+export async function resolvePrimaryModel(
+	override: string | undefined,
+	settingsManager: SettingsManager,
+	modelRegistry: {
+		getAvailable: () => Model<Api>[];
+		getApiKey: (model: Model<Api>) => Promise<string | undefined>;
+	},
+): Promise<{ model: Model<Api>; apiKey: string }> {
+	const available = modelRegistry.getAvailable();
+	const model = override
+		? resolveModelFromString(expandRoleAlias(override, settingsManager), available)
+		: resolveModelFromSettings(settingsManager, available);
+	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 };
+}
+
+export async function resolveSmolModel(
+	settingsManager: SettingsManager,
+	modelRegistry: {
+		getAvailable: () => Model<Api>[];
+		getApiKey: (model: Model<Api>) => Promise<string | undefined>;
+	},
+	fallbackModel: Model<Api>,
+	fallbackApiKey: string,
+): Promise<{ model: Model<Api>; apiKey: string }> {
+	const available = modelRegistry.getAvailable();
+	const role = settingsManager.getModelRole("smol");
+	const roleModel = role ? resolveModelFromString(role, available) : undefined;
+	if (roleModel) {
+		const apiKey = await modelRegistry.getApiKey(roleModel);
+		if (apiKey) return { model: roleModel, apiKey };
+	}
+
+	for (const pattern of SMOL_MODEL_PRIORITY) {
+		const candidate = parseModelPattern(pattern, available).model;
+		if (!candidate) continue;
+		const apiKey = await modelRegistry.getApiKey(candidate);
+		if (apiKey) return { model: candidate, apiKey };
+	}
+
+	return { model: fallbackModel, apiKey: fallbackApiKey };
+}
+
+function resolveModelFromSettings(settingsManager: SettingsManager, available: Model<Api>[]): Model<Api> | undefined {
+	const roles = ["commit", "smol", "default"];
+	for (const role of roles) {
+		const configured = settingsManager.getModelRole(role);
+		if (!configured) continue;
+		const resolved = resolveModelFromString(expandRoleAlias(configured, settingsManager), available);
+		if (resolved) return resolved;
+	}
+	return available[0];
+}
+
+function resolveModelFromString(value: string, available: Model<Api>[]): Model<Api> | undefined {
+	const parsed = parseModelString(value);
+	if (parsed) {
+		return available.find((model) => model.provider === parsed.provider && model.id === parsed.id);
+	}
+	return parseModelPattern(value, available).model;
+}
+
+function expandRoleAlias(value: string, settingsManager: SettingsManager): string {
+	const lower = value.toLowerCase();
+	if (lower.startsWith("pi/") || lower.startsWith("omp/")) {
+		const role = lower.startsWith("pi/") ? value.slice(3) : value.slice(4);
+		return settingsManager.getModelRole(role) ?? value;
+	}
+	return value;
+}

package/src/commit/pipeline.ts

@@ -0,0 +1,242 @@
+import { relative } from "node:path";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { runAgenticCommit } from "@oh-my-pi/pi-coding-agent/commit/agentic";
+import {
+	extractScopeCandidates,
+	generateConventionalAnalysis,
+	generateSummary,
+	validateAnalysis,
+	validateSummary,
+} from "@oh-my-pi/pi-coding-agent/commit/analysis";
+import { runChangelogFlow } from "@oh-my-pi/pi-coding-agent/commit/changelog";
+import { ControlledGit } from "@oh-my-pi/pi-coding-agent/commit/git";
+import { runMapReduceAnalysis, shouldUseMapReduce } from "@oh-my-pi/pi-coding-agent/commit/map-reduce";
+import { formatCommitMessage } from "@oh-my-pi/pi-coding-agent/commit/message";
+import { resolvePrimaryModel, resolveSmolModel } from "@oh-my-pi/pi-coding-agent/commit/model-selection";
+import summaryRetryPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/summary-retry.md" with { type: "text" };
+import typesDescriptionPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/types-description.md" with {
+	type: "text",
+};
+import type { CommitCommandArgs, ConventionalAnalysis } from "@oh-my-pi/pi-coding-agent/commit/types";
+import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
+import { SettingsManager } from "@oh-my-pi/pi-coding-agent/config/settings-manager";
+import { discoverAuthStorage, discoverModels } from "@oh-my-pi/pi-coding-agent/sdk";
+import { loadProjectContextFiles } from "@oh-my-pi/pi-coding-agent/system-prompt";
+import { logger } from "@oh-my-pi/pi-utils";
+
+const SUMMARY_MAX_CHARS = 72;
+const RECENT_COMMITS_COUNT = 8;
+const TYPES_DESCRIPTION = renderPromptTemplate(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 = process.cwd();
+	const settingsManager = await SettingsManager.create(cwd);
+	const commitSettings = settingsManager.getCommitSettings();
+	const authStorage = await discoverAuthStorage();
+	const modelRegistry = await discoverModels(authStorage);
+
+	const { model: primaryModel, apiKey: primaryApiKey } = await resolvePrimaryModel(
+		args.model,
+		settingsManager,
+		modelRegistry,
+	);
+	const { model: smolModel, apiKey: smolApiKey } = await resolveSmolModel(
+		settingsManager,
+		modelRegistry,
+		primaryModel,
+		primaryApiKey,
+	);
+
+	const git = new ControlledGit(cwd);
+	let stagedFiles = await git.getStagedFiles();
+	if (stagedFiles.length === 0) {
+		writeStdout("No staged changes detected, staging all changes...");
+		await git.stageAll();
+		stagedFiles = await git.getStagedFiles();
+	}
+	if (stagedFiles.length === 0) {
+		writeStderr("No changes to commit.");
+		return;
+	}
+
+	if (!args.noChangelog) {
+		await runChangelogFlow({
+			git,
+			cwd,
+			model: primaryModel,
+			apiKey: primaryApiKey,
+			stagedFiles,
+			dryRun: args.dryRun,
+			maxDiffChars: commitSettings.changelogMaxDiffChars,
+		});
+	}
+
+	const diff = await git.getDiff(true);
+	const stat = await git.getStat(true);
+	const numstat = await git.getNumstat(true);
+	const scopeCandidates = extractScopeCandidates(numstat).scopeCandidates;
+	const recentCommits = await git.getRecentCommits(RECENT_COMMITS_COUNT);
+	const contextFiles = await loadProjectContextFiles({ cwd });
+	const formattedContextFiles = contextFiles.map((file) => ({
+		path: relative(cwd, file.path),
+		content: file.content,
+	}));
+
+	const analysis = await generateAnalysis({
+		diff,
+		stat,
+		scopeCandidates,
+		recentCommits,
+		contextFiles: formattedContextFiles,
+		userContext: args.context,
+		primaryModel,
+		primaryApiKey,
+		smolModel,
+		smolApiKey,
+		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,
+		userContext: args.context,
+	});
+
+	const commitMessage = formatCommitMessage(analysis, summary.summary);
+
+	if (args.dryRun) {
+		writeStdout("\nGenerated commit message:\n");
+		writeStdout(commitMessage);
+		return;
+	}
+
+	await git.commit(commitMessage);
+	writeStdout("Commit created.");
+	if (args.push) {
+		await git.push();
+		writeStdout("Pushed to remote.");
+	}
+}
+
+async function generateAnalysis(input: {
+	diff: string;
+	stat: string;
+	scopeCandidates: string;
+	recentCommits: string[];
+	contextFiles: Array<{ path: string; content: string }>;
+	userContext?: string;
+	primaryModel: Model<Api>;
+	primaryApiKey: string;
+	smolModel: Model<Api>;
+	smolApiKey: string;
+	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,
+		})
+	) {
+		writeStdout("Large diff detected, using map-reduce analysis...");
+		return runMapReduceAnalysis({
+			model: input.primaryModel,
+			apiKey: input.primaryApiKey,
+			smolModel: input.smolModel,
+			smolApiKey: input.smolApiKey,
+			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,
+		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: string;
+	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,
+			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 renderPromptTemplate(summaryRetryPrompt, {
+		base_context: base,
+		errors: errors.join("; "),
+	});
+}
+
+function writeStdout(message: string): void {
+	process.stdout.write(`${message}\n`);
+}
+
+function writeStderr(message: string): void {
+	process.stderr.write(`${message}\n`);
+}

package/src/commit/prompts/analysis-system.md

@@ -0,0 +1,155 @@
+<context>
+You are a senior release engineer who writes precise, changelog-ready commit classifications. Your output feeds directly into automated release tooling.
+</context>
+
+<instructions>
+Classify this git diff into conventional commit format. Get this right — it affects release notes and semantic versioning.
+
+## 1. Determine Scope
+
+Apply scope when 60%+ of line changes target a single component:
+- 150 lines in src/api/, 30 in src/lib.rs -> "api"
+- 50 lines in src/api/, 50 in src/types/ -> null (50/50 split)
+
+Use null for: cross-cutting changes, no dominant component, project-wide refactoring.
+
+Forbidden scopes (use null): src, lib, include, tests, benches, examples, docs, project name, app, main, entire, all, misc.
+
+Prefer scopes from <common_scopes> over inventing new ones.
+
+## 2. Generate Details (0-6 items)
+
+Each detail:
+1. Past-tense verb, ends with period
+2. Explains impact/rationale (skip trivial what-changed)
+3. Uses precise names (modules, APIs, files)
+4. Under 120 characters
+
+Abstraction preference:
+- BEST: "Replaced polling with event-driven model for 10x throughput."
+- GOOD: "Consolidated three HTTP builders into unified API."
+- SKIP: "Renamed workspacePath to locate."
+
+Group 3+ similar changes: "Updated 5 test files for new API." (not five bullets).
+
+Issue references inline: (#123), (#123, #456), (#123-#125).
+
+Priority: user-visible -> perf/security -> architecture -> internal.
+
+Exclude: import changes, whitespace, formatting, trivial renames, debug prints, comment-only, file moves without modification.
+
+State only visible rationale. If unclear, use neutral: "Updated logic for correctness."
+
+## 3. Assign Changelog Metadata
+
+| Condition | changelog_category |
+|-----------|--------------------|
+| New public API, feature, capability | "Added" |
+| Modified existing behavior | "Changed" |
+| Bug fix, correction | "Fixed" |
+| Feature marked for removal | "Deprecated" |
+| Feature/API removed | "Removed" |
+| Security fix or improvement | "Security" |
+
+user_visible: true for: new features, APIs, breaking changes, user-affecting bug fixes, user-facing docs, security fixes.
+
+user_visible: false for: internal refactoring, performance optimizations (unless documented), test/build/CI, code style.
+
+Omit changelog_category when user_visible is false.
+</instructions>
+
+<output_format>
+Call create_conventional_analysis with:
+
+{
+  "type": "feat|fix|refactor|docs|test|chore|style|perf|build|ci|revert",
+  "scope": "component-name" | null,
+  "details": [
+    {
+      "text": "Past-tense description ending with period.",
+      "changelog_category": "Added|Changed|Fixed|Deprecated|Removed|Security",
+      "user_visible": true
+    },
+    {
+      "text": "Internal change description.",
+      "user_visible": false
+    }
+  ],
+  "issue_refs": []
+}
+</output_format>
+
+<examples>
+<example name="feature-with-api">
+{
+  "type": "feat",
+  "scope": "api",
+  "details": [
+    {
+      "text": "Added TLS mutual authentication to prevent man-in-the-middle attacks (#100).",
+      "changelog_category": "Added",
+      "user_visible": true
+    },
+    {
+      "text": "Implemented builder pattern to simplify transport configuration (#101).",
+      "changelog_category": "Added",
+      "user_visible": true
+    },
+    {
+      "text": "Migrated 6 integration tests to exercise new security features.",
+      "user_visible": false
+    }
+  ],
+  "issue_refs": []
+}
+</example>
+
+<example name="internal-refactor">
+{
+  "type": "refactor",
+  "scope": "parser",
+  "details": [
+    {
+      "text": "Extracted validation logic into separate module for reusability.",
+      "user_visible": false
+    },
+    {
+      "text": "Consolidated error handling across 12 functions to reduce duplication.",
+      "user_visible": false
+    }
+  ],
+  "issue_refs": []
+}
+</example>
+
+<example name="bug-fix">
+{
+  "type": "fix",
+  "scope": "parser",
+  "details": [
+    {
+      "text": "Corrected off-by-one error causing buffer overflow on large inputs (#456).",
+      "changelog_category": "Fixed",
+      "user_visible": true
+    },
+    {
+      "text": "Added bounds checking to prevent panic on empty files (#457).",
+      "changelog_category": "Fixed",
+      "user_visible": true
+    }
+  ],
+  "issue_refs": []
+}
+</example>
+
+<example name="minimal-chore">
+{
+  "type": "chore",
+  "scope": "deps",
+  "details": [],
+  "issue_refs": []
+}
+</example>
+</examples>
+
+Be thorough. This matters.

package/src/commit/prompts/analysis-user.md

@@ -0,0 +1,41 @@
+{{#if context_files}}
+<project_context>
+{{#each context_files}}
+<file path="{{ path }}">
+{{ content }}
+</file>
+{{/each}}
+</project_context>
+{{/if}}
+{{#if user_context}}
+<user_context>
+{{ user_context }}
+</user_context>
+{{/if}}
+{{#if types_description}}
+<commit_types>
+{{ types_description }}
+</commit_types>
+{{/if}}
+
+<diff_statistics>
+{{ stat }}
+</diff_statistics>
+
+<scope_candidates>
+{{ scope_candidates }}
+</scope_candidates>
+{{#if common_scopes}}
+<common_scopes>
+{{ common_scopes }}
+</common_scopes>
+{{/if}}
+{{#if recent_commits}}
+<style_patterns>
+{{ recent_commits }}
+</style_patterns>
+{{/if}}
+
+<diff>
+{{ diff }}
+</diff>