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

package/src/commit/agentic/tools/propose-commit.ts

@@ -0,0 +1,154 @@
+import type { CommitAgentState } from "@oh-my-pi/pi-coding-agent/commit/agentic/state";
+import {
+	capDetails,
+	MAX_DETAIL_ITEMS,
+	normalizeSummary,
+	SUMMARY_MAX_CHARS,
+	validateSummaryRules,
+	validateTypeConsistency,
+} from "@oh-my-pi/pi-coding-agent/commit/agentic/validation";
+import { validateAnalysis } from "@oh-my-pi/pi-coding-agent/commit/analysis/validation";
+import type { ControlledGit } from "@oh-my-pi/pi-coding-agent/commit/git";
+import type { CommitType, ConventionalAnalysis, ConventionalDetail } from "@oh-my-pi/pi-coding-agent/commit/types";
+import type { CustomTool } from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
+import { Type } from "@sinclair/typebox";
+
+const commitTypeSchema = Type.Union([
+	Type.Literal("feat"),
+	Type.Literal("fix"),
+	Type.Literal("refactor"),
+	Type.Literal("perf"),
+	Type.Literal("docs"),
+	Type.Literal("test"),
+	Type.Literal("build"),
+	Type.Literal("ci"),
+	Type.Literal("chore"),
+	Type.Literal("style"),
+	Type.Literal("revert"),
+]);
+
+const detailSchema = 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()),
+});
+
+const proposeCommitSchema = Type.Object({
+	type: commitTypeSchema,
+	scope: Type.Union([Type.String(), Type.Null()]),
+	summary: Type.String(),
+	details: Type.Array(detailSchema),
+	issue_refs: Type.Array(Type.String()),
+});
+
+interface ProposalResponse {
+	valid: boolean;
+	errors: string[];
+	warnings: string[];
+	proposal?: {
+		type: CommitType;
+		scope: string | null;
+		summary: string;
+		details: ConventionalDetail[];
+		issue_refs: string[];
+	};
+}
+
+function normalizeDetails(
+	details: Array<{
+		text: string;
+		changelog_category?: ConventionalDetail["changelogCategory"];
+		user_visible?: boolean;
+	}>,
+): ConventionalDetail[] {
+	return details.map((detail) => ({
+		text: detail.text.trim(),
+		changelogCategory: detail.user_visible ? detail.changelog_category : undefined,
+		userVisible: detail.user_visible ?? false,
+	}));
+}
+
+export function createProposeCommitTool(
+	git: ControlledGit,
+	state: CommitAgentState,
+): CustomTool<typeof proposeCommitSchema> {
+	return {
+		name: "propose_commit",
+		label: "Propose Commit",
+		description: "Submit the final conventional commit proposal.",
+		parameters: proposeCommitSchema,
+		async execute(_toolCallId, params) {
+			const scope = params.scope?.trim() || null;
+			const summary = normalizeSummary(params.summary, params.type, scope);
+			const details = normalizeDetails(params.details);
+			const { details: cappedDetails, warnings: detailWarnings } = capDetails(details);
+			const analysis: ConventionalAnalysis = {
+				type: params.type,
+				scope,
+				details: cappedDetails,
+				issueRefs: params.issue_refs ?? [],
+			};
+
+			const summaryValidation = validateSummaryRules(summary);
+			const analysisValidation = validateAnalysis(analysis);
+			const stagedFiles = state.overview?.files ?? (await git.getStagedFiles());
+			const diffText = state.diffText ?? (await git.getDiff(true));
+			const typeValidation = validateTypeConsistency(params.type, stagedFiles, {
+				diffText,
+				summary,
+				details: cappedDetails,
+			});
+
+			const errors = [...summaryValidation.errors, ...analysisValidation.errors, ...typeValidation.errors];
+			const warnings = [...summaryValidation.warnings, ...detailWarnings, ...typeValidation.warnings];
+
+			const response: ProposalResponse = {
+				valid: errors.length === 0,
+				errors,
+				warnings,
+			};
+
+			if (response.valid) {
+				response.proposal = {
+					type: analysis.type,
+					scope: analysis.scope,
+					summary,
+					details: analysis.details,
+					issue_refs: analysis.issueRefs,
+				};
+				state.proposal = {
+					analysis,
+					summary,
+					warnings,
+				};
+			}
+
+			const text = JSON.stringify(
+				{
+					...response,
+					constraints: {
+						maxSummaryChars: SUMMARY_MAX_CHARS,
+						maxDetailItems: MAX_DETAIL_ITEMS,
+					},
+				},
+				null,
+				2,
+			);
+
+			return {
+				content: [{ type: "text", text }],
+				details: response,
+			};
+		},
+	};
+}

