@oh-my-pi/pi-coding-agent 3.30.0 → 3.32.0

package/src/core/session-storage.ts

@@ -0,0 +1,379 @@
+import {
+	closeSync,
+	existsSync,
+	fsyncSync,
+	mkdirSync,
+	openSync,
+	readFileSync,
+	readSync,
+	statSync,
+	writeFileSync,
+	writeSync,
+} from "node:fs";
+import { rename as renameAsync } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+export interface SessionStorageStat {
+	size: number;
+	mtimeMs: number;
+	mtime: Date;
+}
+
+export interface SessionStorageWriter {
+	writeLine(line: string): Promise<void>;
+	flush(): Promise<void>;
+	fsync(): Promise<void>;
+	close(): Promise<void>;
+	getError(): Error | undefined;
+}
+
+export interface SessionStorage {
+	ensureDirSync(dir: string): void;
+	existsSync(path: string): boolean;
+	readTextSync(path: string): string;
+	readTextPrefixSync(path: string, buf: Buffer): number;
+	writeTextSync(path: string, content: string): void;
+	statSync(path: string): SessionStorageStat;
+	listFilesSync(dir: string, pattern: string): string[];
+
+	exists(path: string): Promise<boolean>;
+	readText(path: string): Promise<string>;
+	writeText(path: string, content: string): Promise<void>;
+	rename(path: string, nextPath: string): Promise<void>;
+	unlink(path: string): Promise<void>;
+	fsyncDirSync(dir: string): void;
+	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter;
+}
+
+function toError(value: unknown): Error {
+	return value instanceof Error ? value : new Error(String(value));
+}
+
+// FinalizationRegistry to clean up leaked file descriptors
+const writerRegistry = new FinalizationRegistry<number>((fd) => {
+	try {
+		closeSync(fd);
+	} catch {
+		// Ignore - fd may already be closed or invalid
+	}
+});
+
+class FileSessionStorageWriter implements SessionStorageWriter {
+	private fd: number;
+	private closed = false;
+	private error: Error | undefined;
+	private onError: ((err: Error) => void) | undefined;
+
+	constructor(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }) {
+		this.onError = options?.onError;
+		const flags = options?.flags ?? "a";
+		// Ensure parent directory exists
+		const dir = dirname(path);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		// Open file once, keep fd for lifetime
+		this.fd = openSync(path, flags === "w" ? "w" : "a");
+		// Register for cleanup if abandoned without close()
+		writerRegistry.register(this, this.fd, this);
+	}
+
+	private recordError(err: unknown): Error {
+		const error = toError(err);
+		if (!this.error) this.error = error;
+		this.onError?.(error);
+		return error;
+	}
+
+	async writeLine(line: string): Promise<void> {
+		if (this.closed) throw new Error("Writer closed");
+		if (this.error) throw this.error;
+		try {
+			const buf = Buffer.from(line, "utf-8");
+			let offset = 0;
+			while (offset < buf.length) {
+				const written = writeSync(this.fd, buf, offset, buf.length - offset);
+				if (written === 0) {
+					throw new Error("Short write");
+				}
+				offset += written;
+			}
+		} catch (err) {
+			throw this.recordError(err);
+		}
+	}
+
+	async flush(): Promise<void> {
+		if (this.error) throw this.error;
+		// OS buffers are flushed on fsync, nothing to do here
+	}
+
+	async fsync(): Promise<void> {
+		if (this.closed) throw new Error("Writer closed");
+		if (this.error) throw this.error;
+		try {
+			fsyncSync(this.fd);
+		} catch (err) {
+			throw this.recordError(err);
+		}
+	}
+
+	async close(): Promise<void> {
+		if (this.closed) return;
+		this.closed = true;
+		// Unregister from finalization - we're closing properly
+		writerRegistry.unregister(this);
+		try {
+			closeSync(this.fd);
+		} catch {
+			// Ignore close errors
+		}
+	}
+
+	getError(): Error | undefined {
+		return this.error;
+	}
+}
+
+export class FileSessionStorage implements SessionStorage {
+	ensureDirSync(dir: string): void {
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+	}
+
+	existsSync(path: string): boolean {
+		return existsSync(path);
+	}
+
+	readTextSync(path: string): string {
+		return readFileSync(path, "utf-8");
+	}
+
+	readTextPrefixSync(path: string, buf: Buffer): number {
+		const fd = openSync(path, "r");
+		try {
+			const bytesRead = readSync(fd, buf, 0, buf.length, 0);
+			return bytesRead;
+		} finally {
+			closeSync(fd);
+		}
+	}
+
+	writeTextSync(path: string, content: string): void {
+		this.ensureDirSync(dirname(path));
+		writeFileSync(path, content);
+	}
+
+	statSync(path: string): SessionStorageStat {
+		const stats = statSync(path);
+		return { size: stats.size, mtimeMs: stats.mtimeMs, mtime: stats.mtime };
+	}
+
+	listFilesSync(dir: string, pattern: string): string[] {
+		try {
+			return Array.from(new Bun.Glob(pattern).scanSync(dir)).map((name) => join(dir, name));
+		} catch {
+			return [];
+		}
+	}
+
+	exists(path: string): Promise<boolean> {
+		return Bun.file(path).exists();
+	}
+
+	readText(path: string): Promise<string> {
+		return Bun.file(path).text();
+	}
+
+	async writeText(path: string, content: string): Promise<void> {
+		await Bun.write(path, content, { createPath: true });
+	}
+
+	async rename(path: string, nextPath: string): Promise<void> {
+		try {
+			await renameAsync(path, nextPath);
+		} catch (err) {
+			throw toError(err);
+		}
+	}
+
+	unlink(path: string): Promise<void> {
+		return Bun.file(path).unlink();
+	}
+
+	fsyncDirSync(dir: string): void {
+		try {
+			const fd = openSync(dir, "r");
+			try {
+				fsyncSync(fd);
+			} finally {
+				closeSync(fd);
+			}
+		} catch {
+			// Best-effort: some platforms/filesystems don't support fsync on directories.
+		}
+	}
+
+	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter {
+		return new FileSessionStorageWriter(path, options);
+	}
+}
+
+function matchesPattern(name: string, pattern: string): boolean {
+	if (pattern === "*") return true;
+	if (pattern.startsWith("*.")) {
+		return name.endsWith(pattern.slice(1));
+	}
+	return name === pattern;
+}
+
+class MemorySessionStorageWriter implements SessionStorageWriter {
+	private storage: MemorySessionStorage;
+	private path: string;
+	private closed = false;
+	private error: Error | undefined;
+	private onError: ((err: Error) => void) | undefined;
+	private ready: Promise<void>;
+
+	constructor(
+		storage: MemorySessionStorage,
+		path: string,
+		options?: { flags?: "a" | "w"; onError?: (err: Error) => void },
+	) {
+		this.storage = storage;
+		this.path = path;
+		this.onError = options?.onError;
+		this.ready = this.initialize(options?.flags ?? "a");
+	}
+
+	private async initialize(flags: "a" | "w"): Promise<void> {
+		if (flags === "w") {
+			await this.storage.writeText(this.path, "");
+		}
+	}
+
+	private recordError(err: unknown): Error {
+		const error = toError(err);
+		if (!this.error) this.error = error;
+		this.onError?.(error);
+		return error;
+	}
+
+	async writeLine(line: string): Promise<void> {
+		if (this.closed) throw new Error("Writer closed");
+		await this.ready;
+		if (this.error) throw this.error;
+		try {
+			const existing = this.storage.existsSync(this.path) ? this.storage.readTextSync(this.path) : "";
+			await this.storage.writeText(this.path, `${existing}${line}`);
+		} catch (err) {
+			throw this.recordError(err);
+		}
+	}
+
+	async flush(): Promise<void> {
+		await this.ready;
+		if (this.error) throw this.error;
+	}
+
+	async fsync(): Promise<void> {
+		// No-op for in-memory storage
+		await this.ready;
+		if (this.error) throw this.error;
+	}
+
+	async close(): Promise<void> {
+		if (this.closed) return;
+		await this.ready;
+		this.closed = true;
+	}
+
+	getError(): Error | undefined {
+		return this.error;
+	}
+}
+
+export class MemorySessionStorage implements SessionStorage {
+	private files = new Map<string, { content: string; mtimeMs: number }>();
+
+	ensureDirSync(_dir: string): void {
+		// No-op for in-memory storage.
+	}
+
+	existsSync(path: string): boolean {
+		return this.files.has(path);
+	}
+
+	readTextSync(path: string): string {
+		const entry = this.files.get(path);
+		if (!entry) throw new Error(`File not found: ${path}`);
+		return entry.content;
+	}
+
+	readTextPrefixSync(path: string, buf: Buffer): number {
+		const content = this.readTextSync(path);
+		return buf.write(content, 0, buf.length, "utf-8");
+	}
+
+	writeTextSync(path: string, content: string): void {
+		this.files.set(path, { content, mtimeMs: Date.now() });
+	}
+
+	statSync(path: string): SessionStorageStat {
+		const entry = this.files.get(path);
+		if (!entry) throw new Error(`File not found: ${path}`);
+		return {
+			size: entry.content.length,
+			mtimeMs: entry.mtimeMs,
+			mtime: new Date(entry.mtimeMs),
+		};
+	}
+
+	listFilesSync(dir: string, pattern: string): string[] {
+		const prefix = dir.endsWith("/") ? dir : `${dir}/`;
+		const files: string[] = [];
+		for (const path of this.files.keys()) {
+			if (!path.startsWith(prefix)) continue;
+			const name = path.slice(prefix.length);
+			if (name.includes("/") || name.includes("\\")) continue;
+			if (!matchesPattern(name, pattern)) continue;
+			files.push(path);
+		}
+		return files;
+	}
+
+	exists(path: string): Promise<boolean> {
+		return Promise.resolve(this.existsSync(path));
+	}
+
+	readText(path: string): Promise<string> {
+		return Promise.resolve(this.readTextSync(path));
+	}
+
+	writeText(path: string, content: string): Promise<void> {
+		this.writeTextSync(path, content);
+		return Promise.resolve();
+	}
+
+	rename(path: string, nextPath: string): Promise<void> {
+		const entry = this.files.get(path);
+		if (!entry) return Promise.reject(new Error(`File not found: ${path}`));
+		this.files.set(nextPath, entry);
+		this.files.delete(path);
+		return Promise.resolve();
+	}
+
+	unlink(path: string): Promise<void> {
+		this.files.delete(path);
+		return Promise.resolve();
+	}
+
+	fsyncDirSync(_dir: string): void {
+		// No-op for in-memory storage.
+	}
+
+	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter {
+		return new MemorySessionStorageWriter(this, path, options);
+	}
+}

