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

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

@@ -0,0 +1,17 @@
+{{#if types_description}}
+<type_definitions>
+{{ types_description }}
+</type_definitions>
+{{/if}}
+
+<observations>
+{{ observations }}
+</observations>
+
+<diff_statistics>
+{{ stat }}
+</diff_statistics>
+
+<scope_candidates>
+{{ scope_candidates }}
+</scope_candidates>

package/src/commit/prompts/summary-retry.md

@@ -0,0 +1,4 @@
+{{#if base_context}}
+{{ base_context }}
+
+{{/if}}Previous summary failed validation: {{ errors }}

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

@@ -0,0 +1,52 @@
+You are a commit message specialist generating precise, informative descriptions.
+
+<context>
+Output: ONLY the description after "{{ commit_type }}{{ scope_prefix }}:".
+Constraint: {{ chars }} characters max, no trailing period, no type prefix in output.
+</context>
+
+<instructions>
+1. Start with lowercase past-tense verb (must differ from "{{ commit_type }}")
+2. Name the specific subsystem/component affected
+3. Include WHY when it clarifies intent
+4. One focused concept per message
+
+Get this right.
+</instructions>
+
+<verb_reference>
+| Type     | Use instead                                     |
+|----------|-------------------------------------------------|
+| feat     | added, introduced, implemented, enabled         |
+| fix      | corrected, resolved, patched, addressed         |
+| refactor | restructured, reorganized, migrated, simplified |
+| perf     | optimized, reduced, eliminated, accelerated     |
+| docs     | documented, clarified, expanded                 |
+| build    | upgraded, pinned, configured                    |
+| chore    | cleaned, removed, renamed, organized            |
+</verb_reference>
+
+<examples>
+feat | TLS encryption added to HTTP client for MITM prevention
+-> added TLS support to prevent man-in-the-middle attacks
+
+refactor | Consolidated HTTP transport into unified builder pattern
+-> migrated HTTP transport to unified builder API
+
+fix | Race condition in connection pool causing exhaustion under load
+-> corrected race condition causing connection pool exhaustion
+
+perf | Batch processing optimized to reduce memory allocations
+-> eliminated allocation overhead in batch processing
+
+build | Updated serde to fix CVE-2024-1234
+-> upgraded serde to 1.0.200 for CVE-2024-1234
+</examples>
+
+<banned_words>
+comprehensive, various, several, improved, enhanced, quickly, simply, basically, this change, this commit, now
+</banned_words>
+
+<output_format>
+Output the description text only. Include motivation, name specifics, stay focused.
+</output_format>

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

@@ -0,0 +1,13 @@
+{{#if user_context}}
+<user_context>
+{{ user_context }}
+</user_context>
+{{/if}}
+
+<detail_points>
+{{ details }}
+</detail_points>
+
+<diff_stat>
+{{ stat }}
+</diff_stat>

package/src/commit/prompts/types-description.md

@@ -0,0 +1,2 @@
+Types: feat, fix, refactor, perf, docs, test, build, ci, chore, style, revert.
+Format: <type>(<scope>): <summary> with past-tense summary.

package/src/commit/types.ts

@@ -0,0 +1,109 @@
+/**
+ * Types for the omp commit pipeline.
+ */
+
+export type CommitType =
+	| "feat"
+	| "fix"
+	| "refactor"
+	| "perf"
+	| "docs"
+	| "test"
+	| "build"
+	| "ci"
+	| "chore"
+	| "style"
+	| "revert";
+
+export type ChangelogCategory =
+	| "Breaking Changes"
+	| "Added"
+	| "Changed"
+	| "Deprecated"
+	| "Removed"
+	| "Fixed"
+	| "Security";
+
+export interface CommitCommandArgs {
+	/** Push after commit */
+	push: boolean;
+	/** Preview without committing */
+	dryRun: boolean;
+	/** Skip changelog updates */
+	noChangelog: boolean;
+	/** Use legacy deterministic pipeline */
+	legacy?: boolean;
+	/** Additional user context for the model */
+	context?: string;
+	/** Override the model selection */
+	model?: string;
+}
+
+export interface NumstatEntry {
+	path: string;
+	additions: number;
+	deletions: number;
+}
+
+export interface ConventionalDetail {
+	text: string;
+	changelogCategory?: ChangelogCategory;
+	userVisible: boolean;
+}
+
+export interface ConventionalAnalysis {
+	type: CommitType;
+	scope: string | null;
+	details: ConventionalDetail[];
+	issueRefs: string[];
+}
+
+export interface CommitSummary {
+	summary: string;
+}
+
+export interface FileObservation {
+	file: string;
+	observations: string[];
+	additions: number;
+	deletions: number;
+}
+
+export interface FileDiff {
+	filename: string;
+	content: string;
+	additions: number;
+	deletions: number;
+	isBinary: boolean;
+}
+
+export interface DiffHunk {
+	index: number;
+	header: string;
+	oldStart: number;
+	oldLines: number;
+	newStart: number;
+	newLines: number;
+	content: string;
+}
+
+export interface FileHunks {
+	filename: string;
+	isBinary: boolean;
+	hunks: DiffHunk[];
+}
+
+export interface ChangelogBoundary {
+	changelogPath: string;
+	files: string[];
+}
+
+export interface UnreleasedSection {
+	startLine: number;
+	endLine: number;
+	entries: Record<string, string[]>;
+}
+
+export interface ChangelogGenerationResult {
+	entries: Record<string, string[]>;
+}

package/src/commit/utils/exclusions.ts

@@ -0,0 +1,42 @@
+const EXCLUDED_FILES = [
+	"Cargo.lock",
+	"package-lock.json",
+	"npm-shrinkwrap.json",
+	"yarn.lock",
+	"pnpm-lock.yaml",
+	"shrinkwrap.yaml",
+	"bun.lock",
+	"bun.lockb",
+	"deno.lock",
+	"composer.lock",
+	"Gemfile.lock",
+	"poetry.lock",
+	"Pipfile.lock",
+	"pdm.lock",
+	"uv.lock",
+	"go.sum",
+	"flake.lock",
+	"pubspec.lock",
+	"Podfile.lock",
+	"Packages.resolved",
+	"mix.lock",
+	"packages.lock.json",
+	"config.yml.lock",
+	"config.yaml.lock",
+	"settings.yml.lock",
+	"settings.yaml.lock",
+];
+
+const EXCLUDED_SUFFIXES = [".lock.yml", ".lock.yaml", "-lock.yml", "-lock.yaml"];
+
+export function isExcludedFile(path: string): boolean {
+	const lower = path.toLowerCase();
+	if (EXCLUDED_FILES.some(name => lower.endsWith(name.toLowerCase()))) {
+		return true;
+	}
+	return EXCLUDED_SUFFIXES.some(suffix => lower.endsWith(suffix));
+}
+
+export function filterExcludedFiles<T extends { filename: string }>(files: T[]): T[] {
+	return files.filter(file => !isExcludedFile(file.filename));
+}

package/src/config/file-lock.ts

@@ -0,0 +1,121 @@
+import * as fs from "node:fs/promises";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+
+export interface FileLockOptions {
+	staleMs?: number;
+	retries?: number;
+	retryDelayMs?: number;
+}
+
+const DEFAULT_OPTIONS: Required<FileLockOptions> = {
+	staleMs: 10_000,
+	retries: 50,
+	retryDelayMs: 100,
+};
+
+interface LockInfo {
+	pid: number;
+	timestamp: number;
+}
+
+function getLockPath(filePath: string): string {
+	return `${filePath}.lock`;
+}
+
+async function writeLockInfo(lockPath: string): Promise<void> {
+	const info: LockInfo = { pid: process.pid, timestamp: Date.now() };
+	await Bun.write(`${lockPath}/info`, JSON.stringify(info));
+}
+
+async function readLockInfo(lockPath: string): Promise<LockInfo | null> {
+	try {
+		const content = await fs.readFile(`${lockPath}/info`, "utf-8");
+		return JSON.parse(content) as LockInfo;
+	} catch {
+		return null;
+	}
+}
+
+function isProcessAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function isLockStale(lockPath: string, staleMs: number): Promise<boolean> {
+	const info = await readLockInfo(lockPath);
+	if (!info) return true;
+
+	if (!isProcessAlive(info.pid)) return true;
+
+	if (Date.now() - info.timestamp > staleMs) return true;
+
+	return false;
+}
+
+async function tryAcquireLock(lockPath: string): Promise<boolean> {
+	try {
+		await fs.mkdir(lockPath);
+		await writeLockInfo(lockPath);
+		return true;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "EEXIST") {
+			return false;
+		}
+		throw error;
+	}
+}
+
+async function releaseLock(lockPath: string): Promise<void> {
+	try {
+		await fs.rm(lockPath, { recursive: true });
+	} catch {
+		// Ignore errors on release
+	}
+}
+
+async function lockExists(lockPath: string): Promise<boolean> {
+	try {
+		await fs.stat(lockPath);
+		return true;
+	} catch (err) {
+		if (isEnoent(err)) return false;
+		throw err;
+	}
+}
+
+async function acquireLock(filePath: string, options: FileLockOptions = {}): Promise<() => Promise<void>> {
+	const opts = { ...DEFAULT_OPTIONS, ...options };
+	const lockPath = getLockPath(filePath);
+
+	for (let attempt = 0; attempt < opts.retries; attempt++) {
+		if (await tryAcquireLock(lockPath)) {
+			return () => releaseLock(lockPath);
+		}
+
+		if ((await lockExists(lockPath)) && (await isLockStale(lockPath, opts.staleMs))) {
+			await releaseLock(lockPath);
+			continue;
+		}
+
+		await new Promise(resolve => setTimeout(resolve, opts.retryDelayMs));
+	}
+
+	throw new Error(`Failed to acquire lock for ${filePath} after ${opts.retries} attempts`);
+}
+
+export async function withFileLock<T>(
+	filePath: string,
+	fn: () => Promise<T>,
+	options: FileLockOptions = {},
+): Promise<T> {
+	const release = await acquireLock(filePath, options);
+	try {
+		return await fn();
+	} finally {
+		await release();
+	}
+}

package/src/config/keybindings.ts

@@ -1,6 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { getAgentDir } from "@oh-my-pi/pi-coding-agent/config";
+import * as path from "node:path";
 import {
 	DEFAULT_EDITOR_KEYBINDINGS,
 	type EditorAction,
@@ -11,6 +9,7 @@ import {
 	setEditorKeybindings,
 } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
+import { getAgentDir } from "../config";
 
 /**
  * Application-level actions (coding agent specific).
@@ -162,7 +161,7 @@ export class KeybindingsManager {
 	 * Create from config file and set up editor keybindings.
 	 */
 	static async create(agentDir: string = getAgentDir()): Promise<KeybindingsManager> {
-		const configPath = join(agentDir, "keybindings.json");
+		const configPath = path.join(agentDir, "keybindings.json");
 		const config = await KeybindingsManager.loadFromFile(configPath);
 		const manager = new KeybindingsManager(config);
 
@@ -186,9 +185,8 @@ export class KeybindingsManager {
 	}
 
 	private static async loadFromFile(path: string): Promise<KeybindingsConfig> {
-		if (!existsSync(path)) return {};
 		try {
-			return JSON.parse(readFileSync(path, "utf-8"));
+			return await Bun.file(path).json();
 		} catch (error) {
 			logger.warn("Failed to parse keybindings config", { path, error: String(error) });
 			return {};
@@ -203,7 +201,7 @@ export class KeybindingsManager {
 			const keyArray = Array.isArray(keys) ? keys : [keys];
 			this.appActionToKeys.set(
 				action as AppAction,
-				keyArray.map((key) => normalizeKeyId(key as KeyId)),
+				keyArray.map(key => normalizeKeyId(key as KeyId)),
 			);
 		}
 
@@ -213,7 +211,7 @@ export class KeybindingsManager {
 			const keyArray = Array.isArray(keys) ? keys : [keys];
 			this.appActionToKeys.set(
 				action,
-				keyArray.map((key) => normalizeKeyId(key as KeyId)),
+				keyArray.map(key => normalizeKeyId(key as KeyId)),
 			);
 		}
 	}

package/src/config/model-registry.ts

@@ -1,8 +1,8 @@
 /**
  * Model registry - manages built-in and custom models, provides API key resolution.
  */
-
-import { existsSync, readFileSync } from "node:fs";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import {
 	type Api,
 	getGitHubCopilotBaseUrl,
@@ -11,10 +11,11 @@ import {
 	type Model,
 	normalizeDomain,
 } from "@oh-my-pi/pi-ai";
-import type { AuthStorage } from "@oh-my-pi/pi-coding-agent/session/auth-storage";
-import { logger } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import AjvModule from "ajv";
+import { YAML } from "bun";
+import type { AuthStorage } from "../session/auth-storage";
 
 const Ajv = (AjvModule as any).default || AjvModule;
 
@@ -102,10 +103,12 @@ interface CustomModelsResult {
 	/** Providers with only baseUrl/headers override (no custom models) */
 	overrides: Map<string, ProviderOverride>;
 	error: string | undefined;
+	/** Whether the file was found (true) or didn't exist (false) */
+	found: boolean;
 }
 
 function emptyCustomModelsResult(error?: string): CustomModelsResult {
-	return { models: [], replacedProviders: new Set(), overrides: new Map(), error };
+	return { models: [], replacedProviders: new Set(), overrides: new Map(), error, found: false };
 }
 
 /**
@@ -137,7 +140,7 @@ export class ModelRegistry {
 		private fallbackPaths: string[] = [],
 	) {
 		// Set up fallback resolver for custom provider API keys
-		this.authStorage.setFallbackResolver((provider) => {
+		this.authStorage.setFallbackResolver(provider => {
 			const keyConfig = this.customProviderApiKeys.get(provider);
 			if (keyConfig) {
 				return resolveApiKeyConfig(keyConfig);
@@ -159,7 +162,7 @@ export class ModelRegistry {
 		instance.customProviderApiKeys = new Map(Object.entries(data.customProviderApiKeys ?? {}));
 		instance.loadError = data.loadError;
 
-		authStorage.setFallbackResolver((provider) => {
+		authStorage.setFallbackResolver(provider => {
 			const keyConfig = instance.customProviderApiKeys.get(provider);
 			if (keyConfig) {
 				return resolveApiKeyConfig(keyConfig);
@@ -201,7 +204,7 @@ export class ModelRegistry {
 		return this.loadError;
 	}
 
-	private loadModels(): void {
+	private loadModels() {
 		// Load custom models from models.json first (to know which providers to skip/override)
 		let customModels: Model<Api>[] = [];
 		let replacedProviders: Set<string> = new Set();
@@ -213,19 +216,20 @@ export class ModelRegistry {
 		}
 
 		for (const modelsPath of pathsToCheck) {
-			if (existsSync(modelsPath)) {
-				logger.debug("ModelRegistry.loadModels loading", { path: modelsPath });
-				const result = this.loadCustomModels(modelsPath);
-				if (result.error) {
-					this.loadError = result.error;
-					// Keep built-in models even if custom models failed to load
-				} else {
-					customModels = result.models;
-					replacedProviders = result.replacedProviders;
-					overrides = result.overrides;
-				}
-				break; // Use first existing file
+			const result = this.loadCustomModels(modelsPath);
+			if (!result.found) {
+				continue; // File doesn't exist, try next path
 			}
+			logger.debug("ModelRegistry.loadModels loading", { path: modelsPath });
+			if (result.error) {
+				this.loadError = result.error;
+				// Keep built-in models even if custom models failed to load
+			} else {
+				customModels = result.models;
+				replacedProviders = result.replacedProviders;
+				overrides = result.overrides;
+			}
+			break; // Use first existing file
 		}
 
 		const builtInModels = this.loadBuiltInModels(replacedProviders, overrides);
@@ -238,7 +242,7 @@ export class ModelRegistry {
 				? (normalizeDomain(copilotCred.enterpriseUrl) ?? undefined)
 				: undefined;
 			const baseUrl = getGitHubCopilotBaseUrl(copilotCred.access, domain);
-			this.models = combined.map((m) => (m.provider === "github-copilot" ? { ...m, baseUrl } : m));
+			this.models = combined.map(m => (m.provider === "github-copilot" ? { ...m, baseUrl } : m));
 		} else {
 			this.models = combined;
 		}
@@ -247,14 +251,14 @@ export class ModelRegistry {
 	/** Load built-in models, skipping replaced providers and applying overrides */
 	private loadBuiltInModels(replacedProviders: Set<string>, overrides: Map<string, ProviderOverride>): Model<Api>[] {
 		return getProviders()
-			.filter((provider) => !replacedProviders.has(provider))
-			.flatMap((provider) => {
+			.filter(provider => !replacedProviders.has(provider))
+			.flatMap(provider => {
 				const models = getModels(provider as any) as Model<Api>[];
 				const override = overrides.get(provider);
 				if (!override) return models;
 
 				// Apply baseUrl/headers override to all models of this provider
-				return models.map((m) => ({
+				return models.map(m => ({
 					...m,
 					baseUrl: override.baseUrl ?? m.baseUrl,
 					headers: override.headers ? { ...m.headers, ...override.headers } : m.headers,
@@ -262,14 +266,31 @@ export class ModelRegistry {
 			});
 	}
 
-	private loadCustomModels(modelsJsonPath: string): CustomModelsResult {
-		if (!existsSync(modelsJsonPath)) {
-			return emptyCustomModelsResult();
+	private loadCustomModels(modelsPath: string): CustomModelsResult {
+		let content: string;
+		try {
+			content = fs.readFileSync(modelsPath, "utf-8");
+		} catch (error) {
+			if (isEnoent(error)) {
+				return emptyCustomModelsResult();
+			}
+			return {
+				...emptyCustomModelsResult(
+					`Failed to load models config: ${error instanceof Error ? error.message : error}\n\nFile: ${modelsPath}`,
+				),
+				found: true,
+			};
 		}
 
 		try {
-			const content = readFileSync(modelsJsonPath, "utf-8");
-			const config: ModelsConfig = JSON.parse(content);
+			const ext = path.extname(modelsPath).toLowerCase();
+			let config: ModelsConfig;
+
+			if (ext === ".yaml" || ext === ".yml") {
+				config = YAML.parse(content) as ModelsConfig;
+			} else {
+				config = JSON.parse(content) as ModelsConfig;
+			}
 
 			// Validate schema
 			const ajv = new Ajv();
@@ -278,7 +299,7 @@ export class ModelRegistry {
 				const errors =
 					validate.errors?.map((e: any) => `  - ${e.instancePath || "root"}: ${e.message}`).join("\n") ||
 					"Unknown schema error";
-				return emptyCustomModelsResult(`Invalid models.json schema:\n${errors}\n\nFile: ${modelsJsonPath}`);
+				return emptyCustomModelsResult(`Invalid models config schema:\n${errors}\n\nFile: ${modelsPath}`);
 			}
 
 			// Additional validation
@@ -306,14 +327,20 @@ export class ModelRegistry {
 				}
 			}
 
-			return { models: this.parseModels(config), replacedProviders, overrides, error: undefined };
+			return { models: this.parseModels(config), replacedProviders, overrides, error: undefined, found: true };
 		} catch (error) {
 			if (error instanceof SyntaxError) {
-				return emptyCustomModelsResult(`Failed to parse models.json: ${error.message}\n\nFile: ${modelsJsonPath}`);
+				return {
+					...emptyCustomModelsResult(`Failed to parse models config: ${error.message}\n\nFile: ${modelsPath}`),
+					found: true,
+				};
 			}
-			return emptyCustomModelsResult(
-				`Failed to load models.json: ${error instanceof Error ? error.message : error}\n\nFile: ${modelsJsonPath}`,
-			);
+			return {
+				...emptyCustomModelsResult(
+					`Failed to load models config: ${error instanceof Error ? error.message : error}\n\nFile: ${modelsPath}`,
+				),
+				found: true,
+			};
 		}
 	}
 
@@ -422,21 +449,21 @@ export class ModelRegistry {
 	 * This is a fast check that doesn't refresh OAuth tokens.
 	 */
 	getAvailable(): Model<Api>[] {
-		return this.models.filter((m) => this.authStorage.hasAuth(m.provider));
+		return this.models.filter(m => this.authStorage.hasAuth(m.provider));
 	}
 
 	/**
 	 * Find a model by provider and ID.
 	 */
 	find(provider: string, modelId: string): Model<Api> | undefined {
-		return this.models.find((m) => m.provider === provider && m.id === modelId);
+		return this.models.find(m => m.provider === provider && m.id === modelId);
 	}
 
 	/**
 	 * Get the base URL associated with a provider, if any model defines one.
 	 */
 	getProviderBaseUrl(provider: string): string | undefined {
-		return this.models.find((m) => m.provider === provider && m.baseUrl)?.baseUrl;
+		return this.models.find(m => m.provider === provider && m.baseUrl)?.baseUrl;
 	}
 
 	/**