package/src/commit/agentic/tools/recent-commits.ts

@@ -0,0 +1,81 @@
+import type { ControlledGit } from "@oh-my-pi/pi-coding-agent/commit/git";
+import type { CustomTool } from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
+import { Type } from "@sinclair/typebox";
+
+const recentCommitsSchema = Type.Object({
+	count: Type.Optional(Type.Number({ description: "Number of commits to fetch", minimum: 1, maximum: 50 })),
+});
+
+interface RecentCommitStats {
+	scopeUsagePercent: number;
+	commonVerbs: Record<string, number>;
+	summaryLength: { min: number; max: number; average: number };
+	lowercaseSummaryPercent: number;
+	topScopes: Record<string, number>;
+}
+
+function extractSummary(subject: string): string {
+	const match = subject.match(/^[a-z]+(?:\([^)]+\))?:\s+(.*)$/i);
+	if (match?.[1]) return match[1].trim();
+	return subject.trim();
+}
+
+function extractScope(subject: string): string | null {
+	const match = subject.match(/^[a-z]+\(([^)]+)\):/i);
+	return match?.[1]?.trim() ?? null;
+}
+
+export function createRecentCommitsTool(git: ControlledGit): CustomTool<typeof recentCommitsSchema> {
+	return {
+		name: "recent_commits",
+		label: "Recent Commits",
+		description: "Return recent commit subjects with style statistics.",
+		parameters: recentCommitsSchema,
+		async execute(_toolCallId, params) {
+			const count = params.count ?? 8;
+			const commits = await git.getRecentCommits(count);
+			const verbs: Record<string, number> = {};
+			const scopes: Record<string, number> = {};
+			const lengths: number[] = [];
+			let scopeCount = 0;
+			let lowercaseCount = 0;
+
+			for (const subject of commits) {
+				const summary = extractSummary(subject);
+				const scope = extractScope(subject);
+				if (scope) {
+					scopeCount += 1;
+					scopes[scope] = (scopes[scope] ?? 0) + 1;
+				}
+				if (summary[0] && summary[0] === summary[0].toLowerCase()) {
+					lowercaseCount += 1;
+				}
+				const firstWord = summary.split(/\s+/)[0]?.toLowerCase();
+				if (firstWord) {
+					verbs[firstWord] = (verbs[firstWord] ?? 0) + 1;
+				}
+				lengths.push(summary.length);
+			}
+
+			const min = lengths.length > 0 ? Math.min(...lengths) : 0;
+			const max = lengths.length > 0 ? Math.max(...lengths) : 0;
+			const average = lengths.length > 0 ? lengths.reduce((sum, value) => sum + value, 0) / lengths.length : 0;
+			const scopeUsagePercent = commits.length > 0 ? Math.round((scopeCount / commits.length) * 100) : 0;
+			const lowercaseSummaryPercent = commits.length > 0 ? Math.round((lowercaseCount / commits.length) * 100) : 0;
+
+			const stats: RecentCommitStats = {
+				scopeUsagePercent,
+				commonVerbs: verbs,
+				summaryLength: { min, max, average: Number(average.toFixed(1)) },
+				lowercaseSummaryPercent,
+				topScopes: scopes,
+			};
+
+			const payload = { commits, stats };
+			return {
+				content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+				details: payload,
+			};
+		},
+	};
+}

package/src/commit/agentic/tools/split-commit.ts