package/src/core/settings-manager.ts

@@ -70,8 +70,17 @@ export interface ProviderSettings {
 	image?: ImageProviderOption; // default: "auto" (openrouter > gemini)
 }
 
+export interface BashInterceptorRule {
+	pattern: string;
+	flags?: string;
+	tool: string;
+	message: string;
+}
+
 export interface BashInterceptorSettings {
 	enabled?: boolean; // default: false (blocks shell commands that have dedicated tools)
+	simpleLs?: boolean; // default: true (intercept bare ls commands)
+	patterns?: BashInterceptorRule[]; // default: built-in rules
 }
 
 export interface GitSettings {
@@ -191,6 +200,140 @@ export interface Settings {
 	statusLine?: StatusLineSettings; // Status line configuration
 }
 
+export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
+	{
+		pattern: "^\\s*(cat|head|tail|less|more)\\s+",
+		tool: "read",
+		message: "Use the `read` tool instead of cat/head/tail. It provides better context and handles binary files.",
+	},
+	{
+		pattern: "^\\s*(grep|rg|ripgrep|ag|ack)\\s+",
+		tool: "grep",
+		message: "Use the `grep` tool instead of grep/rg. It respects .gitignore and provides structured output.",
+	},
+	{
+		pattern: "^\\s*git(\\s+|$)",
+		tool: "git",
+		message:
+			"Use the `git` tool instead of running git in bash. It provides structured output and safety confirmations.",
+	},
+	{
+		pattern: "^\\s*(find|fd|locate)\\s+.*(-name|-iname|-type|--type|-glob)",
+		tool: "find",
+		message: "Use the `find` tool instead of find/fd. It respects .gitignore and is faster for glob patterns.",
+	},
+	{
+		pattern: "^\\s*sed\\s+(-i|--in-place)",
+		tool: "edit",
+		message: "Use the `edit` tool instead of sed -i. It provides diff preview and fuzzy matching.",
+	},
+	{
+		pattern: "^\\s*perl\\s+.*-[pn]?i",
+		tool: "edit",
+		message: "Use the `edit` tool instead of perl -i. It provides diff preview and fuzzy matching.",
+	},
+	{
+		pattern: "^\\s*awk\\s+.*-i\\s+inplace",
+		tool: "edit",
+		message: "Use the `edit` tool instead of awk -i inplace. It provides diff preview and fuzzy matching.",
+	},
+	{
+		pattern: "^\\s*(echo|printf|cat\\s*<<)\\s+.*[^|]>\\s*\\S",
+		tool: "write",
+		message: "Use the `write` tool instead of echo/cat redirection. It handles encoding and provides confirmation.",
+	},
+];
+
+const DEFAULT_BASH_INTERCEPTOR_SETTINGS: Required<BashInterceptorSettings> = {
+	enabled: false,
+	simpleLs: true,
+	patterns: DEFAULT_BASH_INTERCEPTOR_RULES,
+};
+
+const DEFAULT_SETTINGS: Settings = {
+	compaction: { enabled: true, reserveTokens: 16384, keepRecentTokens: 20000 },
+	branchSummary: { enabled: false, reserveTokens: 16384 },
+	retry: { enabled: true, maxRetries: 3, baseDelayMs: 2000 },
+	skills: {
+		enabled: true,
+		enableCodexUser: true,
+		enableClaudeUser: true,
+		enableClaudeProject: true,
+		enablePiUser: true,
+		enablePiProject: true,
+		customDirectories: [],
+		ignoredSkills: [],
+		includeSkills: [],
+	},
+	commands: { enableClaudeUser: true, enableClaudeProject: true },
+	terminal: { showImages: true },
+	images: { autoResize: true },
+	notifications: { onComplete: "auto" },
+	exa: {
+		enabled: true,
+		enableSearch: true,
+		enableLinkedin: false,
+		enableCompany: false,
+		enableResearcher: false,
+		enableWebsets: false,
+	},
+	bashInterceptor: DEFAULT_BASH_INTERCEPTOR_SETTINGS,
+	git: { enabled: false },
+	mcp: { enableProjectConfig: true },
+	lsp: { formatOnWrite: false, diagnosticsOnWrite: true, diagnosticsOnEdit: false },
+	edit: { fuzzyMatch: true },
+	ttsr: { enabled: true, contextMode: "discard", repeatMode: "once", repeatGap: 10 },
+	voice: {
+		enabled: false,
+		transcriptionModel: "whisper-1",
+		ttsModel: "gpt-4o-mini-tts",
+		ttsVoice: "alloy",
+		ttsFormat: "wav",
+	},
+	providers: { webSearch: "auto", image: "auto" },
+} satisfies Settings;
+
+function normalizeBashInterceptorRule(rule: unknown): BashInterceptorRule | null {
+	if (!rule || typeof rule !== "object" || Array.isArray(rule)) return null;
+
+	const candidate = rule as Record<string, unknown>;
+	const pattern = typeof candidate.pattern === "string" ? candidate.pattern : "";
+	const tool = typeof candidate.tool === "string" ? candidate.tool : "";
+	const message = typeof candidate.message === "string" ? candidate.message : "";
+	const flags = typeof candidate.flags === "string" && candidate.flags.length > 0 ? candidate.flags : undefined;
+
+	if (!pattern || !tool || !message) return null;
+	return { pattern, flags, tool, message };
+}
+
+function normalizeBashInterceptorSettings(
+	settings: BashInterceptorSettings | undefined,
+): Required<BashInterceptorSettings> {
+	const enabled = settings?.enabled ?? DEFAULT_BASH_INTERCEPTOR_SETTINGS.enabled;
+	const simpleLs = settings?.simpleLs ?? DEFAULT_BASH_INTERCEPTOR_SETTINGS.simpleLs;
+	const rawPatterns = settings?.patterns;
+	let patterns: BashInterceptorRule[];
+	if (rawPatterns === undefined) {
+		patterns = DEFAULT_BASH_INTERCEPTOR_RULES;
+	} else if (Array.isArray(rawPatterns)) {
+		patterns = rawPatterns
+			.map((rule) => normalizeBashInterceptorRule(rule))
+			.filter((rule): rule is BashInterceptorRule => rule !== null);
+	} else {
+		patterns = DEFAULT_BASH_INTERCEPTOR_RULES;
+	}
+
+	return { enabled, simpleLs, patterns };
+}
+
+function normalizeSettings(settings: Settings): Settings {
+	const merged = deepMergeSettings(DEFAULT_SETTINGS, settings);
+	return {
+		...merged,
+		bashInterceptor: normalizeBashInterceptorSettings(merged.bashInterceptor),
+	};
+}
+
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
 function deepMergeSettings(base: Settings, overrides: Settings): Settings {
 	const result: Settings = { ...base };
@@ -235,7 +378,7 @@ export class SettingsManager {
 		this.persist = persist;
 		this.globalSettings = initialSettings;
 		const projectSettings = this.loadProjectSettings();
-		this.settings = deepMergeSettings(this.globalSettings, projectSettings);
+		this.settings = normalizeSettings(deepMergeSettings(this.globalSettings, projectSettings));
 	}
 
 	/** Create a SettingsManager that loads from files */
@@ -308,7 +451,7 @@ export class SettingsManager {
 
 	/** Apply additional overrides on top of current settings */
 	applyOverrides(overrides: Partial<Settings>): void {
-		this.settings = deepMergeSettings(this.settings, overrides);
+		this.settings = normalizeSettings(deepMergeSettings(this.settings, overrides));
 	}
 
 	private save(): void {
@@ -325,7 +468,7 @@ export class SettingsManager {
 
 			// Re-merge project settings into active settings
 			const projectSettings = this.loadProjectSettings();
-			this.settings = deepMergeSettings(this.globalSettings, projectSettings);
+			this.settings = normalizeSettings(deepMergeSettings(this.globalSettings, projectSettings));
 		} catch (error) {
 			console.error(`Warning: Could not save settings file: ${error}`);
 		}
@@ -680,7 +823,15 @@ export class SettingsManager {
 	}
 
 	getBashInterceptorEnabled(): boolean {
-		return this.settings.bashInterceptor?.enabled ?? false;
+		return this.settings.bashInterceptor?.enabled ?? DEFAULT_BASH_INTERCEPTOR_SETTINGS.enabled;
+	}
+
+	getBashInterceptorSimpleLsEnabled(): boolean {
+		return this.settings.bashInterceptor?.simpleLs ?? DEFAULT_BASH_INTERCEPTOR_SETTINGS.simpleLs;
+	}
+
+	getBashInterceptorRules(): BashInterceptorRule[] {
+		return [...(this.settings.bashInterceptor?.patterns ?? DEFAULT_BASH_INTERCEPTOR_RULES)];
 	}
 
 	setBashInterceptorEnabled(enabled: boolean): void {

package/src/core/slash-commands.ts

@@ -2,6 +2,7 @@ import { slashCommandCapability } from "../capability/slash-command";
 import type { SlashCommand } from "../discovery";
 import { loadSync } from "../discovery";
 import { parseFrontmatter } from "../discovery/helpers";
+import { EMBEDDED_COMMAND_TEMPLATES } from "./tools/task/commands";
 
 /**
  * Represents a custom slash command loaded from a file
@@ -15,6 +16,25 @@ export interface FileSlashCommand {
 	_source?: { providerName: string; level: "user" | "project" | "native" };
 }
 
+const EMBEDDED_SLASH_COMMANDS = EMBEDDED_COMMAND_TEMPLATES;
+
+function parseCommandTemplate(content: string): { description: string; body: string } {
+	const { frontmatter, body } = parseFrontmatter(content);
+	const frontmatterDesc = typeof frontmatter.description === "string" ? frontmatter.description.trim() : "";
+
+	// Get description from frontmatter or first non-empty line
+	let description = frontmatterDesc;
+	if (!description) {
+		const firstLine = body.split("\n").find((line) => line.trim());
+		if (firstLine) {
+			description = firstLine.slice(0, 60);
+			if (firstLine.length > 60) description += "...";
+		}
+	}
+
+	return { description, body };
+}
+
 /**
  * Parse command arguments respecting quoted strings (bash-style)
  * Returns array of arguments
@@ -90,19 +110,8 @@ export interface LoadSlashCommandsOptions {
 export function loadSlashCommands(options: LoadSlashCommandsOptions = {}): FileSlashCommand[] {
 	const result = loadSync<SlashCommand>(slashCommandCapability.id, { cwd: options.cwd });
 
-	return result.items.map((cmd) => {
-		const { frontmatter, body } = parseFrontmatter(cmd.content);
-		const frontmatterDesc = typeof frontmatter.description === "string" ? frontmatter.description.trim() : "";
-
-		// Get description from frontmatter or first non-empty line
-		let description = frontmatterDesc;
-		if (!description) {
-			const firstLine = body.split("\n").find((line) => line.trim());
-			if (firstLine) {
-				description = firstLine.slice(0, 60);
-				if (firstLine.length > 60) description += "...";
-			}
-		}
+	const fileCommands: FileSlashCommand[] = result.items.map((cmd) => {
+		const { description, body } = parseCommandTemplate(cmd.content);
 
 		// Format source label: "via ProviderName Level"
 		const capitalizedLevel = cmd.level.charAt(0).toUpperCase() + cmd.level.slice(1);
@@ -116,6 +125,23 @@ export function loadSlashCommands(options: LoadSlashCommandsOptions = {}): FileS
 			_source: { providerName: cmd._source.providerName, level: cmd.level },
 		};
 	});
+
+	const seenNames = new Set(fileCommands.map((cmd) => cmd.name));
+	for (const cmd of EMBEDDED_SLASH_COMMANDS) {
+		const name = cmd.name.replace(/\.md$/, "");
+		if (seenNames.has(name)) continue;
+
+		const { description, body } = parseCommandTemplate(cmd.content);
+		fileCommands.push({
+			name,
+			description,
+			content: body,
+			source: "bundled",
+		});
+		seenNames.add(name);
+	}
+
+	return fileCommands;
 }
 
 /**