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

package/src/commit/analysis/summary.ts

@@ -0,0 +1,114 @@
+import type { Api, AssistantMessage, Model, ToolCall } from "@oh-my-pi/pi-ai";
+import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
+import summarySystemPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/summary-system.md" with { type: "text" };
+import summaryUserPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/summary-user.md" with { type: "text" };
+import type { CommitSummary } 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 SummaryTool = {
+	name: "create_commit_summary",
+	description: "Generate the summary line for a conventional commit message.",
+	parameters: Type.Object({
+		summary: Type.String(),
+	}),
+};
+
+export interface SummaryInput {
+	model: Model<Api>;
+	apiKey: string;
+	commitType: string;
+	scope: string | null;
+	details: string[];
+	stat: string;
+	maxChars: number;
+	userContext?: string;
+}
+
+/**
+ * Generate a commit summary line for the conventional commit header.
+ */
+export async function generateSummary({
+	model,
+	apiKey,
+	commitType,
+	scope,
+	details,
+	stat,
+	maxChars,
+	userContext,
+}: SummaryInput): Promise<CommitSummary> {
+	const systemPrompt = renderSummaryPrompt({ commitType, scope, maxChars });
+	const userPrompt = renderPromptTemplate(summaryUserPrompt, {
+		user_context: userContext,
+		details: details.join("\n"),
+		stat,
+	});
+
+	const response = await completeSimple(
+		model,
+		{
+			systemPrompt,
+			messages: [{ role: "user", content: userPrompt, timestamp: Date.now() }],
+			tools: [SummaryTool],
+		},
+		{ apiKey, maxTokens: 200 },
+	);
+
+	return parseSummaryFromResponse(response, commitType, scope);
+}
+
+function renderSummaryPrompt({
+	commitType,
+	scope,
+	maxChars,
+}: {
+	commitType: string;
+	scope: string | null;
+	maxChars: number;
+}): string {
+	const scopePrefix = scope ? `(${scope})` : "";
+	return renderPromptTemplate(summarySystemPrompt, {
+		commit_type: commitType,
+		scope_prefix: scopePrefix,
+		chars: String(maxChars),
+	});
+}
+
+function parseSummaryFromResponse(message: AssistantMessage, commitType: string, scope: string | null): CommitSummary {
+	const toolCall = extractToolCall(message, "create_commit_summary");
+	if (toolCall) {
+		const parsed = validateToolCall([SummaryTool], toolCall) as { summary: string };
+		return { summary: stripTypePrefix(parsed.summary, commitType, scope) };
+	}
+	const text = extractTextContent(message);
+	return { summary: stripTypePrefix(text, commitType, scope) };
+}
+
+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();
+}
+
+export function stripTypePrefix(summary: string, commitType: string, scope: string | null): string {
+	const trimmed = summary.trim();
+	const scopePart = scope ? `(${scope})` : "";
+	const withScope = `${commitType}${scopePart}: `;
+	if (trimmed.startsWith(withScope)) {
+		return trimmed.slice(withScope.length).trim();
+	}
+	const withoutScope = `${commitType}: `;
+	if (trimmed.startsWith(withoutScope)) {
+		return trimmed.slice(withoutScope.length).trim();
+	}
+	return trimmed;
+}

package/src/commit/analysis/validation.ts