@@ -0,0 +1,284 @@
+import type {
+	CommitAgentState,
+	SplitCommitGroup,
+	SplitCommitPlan,
+} from "@oh-my-pi/pi-coding-agent/commit/agentic/state";
+import { computeDependencyOrder } from "@oh-my-pi/pi-coding-agent/commit/agentic/topo-sort";
+import {
+	capDetails,
+	MAX_DETAIL_ITEMS,
+	normalizeSummary,
+	SUMMARY_MAX_CHARS,
+	validateSummaryRules,
+	validateTypeConsistency,
+} from "@oh-my-pi/pi-coding-agent/commit/agentic/validation";
+import { validateScope } from "@oh-my-pi/pi-coding-agent/commit/analysis/validation";
+import type { ControlledGit } from "@oh-my-pi/pi-coding-agent/commit/git";
+import type { ConventionalDetail } from "@oh-my-pi/pi-coding-agent/commit/types";
+import type { CustomTool } from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
+import { Type } from "@sinclair/typebox";
+
+const commitTypeSchema = Type.Union([
+	Type.Literal("feat"),
+	Type.Literal("fix"),
+	Type.Literal("refactor"),
+	Type.Literal("perf"),
+	Type.Literal("docs"),
+	Type.Literal("test"),
+	Type.Literal("build"),
+	Type.Literal("ci"),
+	Type.Literal("chore"),
+	Type.Literal("style"),
+	Type.Literal("revert"),
+]);
+
+const detailSchema = 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()),
+});
+
+const hunkSelectorSchema = Type.Union([
+	Type.Object({ type: Type.Literal("all") }),
+	Type.Object({ type: Type.Literal("indices"), indices: Type.Array(Type.Number(), { minItems: 1 }) }),
+	Type.Object({ type: Type.Literal("lines"), start: Type.Number(), end: Type.Number() }),
+]);
+
+const fileChangeSchema = Type.Object({
+	path: Type.String(),
+	hunks: hunkSelectorSchema,
+});
+
+const splitCommitSchema = Type.Object({
+	commits: Type.Array(
+		Type.Object({
+			changes: Type.Array(fileChangeSchema, { minItems: 1 }),
+			type: commitTypeSchema,
+			scope: Type.Union([Type.String(), Type.Null()]),
+			summary: Type.String(),
+			details: Type.Optional(Type.Array(detailSchema)),
+			issue_refs: Type.Optional(Type.Array(Type.String())),
+			rationale: Type.Optional(Type.String()),
+			dependencies: Type.Optional(Type.Array(Type.Number())),
+		}),
+		{ minItems: 2 },
+	),
+});
+
+interface SplitCommitResponse {
+	valid: boolean;
+	errors: string[];
+	warnings: string[];
+	proposal?: SplitCommitPlan;
+}
+
+function normalizeDetails(
+	details: Array<{
+		text: string;
+		changelog_category?: ConventionalDetail["changelogCategory"];
+		user_visible?: boolean;
+	}>,
+): ConventionalDetail[] {
+	return details.map((detail) => ({
+		text: detail.text.trim(),
+		changelogCategory: detail.user_visible ? detail.changelog_category : undefined,
+		userVisible: detail.user_visible ?? false,
+	}));
+}
+
+export function createSplitCommitTool(
+	git: ControlledGit,
+	state: CommitAgentState,
+	changelogTargets: string[],
+): CustomTool<typeof splitCommitSchema> {
+	return {
+		name: "split_commit",
+		label: "Split Commit",
+		description: "Propose multiple atomic commits for unrelated changes.",
+		parameters: splitCommitSchema,
+		async execute(_toolCallId, params) {
+			const stagedFiles = state.overview?.files ?? (await git.getStagedFiles());
+			const stagedSet = new Set(stagedFiles);
+			const changelogSet = new Set(changelogTargets);
+			const usedFiles = new Set<string>();
+			const errors: string[] = [];
+			const warnings: string[] = [];
+			const diffText = await git.getDiff(true);
+
+			const commits: SplitCommitGroup[] = params.commits.map((commit, index) => {
+				const scope = commit.scope?.trim() || null;
+				const summary = normalizeSummary(commit.summary, commit.type, scope);
+				const detailInput = normalizeDetails(commit.details ?? []);
+				const detailResult = capDetails(detailInput);
+				warnings.push(...detailResult.warnings.map((warning) => `Commit ${index + 1}: ${warning}`));
+				const issueRefs = commit.issue_refs ?? [];
+				const dependencies = (commit.dependencies ?? []).map((dep) => Math.floor(dep));
+				const changes = commit.changes.map((change) => ({
+					path: change.path,
+					hunks: change.hunks,
+				}));
+				const files = changes.map((change) => change.path);
+
+				const summaryValidation = validateSummaryRules(summary);
+				const scopeValidation = validateScope(scope);
+				const typeValidation = validateTypeConsistency(commit.type, files, {
+					diffText,
+					summary,
+					details: detailResult.details,
+				});
+
+				if (summaryValidation.errors.length > 0) {
+					errors.push(...summaryValidation.errors.map((error) => `Commit ${index + 1}: ${error}`));
+				}
+				if (!scopeValidation.valid) {
+					errors.push(...scopeValidation.errors.map((error) => `Commit ${index + 1}: ${error}`));
+				}
+				if (typeValidation.errors.length > 0) {
+					errors.push(...typeValidation.errors.map((error) => `Commit ${index + 1}: ${error}`));
+				}
+				warnings.push(...summaryValidation.warnings.map((warning) => `Commit ${index + 1}: ${warning}`));
+				warnings.push(...typeValidation.warnings.map((warning) => `Commit ${index + 1}: ${warning}`));
+				const hunkValidation = validateHunkSelectors(index, changes, files);
+				warnings.push(...hunkValidation.warnings);
+				errors.push(...hunkValidation.errors);
+				errors.push(...validateDependencies(index, dependencies, params.commits.length));
+
+				return {
+					changes,
+					type: commit.type,
+					scope,
+					summary,
+					details: detailResult.details,
+					issueRefs,
+					rationale: commit.rationale?.trim() || undefined,
+					dependencies,
+				};
+			});
+
+			for (const commit of commits) {
+				const seen = new Set<string>();
+				for (const change of commit.changes) {
+					const file = change.path;
+					if (!stagedSet.has(file) && !changelogSet.has(file)) {
+						errors.push(`File not staged: ${file}`);
+						continue;
+					}
+					if (seen.has(file)) {
+						errors.push(`File listed multiple times in commit ${commit.summary}: ${file}`);
+						continue;
+					}
+					if (usedFiles.has(file)) {
+						errors.push(`File appears in multiple commits: ${file}`);
+						continue;
+					}
+					seen.add(file);
+					usedFiles.add(file);
+				}
+			}
+
+			for (const file of stagedFiles) {
+				if (!usedFiles.has(file)) {
+					errors.push(`Staged file missing from split plan: ${file}`);
+				}
+			}
+
+			const dependencyCheck = computeDependencyOrder(commits);
+			if ("error" in dependencyCheck) {
+				errors.push(dependencyCheck.error);
+			}
+
+			const response: SplitCommitResponse = {
+				valid: errors.length === 0,
+				errors,
+				warnings,
+			};
+
+			if (response.valid) {
+				response.proposal = { commits, warnings };
+				state.splitProposal = response.proposal;
+			}
+
+			const text = JSON.stringify(
+				{
+					...response,
+					constraints: {
+						maxSummaryChars: SUMMARY_MAX_CHARS,
+						maxDetailItems: MAX_DETAIL_ITEMS,
+					},
+				},
+				null,
+				2,
+			);
+
+			return {
+				content: [{ type: "text", text }],
+				details: response,
+			};
+		},
+	};
+}
+
+function validateHunkSelectors(
+	commitIndex: number,
+	changes: SplitCommitGroup["changes"],
+	files: string[],
+): { errors: string[]; warnings: string[] } {
+	const errors: string[] = [];
+	const warnings: string[] = [];
+	const prefix = `Commit ${commitIndex + 1}`;
+	if (files.length === 0) {
+		errors.push(`${prefix}: no files specified`);
+		return { errors, warnings };
+	}
+	for (const change of changes) {
+		if (change.hunks.type === "indices") {
+			const invalid = change.hunks.indices.filter(
+				(value) => !Number.isFinite(value) || Math.floor(value) !== value || value < 1,
+			);
+			if (invalid.length > 0) {
+				errors.push(`${prefix}: invalid hunk indices for ${change.path}`);
+			}
+			continue;
+		}
+		if (change.hunks.type === "lines") {
+			const { start, end } = change.hunks;
+			if (!Number.isFinite(start) || !Number.isFinite(end)) {
+				errors.push(`${prefix}: invalid line range for ${change.path}`);
+				continue;
+			}
+			if (Math.floor(start) !== start || Math.floor(end) !== end || start < 1 || end < start) {
+				errors.push(`${prefix}: invalid line range for ${change.path}`);
+			}
+		}
+	}
+	return { errors, warnings };
+}
+
+function validateDependencies(commitIndex: number, dependencies: number[], totalCommits: number): string[] {
+	const errors: string[] = [];
+	const prefix = `Commit ${commitIndex + 1}`;
+	for (const dependency of dependencies) {
+		if (!Number.isFinite(dependency) || Math.floor(dependency) !== dependency) {
+			errors.push(`${prefix}: dependency index must be an integer`);
+			continue;
+		}
+		if (dependency === commitIndex) {
+			errors.push(`${prefix}: cannot depend on itself`);
+			continue;
+		}
+		if (dependency < 0 || dependency >= totalCommits) {
+			errors.push(`${prefix}: dependency index out of range (${dependency})`);
+		}
+	}
+	return errors;
+}

