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

package/src/commit/agentic/validation.ts

@@ -0,0 +1,200 @@
+import { stripTypePrefix } from "@oh-my-pi/pi-coding-agent/commit/analysis/summary";
+import { validateSummary } from "@oh-my-pi/pi-coding-agent/commit/analysis/validation";
+import type { CommitType, ConventionalDetail } from "@oh-my-pi/pi-coding-agent/commit/types";
+
+export const SUMMARY_MAX_CHARS = 72;
+export const MAX_DETAIL_ITEMS = 6;
+
+const fillerWords = ["comprehensive", "various", "several", "improved", "enhanced", "better"];
+const metaPhrases = ["this commit", "this change", "updated code", "modified files"];
+const pastTenseVerbs = new Set([
+	"added",
+	"adjusted",
+	"aligned",
+	"bumped",
+	"changed",
+	"cleaned",
+	"clarified",
+	"consolidated",
+	"converted",
+	"corrected",
+	"created",
+	"deployed",
+	"deprecated",
+	"disabled",
+	"documented",
+	"dropped",
+	"enabled",
+	"expanded",
+	"extracted",
+	"fixed",
+	"hardened",
+	"implemented",
+	"improved",
+	"integrated",
+	"introduced",
+	"migrated",
+	"moved",
+	"optimized",
+	"patched",
+	"prevented",
+	"reduced",
+	"refactored",
+	"removed",
+	"renamed",
+	"reorganized",
+	"replaced",
+	"resolved",
+	"restored",
+	"restructured",
+	"reworked",
+	"secured",
+	"simplified",
+	"stabilized",
+	"standardized",
+	"streamlined",
+	"tightened",
+	"tuned",
+	"updated",
+	"upgraded",
+	"validated",
+]);
+const pastTenseEdExceptions = new Set(["hundred", "red", "bed"]);
+
+const unicodeReplacements: Array<[RegExp, string]> = [
+	[/[\u2018\u2019]/g, "'"],
+	[/[\u201C\u201D]/g, '"'],
+	[/[\u2013\u2014\u2212]/g, "-"],
+	[/\u2260/g, "!="],
+	[/\u00BD/g, "1/2"],
+	[/\u03BB/g, "lambda"],
+	[/[\u200B-\u200D\uFEFF]/g, ""],
+];
+
+export function normalizeSummary(summary: string, type: CommitType, scope: string | null): string {
+	const stripped = stripTypePrefix(summary, type, scope);
+	return normalizeUnicode(stripped).replace(/\s+/g, " ").trim();
+}
+
+export function normalizeUnicode(text: string): string {
+	let result = text;
+	for (const [pattern, replacement] of unicodeReplacements) {
+		result = result.replace(pattern, replacement);
+	}
+	return result.normalize("NFC");
+}
+
+export function validateSummaryRules(summary: string): { errors: string[]; warnings: string[] } {
+	const errors: string[] = [];
+	const warnings: string[] = [];
+	const basic = validateSummary(summary, SUMMARY_MAX_CHARS);
+	if (!basic.valid) {
+		errors.push(...basic.errors);
+	}
+
+	const words = summary.trim().split(/\s+/);
+	const firstWord = words[0]?.toLowerCase() ?? "";
+	const normalizedFirst = firstWord.replace(/[^a-z]/g, "");
+	const hasPastTense =
+		pastTenseVerbs.has(normalizedFirst) ||
+		(normalizedFirst.endsWith("ed") && !pastTenseEdExceptions.has(normalizedFirst));
+	if (!hasPastTense) {
+		errors.push("Summary must start with a past-tense verb");
+	}
+
+	const lowerSummary = summary.toLowerCase();
+	for (const word of fillerWords) {
+		if (lowerSummary.includes(word)) {
+			warnings.push(`Avoid filler word: ${word}`);
+		}
+	}
+	for (const phrase of metaPhrases) {
+		if (lowerSummary.includes(phrase)) {
+			warnings.push(`Avoid meta phrase: ${phrase}`);
+		}
+	}
+
+	return { errors, warnings };
+}
+
+export function capDetails(details: ConventionalDetail[]): { details: ConventionalDetail[]; warnings: string[] } {
+	if (details.length <= MAX_DETAIL_ITEMS) {
+		return { details, warnings: [] };
+	}
+
+	const scored = details.map((detail, index) => ({
+		detail,
+		index,
+		score: scoreDetail(detail.text),
+	}));
+
+	scored.sort((a, b) => b.score - a.score || a.index - b.index);
+	const keep = new Set(scored.slice(0, MAX_DETAIL_ITEMS).map((entry) => entry.index));
+	const kept = details.filter((_detail, index) => keep.has(index));
+	const warnings = [`Capped detail list to ${MAX_DETAIL_ITEMS} items based on priority scoring.`];
+	return { details: kept, warnings };
+}
+
+function scoreDetail(text: string): number {
+	const lower = text.toLowerCase();
+	let score = 0;
+	if (/(security|vulnerability|exploit|cve)/.test(lower)) score += 100;
+	if (/(breaking|incompatible)/.test(lower)) score += 90;
+	if (/(performance|optimization|optimiz|latency|throughput)/.test(lower)) score += 80;
+	if (/(bug|fix|crash|panic|regression|failure)/.test(lower)) score += 70;
+	if (/(api|interface|public|export)/.test(lower)) score += 50;
+	if (/(user|client|customer)/.test(lower)) score += 40;
+	if (/(deprecated|removed|delete)/.test(lower)) score += 35;
+	return score;
+}
+
+export function validateTypeConsistency(
+	type: CommitType,
+	files: string[],
+	options: { diffText?: string; summary?: string; details?: ConventionalDetail[] } = {},
+): { errors: string[]; warnings: string[] } {
+	const errors: string[] = [];
+	const warnings: string[] = [];
+	const lowerFiles = files.map((file) => file.toLowerCase());
+	const hasDocs = lowerFiles.some((file) => /\.(md|mdx|adoc|rst)$/.test(file));
+	const hasTests = lowerFiles.some(
+		(file) => /(^|\/)(test|tests|__tests__)(\/|$)/.test(file) || /(^|\/).*(_test|\.test|\.spec)\./.test(file),
+	);
+	const hasCI = lowerFiles.some((file) => file.startsWith(".github/workflows/") || file.startsWith(".gitlab-ci"));
+	const hasBuild = lowerFiles.some((file) =>
+		["cargo.toml", "package.json", "makefile"].some((candidate) => file.endsWith(candidate)),
+	);
+	const hasPerfEvidence = lowerFiles.some((file) => /(bench|benchmark|perf)/.test(file));
+	const summary = options.summary?.toLowerCase() ?? "";
+	const detailText = options.details?.map((detail) => detail.text.toLowerCase()).join(" ") ?? "";
+	const hasPerfKeywords = /(performance|optimiz|latency|throughput|benchmark)/.test(`${summary} ${detailText}`);
+
+	switch (type) {
+		case "docs":
+			if (!hasDocs) errors.push("Docs commit should include documentation file changes");
+			break;
+		case "test":
+			if (!hasTests) errors.push("Test commit should include test file changes");
+			break;
+		case "ci":
+			if (!hasCI) errors.push("CI commit should include CI configuration changes");
+			break;
+		case "build":
+			if (!hasBuild) errors.push("Build commit should include build-related files");
+			break;
+		case "refactor": {
+			const hasNewFiles = options.diffText ? /\nnew file mode\s/m.test(options.diffText) : false;
+			if (hasNewFiles) warnings.push("Refactor commit adds new files; consider feat if new functionality");
+			break;
+		}
+		case "perf":
+			if (!hasPerfEvidence && !hasPerfKeywords) {
+				warnings.push("Perf commit lacks benchmark or performance keywords");
+			}
+			break;
+		default:
+			break;
+	}
+
+	return { errors, warnings };
+}