@@ -0,0 +1,66 @@
+import type { ConventionalAnalysis } from "@oh-my-pi/pi-coding-agent/commit/types";
+
+export interface ValidationResult {
+	valid: boolean;
+	errors: string[];
+}
+
+export function validateSummary(summary: string, maxChars: number): ValidationResult {
+	const errors: string[] = [];
+	if (!summary.trim()) {
+		errors.push("Summary is empty");
+	}
+	if (summary.length > maxChars) {
+		errors.push(`Summary exceeds ${maxChars} characters`);
+	}
+	if (summary.trimEnd().endsWith(".")) {
+		errors.push("Summary must not end with a period");
+	}
+	if (summary.includes("\n")) {
+		errors.push("Summary must be a single line");
+	}
+	return { valid: errors.length === 0, errors };
+}
+
+export function validateScope(scope: string | null): ValidationResult {
+	if (!scope) return { valid: true, errors: [] };
+	const errors: string[] = [];
+	const segments = scope.split("/");
+	if (segments.length > 2) {
+		errors.push("Scope may contain at most two segments");
+	}
+	for (const segment of segments) {
+		if (!segment) {
+			errors.push("Scope segments cannot be empty");
+			continue;
+		}
+		if (segment !== segment.toLowerCase()) {
+			errors.push("Scope must be lowercase");
+		}
+		if (!/^[a-z0-9][a-z0-9-_]*$/.test(segment)) {
+			errors.push(`Scope segment has invalid characters: ${segment}`);
+		}
+	}
+	return { valid: errors.length === 0, errors };
+}
+
+export function validateAnalysis(analysis: ConventionalAnalysis): ValidationResult {
+	const errors: string[] = [];
+	const scopeResult = validateScope(analysis.scope);
+	if (!scopeResult.valid) {
+		errors.push(...scopeResult.errors);
+	}
+	for (const detail of analysis.details) {
+		if (!detail.text.trim()) {
+			errors.push("Detail text is empty");
+			continue;
+		}
+		if (!detail.text.trim().endsWith(".")) {
+			errors.push(`Detail must end with a period: ${detail.text}`);
+		}
+		if (detail.text.length > 120) {
+			errors.push(`Detail exceeds 120 characters: ${detail.text}`);
+		}
+	}
+	return { valid: errors.length === 0, errors };
+}

package/src/commit/changelog/detect.ts

@@ -0,0 +1,36 @@
+import { dirname, resolve } from "node:path";
+import type { ChangelogBoundary } from "@oh-my-pi/pi-coding-agent/commit/types";
+
+const CHANGELOG_NAME = "CHANGELOG.md";
+
+export async function detectChangelogBoundaries(cwd: string, stagedFiles: string[]): Promise<ChangelogBoundary[]> {
+	const boundaries = new Map<string, string[]>();
+	for (const file of stagedFiles) {
+		if (file.toLowerCase().endsWith("changelog.md")) continue;
+		const changelogPath = await findNearestChangelog(cwd, file);
+		if (!changelogPath) continue;
+		const list = boundaries.get(changelogPath) ?? [];
+		list.push(file);
+		boundaries.set(changelogPath, list);
+	}
+
+	return Array.from(boundaries.entries()).map(([changelogPath, files]) => ({
+		changelogPath,
+		files,
+	}));
+}
+
+async function findNearestChangelog(cwd: string, filePath: string): Promise<string | null> {
+	let current = resolve(cwd, dirname(filePath));
+	const root = resolve(cwd);
+	while (true) {
+		const candidate = resolve(current, CHANGELOG_NAME);
+		if (await Bun.file(candidate).exists()) {
+			return candidate;
+		}
+		if (current === root) return null;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}

package/src/commit/changelog/generate.ts

@@ -0,0 +1,112 @@
+import type { Api, AssistantMessage, Model, ToolCall } from "@oh-my-pi/pi-ai";
+import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
+import changelogSystemPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/changelog-system.md" with { type: "text" };
+import changelogUserPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/changelog-user.md" with { type: "text" };
+import type { ChangelogGenerationResult } 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 ChangelogTool = {
+	name: "create_changelog_entries",
+	description: "Generate changelog entries grouped by Keep a Changelog categories.",
+	parameters: Type.Object({
+		entries: Type.Record(Type.String(), Type.Array(Type.String())),
+	}),
+};
+
+export interface ChangelogPromptInput {
+	model: Model<Api>;
+	apiKey: string;
+	changelogPath: string;
+	isPackageChangelog: boolean;
+	existingEntries?: string;
+	stat: string;
+	diff: string;
+}
+
+export async function generateChangelogEntries({
+	model,
+	apiKey,
+	changelogPath,
+	isPackageChangelog,
+	existingEntries,
+	stat,
+	diff,
+}: ChangelogPromptInput): Promise<ChangelogGenerationResult> {
+	const prompt = renderPromptTemplate(changelogUserPrompt, {
+		changelog_path: changelogPath,
+		is_package_changelog: isPackageChangelog,
+		existing_entries: existingEntries,
+		stat,
+		diff,
+	});
+	const response = await completeSimple(
+		model,
+		{
+			systemPrompt: renderPromptTemplate(changelogSystemPrompt),
+			messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+			tools: [ChangelogTool],
+		},
+		{ apiKey, maxTokens: 1200 },
+	);
+
+	const parsed = parseChangelogResponse(response);
+	return { entries: dedupeEntries(parsed.entries) };
+}
+
+function parseChangelogResponse(message: AssistantMessage): ChangelogGenerationResult {
+	const toolCall = extractToolCall(message, "create_changelog_entries");
+	if (toolCall) {
+		const parsed = validateToolCall([ChangelogTool], toolCall) as ChangelogGenerationResult;
+		return { entries: parsed.entries ?? {} };
+	}
+
+	const text = extractTextContent(message);
+	const parsed = parseJsonPayload(text) as ChangelogGenerationResult;
+	return { entries: parsed.entries ?? {} };
+}
+
+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();
+}
+
+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 changelog response");
+	}
+	return JSON.parse(match[0]) as unknown;
+}
+
+function dedupeEntries(entries: Record<string, string[]>): Record<string, string[]> {
+	const result: Record<string, string[]> = {};
+	for (const [category, values] of Object.entries(entries)) {
+		const seen = new Set<string>();
+		const cleaned: string[] = [];
+		for (const value of values) {
+			const trimmed = value.trim().replace(/\.$/, "");
+			const key = trimmed.toLowerCase();
+			if (!trimmed || seen.has(key)) continue;
+			seen.add(key);
+			cleaned.push(trimmed);
+		}
+		if (cleaned.length > 0) {
+			result[category] = cleaned;
+		}
+	}
+	return result;
+}