package/src/commit/agentic/topo-sort.ts

@@ -0,0 +1,44 @@
+import type { SplitCommitGroup } from "@oh-my-pi/pi-coding-agent/commit/agentic/state";
+
+export function computeDependencyOrder(groups: SplitCommitGroup[]): number[] | { error: string } {
+	const total = groups.length;
+	const inDegree = new Array<number>(total).fill(0);
+	const edges = Array.from({ length: total }, () => new Set<number>());
+
+	for (let index = 0; index < total; index += 1) {
+		const dependencies = groups[index]?.dependencies ?? [];
+		for (const dependency of dependencies) {
+			if (dependency < 0 || dependency >= total) {
+				return { error: `Invalid dependency index: ${dependency}` };
+			}
+			if (!edges[dependency]?.has(index)) {
+				edges[dependency]?.add(index);
+				inDegree[index] += 1;
+			}
+		}
+	}
+
+	const queue: number[] = [];
+	for (let index = 0; index < total; index += 1) {
+		if (inDegree[index] === 0) queue.push(index);
+	}
+
+	const order: number[] = [];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (current === undefined) break;
+		order.push(current);
+		for (const next of edges[current] ?? []) {
+			inDegree[next] -= 1;
+			if (inDegree[next] === 0) {
+				queue.push(next);
+			}
+		}
+	}
+
+	if (order.length !== total) {
+		return { error: "Circular dependency detected in split commit plan." };
+	}
+
+	return order;
+}