package/src/commit/analysis/conventional.ts

@@ -0,0 +1,169 @@
+import type { Api, AssistantMessage, Model, ToolCall } from "@oh-my-pi/pi-ai";
+import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
+import analysisSystemPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/analysis-system.md" with { type: "text" };
+import analysisUserPrompt from "@oh-my-pi/pi-coding-agent/commit/prompts/analysis-user.md" with { type: "text" };
+import type {
+	ChangelogCategory,
+	ConventionalAnalysis,
+	ConventionalDetail,
+} 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 ConventionalAnalysisTool = {
+	name: "create_conventional_analysis",
+	description: "Analyze a diff and return conventional commit classification.",
+	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 ConventionalAnalysisInput {
+	model: Model<Api>;
+	apiKey: string;
+	contextFiles?: Array<{ path: string; content: string }>;
+	userContext?: string;
+	typesDescription?: string;
+	recentCommits?: string[];
+	scopeCandidates: string;
+	stat: string;
+	diff: string;
+}
+
+/**
+ * Generate conventional analysis data from a diff and metadata.
+ */
+export async function generateConventionalAnalysis({
+	model,
+	apiKey,
+	contextFiles,
+	userContext,
+	typesDescription,
+	recentCommits,
+	scopeCandidates,
+	stat,
+	diff,
+}: ConventionalAnalysisInput): Promise<ConventionalAnalysis> {
+	const prompt = renderPromptTemplate(analysisUserPrompt, {
+		context_files: contextFiles && contextFiles.length > 0 ? contextFiles : undefined,
+		user_context: userContext,
+		types_description: typesDescription,
+		recent_commits: recentCommits?.join("\n"),
+		scope_candidates: scopeCandidates,
+		stat,
+		diff,
+	});
+
+	const response = await completeSimple(
+		model,
+		{
+			systemPrompt: renderPromptTemplate(analysisSystemPrompt),
+			messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+			tools: [ConventionalAnalysisTool],
+		},
+		{ apiKey, maxTokens: 2400 },
+	);
+
+	return parseAnalysisFromResponse(response);
+}
+
+function parseAnalysisFromResponse(message: AssistantMessage): ConventionalAnalysis {
+	const toolCall = extractToolCall(message, "create_conventional_analysis");
+	if (toolCall) {
+		const parsed = validateToolCall([ConventionalAnalysisTool], 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 normalizeAnalysis(parsed: {
+	type: ConventionalAnalysis["type"];
+	scope: string | null;
+	details: Array<{ text: string; changelog_category?: ChangelogCategory; user_visible?: boolean }>;
+	issue_refs: string[];
+}): ConventionalAnalysis {
+	const details: ConventionalDetail[] = parsed.details.map((detail) => ({
+		text: detail.text.trim(),
+		changelogCategory: detail.user_visible ? detail.changelog_category : undefined,
+		userVisible: detail.user_visible ?? false,
+	}));
+	return {
+		type: parsed.type,
+		scope: parsed.scope?.trim() || null,
+		details,
+		issueRefs: parsed.issue_refs ?? [],
+	};
+}
+
+function extractToolCall(message: AssistantMessage, name: string): ToolCall | undefined {
+	for (const content of message.content) {
+		if (content.type === "toolCall" && content.name === name) {
+			return content;
+		}
+	}
+	return 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 analysis response");
+	}
+	return JSON.parse(match[0]) as unknown;
+}

package/src/commit/analysis/index.ts

@@ -0,0 +1,4 @@
+export { generateConventionalAnalysis } from "@oh-my-pi/pi-coding-agent/commit/analysis/conventional";
+export { extractScopeCandidates } from "@oh-my-pi/pi-coding-agent/commit/analysis/scope";
+export { generateSummary, stripTypePrefix } from "@oh-my-pi/pi-coding-agent/commit/analysis/summary";
+export { validateAnalysis, validateScope, validateSummary } from "@oh-my-pi/pi-coding-agent/commit/analysis/validation";

package/src/commit/analysis/scope.ts

@@ -0,0 +1,242 @@
+import type { NumstatEntry } from "@oh-my-pi/pi-coding-agent/commit/types";
+import { isExcludedFile } from "@oh-my-pi/pi-coding-agent/commit/utils/exclusions";
+
+interface ScopeCandidate {
+	path: string;
+	percentage: number;
+	confidence: number;
+}
+
+const PLACEHOLDER_DIRS = new Set([
+	"src",
+	"lib",
+	"bin",
+	"crates",
+	"benches",
+	"examples",
+	"internal",
+	"pkg",
+	"include",
+	"tests",
+	"test",
+	"docs",
+	"packages",
+	"modules",
+]);
+
+const SKIP_DIRS = new Set(["test", "tests", "benches", "examples", "target", "build", "node_modules", ".github"]);
+
+export interface ScopeCandidatesResult {
+	scopeCandidates: string;
+	isWide: boolean;
+}
+
+export function extractScopeCandidates(numstat: NumstatEntry[]): ScopeCandidatesResult {
+	const componentLines = new Map<string, number>();
+	const paths: string[] = [];
+	const distinctRoots = new Set<string>();
+	let totalLines = 0;
+
+	for (const entry of numstat) {
+		const linesChanged = entry.additions + entry.deletions;
+		if (linesChanged === 0) continue;
+		const normalizedPath = normalizePathForScope(entry.path);
+		if (isExcludedFile(normalizedPath)) continue;
+		paths.push(normalizedPath);
+		const root = extractTopLevelRoot(normalizedPath);
+		if (root) {
+			distinctRoots.add(root);
+		}
+		totalLines += linesChanged;
+		const components = extractComponentsFromPath(normalizedPath);
+		for (const component of components) {
+			if (component.split("/").some((segment) => segment.includes("."))) {
+				continue;
+			}
+			componentLines.set(component, (componentLines.get(component) ?? 0) + linesChanged);
+		}
+	}
+
+	if (totalLines === 0) {
+		return { scopeCandidates: "(none - no measurable changes)", isWide: false };
+	}
+
+	const candidates = buildScopeCandidates(componentLines, totalLines);
+	const isWide = isWideChange(candidates, 0.6, distinctRoots.size);
+	if (isWide) {
+		const pattern = analyzeWideChange(paths);
+		if (pattern) {
+			return { scopeCandidates: `(cross-cutting: ${pattern})`, isWide: true };
+		}
+		return { scopeCandidates: "(none - multi-component change)", isWide: true };
+	}
+
+	const suggestionParts: string[] = [];
+	for (const candidate of candidates.slice(0, 5)) {
+		if (candidate.percentage < 10) continue;
+		const confidenceLabel = candidate.path.includes("/")
+			? candidate.percentage > 60
+				? "high confidence"
+				: "moderate confidence"
+			: "high confidence";
+		suggestionParts.push(`${candidate.path} (${candidate.percentage.toFixed(0)}%, ${confidenceLabel})`);
+	}
+
+	const scopeCandidates =
+		suggestionParts.length === 0
+			? "(none - unclear component)"
+			: `${suggestionParts.join(", ")}\nPrefer 2-segment scopes marked 'high confidence'`;
+
+	return { scopeCandidates, isWide: false };
+}
+
+function buildScopeCandidates(componentLines: Map<string, number>, totalLines: number): ScopeCandidate[] {
+	const candidates: ScopeCandidate[] = [];
+	for (const [path, lines] of componentLines.entries()) {
+		if (!path.includes("/") && PLACEHOLDER_DIRS.has(path)) continue;
+		const root = path.split("/")[0] ?? "";
+		if (PLACEHOLDER_DIRS.has(root)) continue;
+		const percentage = (lines / totalLines) * 100;
+		const isTwoSegment = path.includes("/");
+		const confidence = isTwoSegment ? (percentage > 60 ? percentage * 1.2 : percentage * 0.8) : percentage;
+		candidates.push({ path, percentage, confidence });
+	}
+	return candidates.sort((a, b) => b.confidence - a.confidence);
+}
+
+function isWideChange(candidates: ScopeCandidate[], threshold: number, distinctRoots: number): boolean {
+	if (distinctRoots >= 3) return true;
+	const top = candidates[0];
+	if (!top) return false;
+	return top.percentage / 100 < threshold;
+}
+
+function extractComponentsFromPath(path: string): string[] {
+	const segments = path.split("/");
+	const meaningful: string[] = [];
+
+	const stripExt = (segment: string): string => {
+		const index = segment.lastIndexOf(".");
+		return index > 0 ? segment.slice(0, index) : segment;
+	};
+
+	const isFile = (segment: string): boolean => {
+		return segment.includes(".") && !segment.startsWith(".") && segment.lastIndexOf(".") > 0;
+	};
+
+	for (let index = 0; index < segments.length; index += 1) {
+		const segment = segments[index] ?? "";
+		if (PLACEHOLDER_DIRS.has(segment) && segments.length > index + 1) {
+			continue;
+		}
+		if (isFile(segment)) continue;
+		if (SKIP_DIRS.has(segment)) continue;
+
+		const stripped = stripExt(segment);
+		if (stripped && !stripped.startsWith(".")) {
+			meaningful.push(stripped);
+		}
+	}
+
+	const components: string[] = [];
+	if (meaningful.length > 0) {
+		components.push(meaningful[0]!);
+		if (meaningful.length >= 2) {
+			components.push(`${meaningful[0]}/${meaningful[1]}`);
+		}
+	}
+
+	return components;
+}
+
+function extractTopLevelRoot(path: string): string | null {
+	const segments = path.split("/").filter((segment) => segment.length > 0);
+	if (segments.length === 0) return null;
+	if (segments.length === 1) {
+		return segments[0]!.startsWith(".") ? null : "(root)";
+	}
+
+	for (let index = 0; index < segments.length; index += 1) {
+		const segment = segments[index] ?? "";
+		if (PLACEHOLDER_DIRS.has(segment) && segments.length > index + 1) {
+			continue;
+		}
+		if (SKIP_DIRS.has(segment)) continue;
+		if (segment.startsWith(".")) continue;
+		return segment;
+	}
+
+	return null;
+}
+
+function normalizePathForScope(path: string): string {
+	const braceStart = path.indexOf("{");
+	if (braceStart !== -1) {
+		const arrowPos = path.indexOf(" => ", braceStart);
+		if (arrowPos !== -1) {
+			const braceEnd = path.indexOf("}", arrowPos);
+			if (braceEnd !== -1) {
+				const prefix = path.slice(0, braceStart);
+				const newName = path.slice(arrowPos + 4, braceEnd).trim();
+				return `${prefix}${newName}`;
+			}
+		}
+	}
+
+	if (path.includes(" => ")) {
+		const parts = path.split(" => ");
+		return parts[1]?.trim() ?? path.trim();
+	}
+
+	return path.trim();
+}
+
+function analyzeWideChange(paths: string[]): string | null {
+	if (paths.length === 0) return null;
+	const total = paths.length;
+	let mdCount = 0;
+	let testCount = 0;
+	let configCount = 0;
+	let hasCargoToml = false;
+	let hasPackageJson = false;
+	let errorKeywords = 0;
+	let typeKeywords = 0;
+
+	for (const path of paths) {
+		const lowerPath = path.toLowerCase();
+		if (lowerPath.endsWith(".md")) {
+			mdCount += 1;
+		}
+		if (lowerPath.includes("/test") || lowerPath.includes("_test.")) {
+			testCount += 1;
+		}
+		if (
+			lowerPath.endsWith(".toml") ||
+			lowerPath.endsWith(".yaml") ||
+			lowerPath.endsWith(".yml") ||
+			lowerPath.endsWith(".json")
+		) {
+			configCount += 1;
+		}
+		if (path.includes("Cargo.toml")) {
+			hasCargoToml = true;
+		}
+		if (path.includes("package.json")) {
+			hasPackageJson = true;
+		}
+		if (lowerPath.includes("error") || lowerPath.includes("result") || lowerPath.includes("err")) {
+			errorKeywords += 1;
+		}
+		if (lowerPath.includes("type") || lowerPath.includes("struct") || lowerPath.includes("enum")) {
+			typeKeywords += 1;
+		}
+	}
+
+	if (hasCargoToml || hasPackageJson) return "deps";
+	if ((mdCount * 100) / total > 70) return "docs";
+	if ((testCount * 100) / total > 60) return "tests";
+	if ((errorKeywords * 100) / total > 40) return "error-handling";
+	if ((typeKeywords * 100) / total > 40) return "type-refactor";
+	if ((configCount * 100) / total > 50) return "config";
+	return null;
+}