package/src/commit/changelog/index.ts

@@ -0,0 +1,233 @@
+import { relative, resolve } from "node:path";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { detectChangelogBoundaries } from "@oh-my-pi/pi-coding-agent/commit/changelog/detect";
+import { generateChangelogEntries } from "@oh-my-pi/pi-coding-agent/commit/changelog/generate";
+import { parseUnreleasedSection } from "@oh-my-pi/pi-coding-agent/commit/changelog/parse";
+import type { ControlledGit } from "@oh-my-pi/pi-coding-agent/commit/git";
+import { logger } from "@oh-my-pi/pi-utils";
+
+const CHANGELOG_SECTIONS = ["Breaking Changes", "Added", "Changed", "Deprecated", "Removed", "Fixed", "Security"];
+
+const DEFAULT_MAX_DIFF_CHARS = 120_000;
+
+export interface ChangelogFlowInput {
+	git: ControlledGit;
+	cwd: string;
+	model: Model<Api>;
+	apiKey: string;
+	stagedFiles: string[];
+	dryRun: boolean;
+	maxDiffChars?: number;
+	onProgress?: (message: string) => void;
+}
+
+export interface ChangelogProposalInput {
+	git: ControlledGit;
+	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({
+	git,
+	cwd,
+	model,
+	apiKey,
+	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.getDiffForFiles(boundary.files, true);
+		if (!diff.trim()) continue;
+		const stat = await git.getStatForFiles(boundary.files, true);
+		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 = resolve(boundary.changelogPath) !== resolve(cwd, "CHANGELOG.md");
+		const generated = await generateChangelogEntries({
+			model,
+			apiKey,
+			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.stageFiles([relative(cwd, boundary.changelogPath)]);
+		}
+		updated.push(boundary.changelogPath);
+	}
+
+	return updated;
+}
+
+/**
+ * Apply changelog entries provided by the commit agent.
+ */
+export async function applyChangelogProposals({
+	git,
+	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.stageFiles([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 "@oh-my-pi/pi-coding-agent/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,93 @@
+import type { CommitCommandArgs } from "@oh-my-pi/pi-coding-agent/commit/types";
+import chalk from "chalk";
+
+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("-")) {
+					writeStderr(chalk.red("Error: --context requires a value"));
+					process.exit(1);
+				}
+				result.context = value;
+				i += 1;
+				break;
+			}
+			case "--model": {
+				const value = args[i + 1];
+				if (!value || value.startsWith("-")) {
+					writeStderr(chalk.red("Error: --model requires a value"));
+					process.exit(1);
+				}
+				result.model = value;
+				i += 1;
+				break;
+			}
+			case "--help":
+			case "-h":
+				break;
+			default:
+				if (flag.startsWith("-")) {
+					writeStderr(chalk.red(`Error: Unknown flag ${flag}`));
+					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",
+	];
+	writeStdout(lines.join("\n"));
+}
+
+function writeStdout(message: string): void {
+	process.stdout.write(`${message}\n`);
+}
+
+function writeStderr(message: string): void {
+	process.stderr.write(`${message}\n`);
+}