package/src/commit/agentic/trivial.ts

@@ -0,0 +1,51 @@
+import type { CommitType } from "@oh-my-pi/pi-coding-agent/commit/types";
+
+export interface TrivialChangeResult {
+	isTrivial: true;
+	type: CommitType;
+	summary: string;
+}
+
+const WHITESPACE_ONLY_PATTERN = /^[-+][\t ]*$/;
+const IMPORT_LINE_PATTERN = /^[-+]\s*(import\s|from\s|export\s.*from|require\(|module\.exports)/;
+const EMPTY_LINE_PATTERN = /^[-+]\s*$/;
+
+export function detectTrivialChange(diff: string): TrivialChangeResult | null {
+	const lines = diff.split("\n");
+	const changeLines = lines.filter((line) => line.startsWith("+") || line.startsWith("-"));
+	const contentLines = changeLines.filter(
+		(line) => !line.startsWith("+++") && !line.startsWith("---") && !line.startsWith("@@"),
+	);
+
+	if (contentLines.length === 0) return null;
+
+	if (isOnlyWhitespace(contentLines)) {
+		return { isTrivial: true, type: "style", summary: "formatted code" };
+	}
+
+	if (isOnlyImports(contentLines)) {
+		return { isTrivial: true, type: "style", summary: "reorganized imports" };
+	}
+
+	return null;
+}
+
+function isOnlyWhitespace(lines: string[]): boolean {
+	for (const line of lines) {
+		const content = line.slice(1);
+		if (content.trim().length > 0 && !WHITESPACE_ONLY_PATTERN.test(line)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function isOnlyImports(lines: string[]): boolean {
+	for (const line of lines) {
+		if (EMPTY_LINE_PATTERN.test(line)) continue;
+		if (!IMPORT_LINE_PATTERN.test(line)) {
+			return false;
+		}
+	}
+	return true;
+}