@oh-my-pi/pi-coding-agent 6.2.0 → 6.7.67

package/src/core/ttsr.ts

@@ -21,44 +21,6 @@ interface InjectionRecord {
 	lastInjectedAt: number;
 }
 
-export interface TtsrManager {
-	/** Add a TTSR rule to be monitored */
-	addRule(rule: Rule): void;
-
-	/** Check if any uninjected TTSR matches the stream buffer. Returns matching rules. */
-	check(streamBuffer: string): Rule[];
-
-	/** Mark rules as injected (won't trigger again until conditions allow) */
-	markInjected(rules: Rule[]): void;
-
-	/** Get names of all injected rules (for persistence) */
-	getInjectedRuleNames(): string[];
-
-	/** Restore injected state from a list of rule names */
-	restoreInjected(ruleNames: string[]): void;
-
-	/** Reset stream buffer (called on new turn) */
-	resetBuffer(): void;
-
-	/** Get current stream buffer */
-	getBuffer(): string;
-
-	/** Append to stream buffer */
-	appendToBuffer(text: string): void;
-
-	/** Check if any TTSRs are registered */
-	hasRules(): boolean;
-
-	/** Increment message counter (call after each turn) */
-	incrementMessageCount(): void;
-
-	/** Get current message count */
-	getMessageCount(): number;
-
-	/** Get settings */
-	getSettings(): Required<TtsrSettings>;
-}
-
 const DEFAULT_SETTINGS: Required<TtsrSettings> = {
 	enabled: true,
 	contextMode: "discard",
@@ -66,146 +28,138 @@ const DEFAULT_SETTINGS: Required<TtsrSettings> = {
 	repeatGap: 10,
 };
 
-export function createTtsrManager(settings?: TtsrSettings): TtsrManager {
-	/** Resolved settings with defaults */
-	const resolvedSettings: Required<TtsrSettings> = {
-		...DEFAULT_SETTINGS,
-		...settings,
-	};
-
-	/** Map of rule name -> { rule, compiled regex } */
-	const rules = new Map<string, TtsrEntry>();
-
-	/** Map of rule name -> injection record */
-	const injectionRecords = new Map<string, InjectionRecord>();
+export class TtsrManager {
+	private readonly settings: Required<TtsrSettings>;
+	private readonly rules = new Map<string, TtsrEntry>();
+	private readonly injectionRecords = new Map<string, InjectionRecord>();
+	private buffer = "";
+	private messageCount = 0;
 
-	/** Current stream buffer for pattern matching */
-	let buffer = "";
-
-	/** Message counter for tracking gap between injections */
-	let messageCount = 0;
+	constructor(settings?: TtsrSettings) {
+		this.settings = { ...DEFAULT_SETTINGS, ...settings };
+	}
 
 	/** Check if a rule can be triggered based on repeat settings */
-	function canTrigger(ruleName: string): boolean {
-		const record = injectionRecords.get(ruleName);
+	private canTrigger(ruleName: string): boolean {
+		const record = this.injectionRecords.get(ruleName);
 		if (!record) {
-			// Never injected, can trigger
 			return true;
 		}
 
-		if (resolvedSettings.repeatMode === "once") {
-			// Once mode: never trigger again after first injection
+		if (this.settings.repeatMode === "once") {
 			return false;
 		}
 
-		// After-gap mode: check if enough messages have passed
-		const gap = messageCount - record.lastInjectedAt;
-		return gap >= resolvedSettings.repeatGap;
+		const gap = this.messageCount - record.lastInjectedAt;
+		return gap >= this.settings.repeatGap;
 	}
 
-	return {
-		addRule(rule: Rule): void {
-			// Only add rules that have a TTSR trigger pattern
-			if (!rule.ttsrTrigger) {
-				return;
-			}
+	/** Add a TTSR rule to be monitored */
+	addRule(rule: Rule): void {
+		if (!rule.ttsrTrigger) {
+			return;
+		}
+
+		if (this.rules.has(rule.name)) {
+			return;
+		}
+
+		try {
+			const regex = new RegExp(rule.ttsrTrigger);
+			this.rules.set(rule.name, { rule, regex });
+			logger.debug("TTSR rule registered", {
+				ruleName: rule.name,
+				pattern: rule.ttsrTrigger,
+			});
+		} catch (err) {
+			logger.warn("TTSR rule has invalid regex pattern, skipping", {
+				ruleName: rule.name,
+				pattern: rule.ttsrTrigger,
+				error: err instanceof Error ? err.message : String(err),
+			});
+		}
+	}
 
-			// Skip if already registered
-			if (rules.has(rule.name)) {
-				return;
+	/** Check if any uninjected TTSR matches the stream buffer. Returns matching rules. */
+	check(streamBuffer: string): Rule[] {
+		const matches: Rule[] = [];
+
+		for (const [name, entry] of this.rules) {
+			if (!this.canTrigger(name)) {
+				continue;
 			}
 
-			// Compile the regex pattern
-			try {
-				const regex = new RegExp(rule.ttsrTrigger);
-				rules.set(rule.name, { rule, regex });
-				logger.debug("TTSR rule registered", {
-					ruleName: rule.name,
-					pattern: rule.ttsrTrigger,
-				});
-			} catch (err) {
-				logger.warn("TTSR rule has invalid regex pattern, skipping", {
-					ruleName: rule.name,
-					pattern: rule.ttsrTrigger,
-					error: err instanceof Error ? err.message : String(err),
+			if (entry.regex.test(streamBuffer)) {
+				matches.push(entry.rule);
+				logger.debug("TTSR pattern matched", {
+					ruleName: name,
+					pattern: entry.rule.ttsrTrigger,
 				});
 			}
-		},
-
-		check(streamBuffer: string): Rule[] {
-			const matches: Rule[] = [];
-
-			for (const [name, entry] of rules) {
-				// Skip rules that can't trigger yet
-				if (!canTrigger(name)) {
-					continue;
-				}
-
-				// Test the buffer against the rule's pattern
-				if (entry.regex.test(streamBuffer)) {
-					matches.push(entry.rule);
-					logger.debug("TTSR pattern matched", {
-						ruleName: name,
-						pattern: entry.rule.ttsrTrigger,
-					});
-				}
-			}
+		}
 
-			return matches;
-		},
+		return matches;
+	}
 
-		markInjected(rulesToMark: Rule[]): void {
-			for (const rule of rulesToMark) {
-				injectionRecords.set(rule.name, { lastInjectedAt: messageCount });
-				logger.debug("TTSR rule marked as injected", {
-					ruleName: rule.name,
-					messageCount,
-					repeatMode: resolvedSettings.repeatMode,
-				});
-			}
-		},
+	/** Mark rules as injected (won't trigger again until conditions allow) */
+	markInjected(rulesToMark: Rule[]): void {
+		for (const rule of rulesToMark) {
+			this.injectionRecords.set(rule.name, { lastInjectedAt: this.messageCount });
+			logger.debug("TTSR rule marked as injected", {
+				ruleName: rule.name,
+				messageCount: this.messageCount,
+				repeatMode: this.settings.repeatMode,
+			});
+		}
+	}
 
-		getInjectedRuleNames(): string[] {
-			return Array.from(injectionRecords.keys());
-		},
+	/** Get names of all injected rules (for persistence) */
+	getInjectedRuleNames(): string[] {
+		return Array.from(this.injectionRecords.keys());
+	}
 
-		restoreInjected(ruleNames: string[]): void {
-			// When restoring, we don't know the original message count, so use 0
-			// This means in "after-gap" mode, rules can trigger again after the gap
-			for (const name of ruleNames) {
-				injectionRecords.set(name, { lastInjectedAt: 0 });
-			}
-			if (ruleNames.length > 0) {
-				logger.debug("TTSR injected state restored", { ruleNames });
-			}
-		},
+	/** Restore injected state from a list of rule names */
+	restoreInjected(ruleNames: string[]): void {
+		for (const name of ruleNames) {
+			this.injectionRecords.set(name, { lastInjectedAt: 0 });
+		}
+		if (ruleNames.length > 0) {
+			logger.debug("TTSR injected state restored", { ruleNames });
+		}
+	}
 
-		resetBuffer(): void {
-			buffer = "";
-		},
+	/** Reset stream buffer (called on new turn) */
+	resetBuffer(): void {
+		this.buffer = "";
+	}
 
-		getBuffer(): string {
-			return buffer;
-		},
+	/** Get current stream buffer */
+	getBuffer(): string {
+		return this.buffer;
+	}
 
-		appendToBuffer(text: string): void {
-			buffer += text;
-		},
+	/** Append to stream buffer */
+	appendToBuffer(text: string): void {
+		this.buffer += text;
+	}
 
-		hasRules(): boolean {
-			return rules.size > 0;
-		},
+	/** Check if any TTSRs are registered */
+	hasRules(): boolean {
+		return this.rules.size > 0;
+	}
 
-		incrementMessageCount(): void {
-			messageCount++;
-		},
+	/** Increment message counter (call after each turn) */
+	incrementMessageCount(): void {
+		this.messageCount++;
+	}
 
-		getMessageCount(): number {
-			return messageCount;
-		},
+	/** Get current message count */
+	getMessageCount(): number {
+		return this.messageCount;
+	}
 
-		getSettings(): Required<TtsrSettings> {
-			return resolvedSettings;
-		},
-	};
+	/** Get settings */
+	getSettings(): Required<TtsrSettings> {
+		return this.settings;
+	}
 }

package/src/core/voice.ts

@@ -23,6 +23,50 @@ export interface VoiceRecordingHandle {
 	cleanup: () => void;
 }
 
+export class VoiceRecording implements VoiceRecordingHandle {
+	readonly filePath: string;
+	private proc: ReturnType<typeof Bun.spawn>;
+
+	constructor(_settings: VoiceSettings) {
+		const sampleRate = DEFAULT_SAMPLE_RATE;
+		const channels = DEFAULT_CHANNELS;
+		this.filePath = join(tmpdir(), `omp-voice-${nanoid()}.wav`);
+		const command = buildRecordingCommand(this.filePath, sampleRate, channels);
+		if (!command) {
+			throw new Error("No audio recorder found (install sox, arecord, or ffmpeg).");
+		}
+
+		logger.debug("voice: starting recorder", { command });
+		this.proc = Bun.spawn(command, {
+			stdin: "ignore",
+			stdout: "ignore",
+			stderr: "pipe",
+		});
+	}
+
+	async stop(): Promise<void> {
+		try {
+			this.proc.kill();
+		} catch {
+			// ignore
+		}
+		await this.proc.exited;
+	}
+
+	cleanup(): void {
+		try {
+			unlinkSync(this.filePath);
+		} catch {
+			// ignore cleanup errors
+		}
+	}
+
+	async cancel(): Promise<void> {
+		await this.stop();
+		this.cleanup();
+	}
+}
+
 export interface VoiceTranscriptionResult {
 	text: string;
 }
@@ -99,45 +143,11 @@ function buildRecordingCommand(filePath: string, sampleRate: number, channels: n
 	return null;
 }
 
-export async function startVoiceRecording(_settings: VoiceSettings): Promise<VoiceRecordingHandle> {
-	const sampleRate = DEFAULT_SAMPLE_RATE;
-	const channels = DEFAULT_CHANNELS;
-	const filePath = join(tmpdir(), `omp-voice-${nanoid()}.wav`);
-	const command = buildRecordingCommand(filePath, sampleRate, channels);
-	if (!command) {
-		throw new Error("No audio recorder found (install sox, arecord, or ffmpeg).");
-	}
-
-	logger.debug("voice: starting recorder", { command });
-	const proc = Bun.spawn(command, {
-		stdin: "ignore",
-		stdout: "ignore",
-		stderr: "pipe",
-	});
-
-	const stop = async (): Promise<void> => {
-		try {
-			proc.kill();
-		} catch {
-			// ignore
-		}
-		await proc.exited;
-	};
-
-	const cleanup = (): void => {
-		try {
-			unlinkSync(filePath);
-		} catch {
-			// ignore cleanup errors
-		}
-	};
-
-	const cancel = async (): Promise<void> => {
-		await stop();
-		cleanup();
-	};
-
-	return { filePath, stop, cancel, cleanup };
+/**
+ * @deprecated Use `new VoiceRecording(settings)` instead.
+ */
+export function startVoiceRecording(settings: VoiceSettings): VoiceRecordingHandle {
+	return new VoiceRecording(settings);
 }
 
 export async function transcribeAudio(

package/src/index.ts

@@ -63,7 +63,7 @@ export type {
 	LoadedCustomTool,
 	RenderResultOptions,
 } from "./core/custom-tools/index";
-export { discoverAndLoadCustomTools, loadCustomTools } from "./core/custom-tools/index";
+export { CustomToolLoader, discoverAndLoadCustomTools, loadCustomTools } from "./core/custom-tools/index";
 // Extension types and utilities
 export type {
 	AppAction,
@@ -79,7 +79,6 @@ export type {
 	ExtensionFactory,
 	ExtensionFlag,
 	ExtensionHandler,
-	ExtensionRuntime,
 	ExtensionShortcut,
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
@@ -97,9 +96,9 @@ export type {
 	UserBashEventResult,
 } from "./core/extensions/index";
 export {
-	createExtensionRuntime,
 	discoverAndLoadExtensions,
 	ExtensionRunner,
+	ExtensionRuntime,
 	isBashToolResult,
 	isEditToolResult,
 	isFindToolResult,
@@ -119,22 +118,16 @@ export { ModelRegistry } from "./core/model-registry";
 export type { PromptTemplate } from "./core/prompt-templates";
 // SDK for programmatic usage
 export {
+	// Factory
+	BashTool,
 	// Tool factories
 	BUILTIN_TOOLS,
 	type BuildSystemPromptOptions,
 	buildSystemPrompt,
 	type CreateAgentSessionOptions,
 	type CreateAgentSessionResult,
-	// Factory
 	createAgentSession,
-	createBashTool,
-	createEditTool,
-	createFindTool,
-	createGrepTool,
-	createLsTool,
-	createReadTool,
 	createTools,
-	createWriteTool,
 	// Discovery
 	discoverAuthStorage,
 	discoverContextFiles,
@@ -144,8 +137,16 @@ export {
 	discoverModels,
 	discoverPromptTemplates,
 	discoverSkills,
+	EditTool,
+	FindTool,
+	GrepTool,
+	LsTool,
 	loadSettings,
+	loadSshTool,
+	PythonTool,
+	ReadTool,
 	type ToolSession,
+	WriteTool,
 } from "./core/sdk";
 export {
 	type BranchSummaryEntry,
@@ -201,11 +202,11 @@ export {
 	type FindToolDetails,
 	type FindToolOptions,
 	formatSize,
+	GitTool,
 	type GitToolDetails,
 	type GrepOperations,
 	type GrepToolDetails,
 	type GrepToolOptions,
-	gitTool,
 	type LsOperations,
 	type LsToolDetails,
 	type LsToolOptions,
@@ -226,6 +227,9 @@ export {
 	InteractiveMode,
 	type InteractiveModeOptions,
 	type PrintModeOptions,
+	RpcClient,
+	type RpcClientOptions,
+	type RpcEventListener,
 	runPrintMode,
 	runRpcMode,
 } from "./modes/index";

package/src/lib/worktree/index.ts

@@ -2,15 +2,7 @@ export { type CollapseOptions, type CollapseResult, type CollapseStrategy, colla
 export { WORKTREE_BASE } from "./constants";
 export { WorktreeError, WorktreeErrorCode } from "./errors";
 export { getRepoName, getRepoRoot, git, gitWithStdin } from "./git";
-export {
-	create,
-	find,
-	list,
-	prune,
-	remove,
-	type Worktree,
-	which,
-} from "./operations";
+export { create, find, list, prune, remove, type Worktree, which } from "./operations";
 export {
 	cleanupSessions,
 	createSession,

package/src/modes/interactive/components/diff.ts

@@ -6,9 +6,9 @@ import { theme } from "../theme/theme";
  * Format: "+123 content" or "-123 content" or " 123 content" or "     ..."
  */
 function parseDiffLine(line: string): { prefix: string; lineNum: string; content: string } | null {
-	const match = line.match(/^([+-\s])(\s*\d*)\s(.*)$/);
+	const match = line.match(/^([+-\s])(?:(\s*\d+)\s)?(.*)$/);
 	if (!match) return null;
-	return { prefix: match[1], lineNum: match[2], content: match[3] };
+	return { prefix: match[1], lineNum: match[2] ?? "", content: match[3] };
 }
 
 /**
@@ -80,6 +80,13 @@ export function renderDiff(diffText: string, _options: RenderDiffOptions = {}):
 	const lines = diffText.split("\n");
 	const result: string[] = [];
 
+	const formatLine = (prefix: string, lineNum: string, content: string): string => {
+		if (lineNum.trim().length === 0) {
+			return `${prefix}${content}`;
+		}
+		return `${prefix}${lineNum} ${content}`;
+	};
+
 	let i = 0;
 	while (i < lines.length) {
 		const line = lines[i];
@@ -121,24 +128,24 @@ export function renderDiff(diffText: string, _options: RenderDiffOptions = {}):
 					replaceTabs(added.content),
 				);
 
-				result.push(theme.fg("toolDiffRemoved", `-${removed.lineNum} ${removedLine}`));
-				result.push(theme.fg("toolDiffAdded", `+${added.lineNum} ${addedLine}`));
+				result.push(theme.fg("toolDiffRemoved", formatLine("-", removed.lineNum, removedLine)));
+				result.push(theme.fg("toolDiffAdded", formatLine("+", added.lineNum, addedLine)));
 			} else {
 				// Show all removed lines first, then all added lines
 				for (const removed of removedLines) {
-					result.push(theme.fg("toolDiffRemoved", `-${removed.lineNum} ${replaceTabs(removed.content)}`));
+					result.push(theme.fg("toolDiffRemoved", formatLine("-", removed.lineNum, replaceTabs(removed.content))));
 				}
 				for (const added of addedLines) {
-					result.push(theme.fg("toolDiffAdded", `+${added.lineNum} ${replaceTabs(added.content)}`));
+					result.push(theme.fg("toolDiffAdded", formatLine("+", added.lineNum, replaceTabs(added.content))));
 				}
 			}
 		} else if (parsed.prefix === "+") {
 			// Standalone added line
-			result.push(theme.fg("toolDiffAdded", `+${parsed.lineNum} ${replaceTabs(parsed.content)}`));
+			result.push(theme.fg("toolDiffAdded", formatLine("+", parsed.lineNum, replaceTabs(parsed.content))));
 			i++;
 		} else {
 			// Context line
-			result.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${replaceTabs(parsed.content)}`));
+			result.push(theme.fg("toolDiffContext", formatLine(" ", parsed.lineNum, replaceTabs(parsed.content))));
 			i++;
 		}
 	}

package/src/modes/interactive/components/settings-defs.ts

@@ -209,6 +209,15 @@ export const SETTINGS_DEFS: SettingDef[] = [
 		get: (sm) => sm.getCollapseChangelog(),
 		set: (sm, v) => sm.setCollapseChangelog(v),
 	},
+	{
+		id: "normativeRewrite",
+		tab: "behavior",
+		type: "boolean",
+		label: "Normative rewrite",
+		description: "Rewrite tool call arguments to normalized format in session history",
+		get: (sm) => sm.getNormativeRewrite(),
+		set: (sm, v) => sm.setNormativeRewrite(v),
+	},
 	{
 		id: "doubleEscapeAction",
 		tab: "behavior",
@@ -288,6 +297,39 @@ export const SETTINGS_DEFS: SettingDef[] = [
 		get: (sm) => sm.getEditFuzzyMatch(),
 		set: (sm, v) => sm.setEditFuzzyMatch(v),
 	},
+	{
+		id: "editFuzzyThreshold",
+		tab: "tools",
+		type: "submenu",
+		label: "Edit fuzzy threshold",
+		description: "Similarity threshold for fuzzy matches (higher = stricter)",
+		get: (sm) => sm.getEditFuzzyThreshold().toFixed(2),
+		set: (sm, v) => sm.setEditFuzzyThreshold(Number(v)),
+		getOptions: () => [
+			{ value: "0.85", label: "0.85", description: "Lenient" },
+			{ value: "0.90", label: "0.90", description: "Moderate" },
+			{ value: "0.95", label: "0.95", description: "Default" },
+			{ value: "0.98", label: "0.98", description: "Strict" },
+		],
+	},
+	{
+		id: "editPatchMode",
+		tab: "tools",
+		type: "boolean",
+		label: "Edit patch mode",
+		description: "Use codex-style apply-patch format instead of oldText/newText for edits",
+		get: (sm) => sm.getEditPatchMode(),
+		set: (sm, v) => sm.setEditPatchMode(v),
+	},
+	{
+		id: "readLineNumbers",
+		tab: "tools",
+		type: "boolean",
+		label: "Read line numbers",
+		description: "Prepend line numbers to read tool output by default",
+		get: (sm) => sm.getReadLineNumbers(),
+		set: (sm, v) => sm.setReadLineNumbers(v),
+	},
 	{
 		id: "mcpProjectConfig",
 		tab: "tools",