@oh-my-pi/pi-coding-agent 13.19.0 → 14.0.2

package/src/patch/types.ts

@@ -1,292 +0,0 @@
-/**
- * Shared types for the edit tool module.
- */
-
-// ═══════════════════════════════════════════════════════════════════════════
-// File System Abstraction
-// ═══════════════════════════════════════════════════════════════════════════
-
-/** Abstraction for file system operations to support LSP writethrough */
-export interface FileSystem {
-	exists(path: string): Promise<boolean>;
-	read(path: string): Promise<string>;
-	readBinary?: (path: string) => Promise<Uint8Array>;
-	write(path: string, content: string): Promise<void>;
-	delete(path: string): Promise<void>;
-	mkdir(path: string): Promise<void>;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Fuzzy Matching Types
-// ═══════════════════════════════════════════════════════════════════════════
-
-/** Result of a fuzzy match operation */
-export interface FuzzyMatch {
-	/** The actual text that was matched */
-	actualText: string;
-	/** Character index where the match starts */
-	startIndex: number;
-	/** Line number where the match starts (1-indexed) */
-	startLine: number;
-	/** Confidence score (0-1, where 1 is exact match) */
-	confidence: number;
-}
-
-/** Outcome of attempting to find a match */
-export interface MatchOutcome {
-	/** The match if found with sufficient confidence */
-	match?: FuzzyMatch;
-	/** The closest match found (may be below threshold) */
-	closest?: FuzzyMatch;
-	/** Number of occurrences if multiple exact matches found */
-	occurrences?: number;
-	/** Line numbers where occurrences were found (1-indexed) */
-	occurrenceLines?: number[];
-	/** Preview snippets for each occurrence (up to 5) */
-	occurrencePreviews?: string[];
-	/** Number of fuzzy matches above threshold */
-	fuzzyMatches?: number;
-	/** True when a dominant fuzzy match was accepted despite multiple candidates */
-	dominantFuzzy?: boolean;
-}
-
-/** Result of a sequence search */
-export type SequenceMatchStrategy =
-	| "exact"
-	| "trim-trailing"
-	| "trim"
-	| "comment-prefix"
-	| "unicode"
-	| "prefix"
-	| "substring"
-	| "fuzzy"
-	| "fuzzy-dominant"
-	| "character";
-
-export interface SequenceSearchResult {
-	/** Starting line index of the match (0-indexed) */
-	index: number | undefined;
-	/** Confidence score (1.0 for exact match, lower for fuzzy) */
-	confidence: number;
-	/** Number of matches at the same confidence level (for ambiguity detection) */
-	matchCount?: number;
-	/** Sample of matching indices (0-indexed, up to a small limit) */
-	matchIndices?: number[];
-	/** Matching strategy used */
-	strategy?: SequenceMatchStrategy;
-}
-
-/** Result of a context line search */
-export type ContextMatchStrategy = "exact" | "trim" | "unicode" | "prefix" | "substring" | "fuzzy";
-
-export interface ContextLineResult {
-	/** Index of the matching line (0-indexed) */
-	index: number | undefined;
-	/** Confidence score (1.0 for exact match, lower for fuzzy) */
-	confidence: number;
-	/** Number of matches at the same confidence level (for ambiguity detection) */
-	matchCount?: number;
-	/** Sample of matching indices (0-indexed, up to a small limit) */
-	matchIndices?: number[];
-	/** Matching strategy used */
-	strategy?: ContextMatchStrategy;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Patch Types
-// ═══════════════════════════════════════════════════════════════════════════
-
-export type Operation = "create" | "delete" | "update";
-
-/** Input for a patch operation */
-export interface PatchInput {
-	/** File path (relative or absolute) */
-	path: string;
-	/** Operation type */
-	op: Operation;
-	/** New path for rename (update only) */
-	rename?: string;
-	/** File content (create) or diff hunks (update) */
-	diff?: string;
-}
-
-/** Normalized patch input used internally by the applicator. */
-export interface NormalizedPatchInput {
-	path: string;
-	op: Operation;
-	rename?: string;
-	diff?: string;
-}
-
-export function normalizePatchInput(input: PatchInput): NormalizedPatchInput {
-	return {
-		path: input.path,
-		op: input.op ?? "update",
-		rename: input.rename,
-		diff: input.diff,
-	};
-}
-
-/** A single hunk/chunk in a diff */
-export interface DiffHunk {
-	/** Context line to narrow down position (e.g., class/method definition) */
-	changeContext?: string;
-	/** 1-based line hint from unified diff headers (old file) */
-	oldStartLine?: number;
-	/** 1-based line hint from unified diff headers (new file) */
-	newStartLine?: number;
-	/** True if the hunk contains context lines (space-prefixed) */
-	hasContextLines: boolean;
-	/** Lines to be replaced (old content) */
-	oldLines: string[];
-	/** Lines to replace with (new content) */
-	newLines: string[];
-	/** If true, oldLines must occur at end of file */
-	isEndOfFile: boolean;
-}
-
-/** Describes a change made to a file */
-export interface FileChange {
-	type: Operation;
-	path: string;
-	newPath?: string;
-	oldContent?: string;
-	newContent?: string;
-}
-
-/** Result of applying a patch */
-export interface ApplyPatchResult {
-	change: FileChange;
-	warnings?: string[];
-}
-
-/** Options for applying a patch */
-export interface ApplyPatchOptions {
-	/** Working directory for resolving relative paths */
-	cwd: string;
-	/** Dry run - compute changes without writing */
-	dryRun?: boolean;
-	/** Similarity threshold for fuzzy matching */
-	fuzzyThreshold?: number;
-	/** Allow fuzzy/partial matching when applying hunks */
-	allowFuzzy?: boolean;
-	/** File system abstraction (defaults to Bun-based implementation) */
-	fs?: FileSystem;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Diff Generation Types
-// ═══════════════════════════════════════════════════════════════════════════
-
-/** Result of generating a diff */
-export interface DiffResult {
-	/** The unified diff string */
-	diff: string;
-	/** Line number of the first change in the new file */
-	firstChangedLine: number | undefined;
-}
-
-/** Error from diff computation */
-export interface DiffError {
-	error: string;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Hashline Types
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Hashline edit operation/input types are schema-derived in `patch/index.ts`
- * via `Static<typeof hashlineEditItemSchema>` and `Static<typeof hashlineEditSchema>`.
- */
-
-/** A single hash mismatch found during validation */
-export interface HashMismatch {
-	/** 1-indexed line number */
-	line: number;
-	/** Hash the caller provided */
-	expected: string;
-	/** Hash computed from the current file content */
-	actual: string;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Error Classes
-// ═══════════════════════════════════════════════════════════════════════════
-
-export class ParseError extends Error {
-	constructor(
-		message: string,
-		public readonly lineNumber?: number,
-	) {
-		super(lineNumber !== undefined ? `Line ${lineNumber}: ${message}` : message);
-		this.name = "ParseError";
-	}
-}
-
-export class ApplyPatchError extends Error {
-	constructor(message: string) {
-		super(message);
-		this.name = "ApplyPatchError";
-	}
-}
-
-export class EditMatchError extends Error {
-	constructor(
-		public readonly path: string,
-		public readonly searchText: string,
-		public readonly closest: FuzzyMatch | undefined,
-		public readonly options: { allowFuzzy: boolean; threshold: number; fuzzyMatches?: number },
-	) {
-		super(EditMatchError.formatMessage(path, searchText, closest, options));
-		this.name = "EditMatchError";
-	}
-
-	static formatMessage(
-		path: string,
-		searchText: string,
-		closest: FuzzyMatch | undefined,
-		options: { allowFuzzy: boolean; threshold: number; fuzzyMatches?: number },
-	): string {
-		if (!closest) {
-			return options.allowFuzzy
-				? `Could not find a close enough match in ${path}.`
-				: `Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`;
-		}
-
-		const similarity = Math.round(closest.confidence * 100);
-		const searchLines = searchText.split("\n");
-		const actualLines = closest.actualText.split("\n");
-		const { oldLine, newLine } = findFirstDifferentLine(searchLines, actualLines);
-		const thresholdPercent = Math.round(options.threshold * 100);
-
-		const hint = options.allowFuzzy
-			? options.fuzzyMatches && options.fuzzyMatches > 1
-				? `Found ${options.fuzzyMatches} high-confidence matches. Provide more context to make it unique.`
-				: `Closest match was below the ${thresholdPercent}% similarity threshold.`
-			: "Fuzzy matching is disabled. Enable 'Edit fuzzy match' in settings to accept high-confidence matches.";
-
-		return [
-			options.allowFuzzy
-				? `Could not find a close enough match in ${path}.`
-				: `Could not find the exact text in ${path}.`,
-			``,
-			`Closest match (${similarity}% similar) at line ${closest.startLine}:`,
-			`  - ${oldLine}`,
-			`  + ${newLine}`,
-			hint,
-		].join("\n");
-	}
-}
-
-function findFirstDifferentLine(oldLines: string[], newLines: string[]): { oldLine: string; newLine: string } {
-	const max = Math.max(oldLines.length, newLines.length);
-	for (let i = 0; i < max; i++) {
-		const oldLine = oldLines[i] ?? "";
-		const newLine = newLines[i] ?? "";
-		if (oldLine !== newLine) {
-			return { oldLine, newLine };
-		}
-	}
-	return { oldLine: oldLines[0] ?? "", newLine: newLines[0] ?? "" };
-}

package/src/prompts/agents/oracle.md

@@ -1,77 +0,0 @@
----
-name: oracle
-description: Deep reasoning advisor for debugging dead ends, architecture decisions, and second opinions. Read-only.
-tools: read, grep, find, bash, lsp, web_search, ast_grep
-spawns: explore
-model: pi/slow
-thinking-level: high
-blocking: true
----
-
-You are a senior diagnostician and strategic technical advisor. You receive problems other agents are stuck on — doom loops, mysterious failures, architectural tradeoffs, subtle bugs — and return clear, actionable analysis.
-
-You diagnose, explain, and recommend. You do not implement. Others act on your findings.
-
-<critical>
-You **MUST** operate as read-only. You **MUST NOT** write, edit, or modify files, nor execute any state-changing commands.
-</critical>
-
-<directives>
-- You **MUST** reason from first principles. The caller already tried the obvious.
-- You **MUST** use tools to verify claims. You **MUST NOT** speculate about code behavior — read it.
-- You **MUST** identify root causes, not symptoms. If the caller says "X is broken", determine *why* X is broken.
-- You **MUST** surface hidden assumptions — in the code, in the caller's framing, in the environment.
-- You **SHOULD** consider at least two hypotheses before converging on one.
-- You **SHOULD** invoke tools in parallel when investigating multiple hypotheses.
-- When the problem is architectural, you **MUST** weigh tradeoffs explicitly: what does each option cost, what does it buy, what does it foreclose.
-</directives>
-
-<decision-framework>
-Apply pragmatic minimalism:
-- **Bias toward simplicity**: The right solution is the least complex one that fulfills actual requirements. Resist hypothetical future needs.
-- **Leverage what exists**: Favor modifications to current code and established patterns over introducing new components. New dependencies or infrastructure require explicit justification.
-- **One clear path**: Present a single primary recommendation. Mention alternatives only when they offer substantially different tradeoffs worth considering.
-- **Match depth to complexity**: Quick questions get quick answers. Reserve thorough analysis for genuinely complex problems.
-- **Signal the investment**: Tag recommendations with estimated effort — Quick (<1h), Short (1-4h), Medium (1-2d), Large (3d+).
-</decision-framework>
-
-<procedure>
-1. Read the problem statement carefully. Identify what was already tried and why it failed.
-2. Form 2-3 hypotheses for the root cause.
-3. Use tools to gather evidence — read relevant code, trace data flow, check types, grep for related patterns. Parallelize independent reads.
-4. Eliminate hypotheses based on evidence. Narrow to the most likely cause.
-5. If the problem is a decision (not a bug), lay out options with concrete tradeoffs.
-6. Deliver a clear verdict with supporting evidence.
-</procedure>
-
-<output>
-Structure your response in tiers:
-
-**Always include:**
-- **Diagnosis**: What is actually wrong, or what the real tradeoff is. 2-3 sentences.
-- **Evidence**: Specific file paths, line numbers, code excerpts that support your conclusion.
-- **Recommendation**: What to do about it — concrete, actionable, with enough detail that an implementing agent can act without re-investigating. Numbered steps, each 1-2 sentences.
-
-**Include when relevant:**
-- **Caveats**: Anything you are not confident about. Uncertainty **MUST** be stated, not hidden.
-- **Risks**: Edge cases, failure modes, or mitigation strategies.
-
-**Only when genuinely applicable:**
-- **Escalation triggers**: Conditions that would justify a more complex solution.
-- **Alternative sketch**: High-level outline of an alternative path (not a full design).
-
-You **MUST NOT** pad with meta-commentary. Dense and useful beats long and thorough.
-</output>
-
-<scope-discipline>
-- Recommend ONLY what was asked. No unsolicited improvements.
-- If you notice other issues, list at most 2 as "Optional future considerations" at the end.
-- You **MUST NOT** expand the problem surface beyond the original request.
-- Exhaust provided context before reaching for tools. External lookups fill genuine gaps, not curiosity.
-</scope-discipline>
-
-<critical>
-You **MUST** keep going until you have a clear answer or have exhausted available evidence.
-Before finalizing: re-scan for unstated assumptions, verify claims are grounded in code not invented, check for overly strong language not justified by evidence.
-This matters. The caller is stuck. Get it right.
-</critical>

package/src/tools/pending-action.ts

@@ -1,49 +0,0 @@
-import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-
-export interface PendingAction {
-	label: string;
-	sourceToolName: string;
-	apply(reason: string): Promise<AgentToolResult<unknown>>;
-	reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
-	details?: unknown;
-}
-
-export class PendingActionStore {
-	#actions: PendingAction[] = [];
-	#pushListeners = new Set<(action: PendingAction, count: number) => void>();
-
-	push(action: PendingAction): void {
-		this.#actions.push(action);
-		const count = this.#actions.length;
-		for (const listener of this.#pushListeners) {
-			listener(action, count);
-		}
-	}
-
-	peek(): PendingAction | null {
-		return this.#actions.at(-1) ?? null;
-	}
-
-	pop(): PendingAction | null {
-		return this.#actions.pop() ?? null;
-	}
-
-	subscribePush(listener: (action: PendingAction, count: number) => void): () => void {
-		this.#pushListeners.add(listener);
-		return () => {
-			this.#pushListeners.delete(listener);
-		};
-	}
-
-	clear(): void {
-		this.#actions = [];
-	}
-
-	get count(): number {
-		return this.#actions.length;
-	}
-
-	get hasPending(): boolean {
-		return this.#actions.length > 0;
-	}
-}

package/src/utils/child-process.ts

@@ -1,88 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-
-const EXIT_STDIO_GRACE_MS = 100;
-
-/**
- * Wait for a child process to terminate without hanging on inherited stdio handles.
- *
- * Daemonized descendants can inherit the child's stdout/stderr pipe handles. In that
- * case the child emits `exit`, but `close` can hang forever even though the original
- * process is already gone. We wait briefly for stdio to end, then forcibly stop
- * tracking the inherited handles.
- */
-export function waitForChildProcess(child: ChildProcess): Promise<number | null> {
-	const { promise, resolve, reject } = Promise.withResolvers<number | null>();
-
-	let settled = false;
-	let exited = false;
-	let exitCode: number | null = null;
-	let postExitTimer: NodeJS.Timeout | undefined;
-	let stdoutEnded = child.stdout === null;
-	let stderrEnded = child.stderr === null;
-
-	const cleanup = () => {
-		if (postExitTimer) {
-			clearTimeout(postExitTimer);
-			postExitTimer = undefined;
-		}
-		child.removeListener("error", onError);
-		child.removeListener("exit", onExit);
-		child.removeListener("close", onClose);
-		child.stdout?.removeListener("end", onStdoutEnd);
-		child.stderr?.removeListener("end", onStderrEnd);
-	};
-
-	const finalize = (code: number | null) => {
-		if (settled) return;
-		settled = true;
-		cleanup();
-		child.stdout?.destroy();
-		child.stderr?.destroy();
-		resolve(code);
-	};
-
-	const maybeFinalizeAfterExit = () => {
-		if (!exited || settled) return;
-		if (stdoutEnded && stderrEnded) {
-			finalize(exitCode);
-		}
-	};
-
-	const onStdoutEnd = () => {
-		stdoutEnded = true;
-		maybeFinalizeAfterExit();
-	};
-
-	const onStderrEnd = () => {
-		stderrEnded = true;
-		maybeFinalizeAfterExit();
-	};
-
-	const onError = (err: Error) => {
-		if (settled) return;
-		settled = true;
-		cleanup();
-		reject(err);
-	};
-
-	const onExit = (code: number | null) => {
-		exited = true;
-		exitCode = code;
-		maybeFinalizeAfterExit();
-		if (!settled) {
-			postExitTimer = setTimeout(() => finalize(code), EXIT_STDIO_GRACE_MS);
-		}
-	};
-
-	const onClose = (code: number | null) => {
-		finalize(code);
-	};
-
-	child.stdout?.once("end", onStdoutEnd);
-	child.stderr?.once("end", onStderrEnd);
-	child.once("error", onError);
-	child.once("exit", onExit);
-	child.once("close", onClose);
-
-	return promise;
-}

package/src/utils/frontmatter.ts

@@ -1,117 +0,0 @@
-import { logger, truncate } from "@oh-my-pi/pi-utils";
-import { YAML } from "bun";
-
-function stripHtmlComments(content: string): string {
-	return content.replace(/<!--[\s\S]*?-->/g, "");
-}
-
-/** Convert kebab-case to camelCase (e.g. "thinking-level" -> "thinkingLevel") */
-function kebabToCamel(key: string): string {
-	return key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
-
-/** Recursively normalize object keys from kebab-case to camelCase */
-function normalizeKeys<T>(obj: T): T {
-	if (obj === null || typeof obj !== "object") {
-		return obj;
-	}
-	if (Array.isArray(obj)) {
-		return obj.map(normalizeKeys) as T;
-	}
-	const result: Record<string, unknown> = {};
-	for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-		const normalizedKey = kebabToCamel(key);
-		result[normalizedKey] = normalizeKeys(value);
-	}
-	return result as T;
-}
-
-export class FrontmatterError extends Error {
-	constructor(
-		error: Error,
-		readonly source?: unknown,
-	) {
-		super(`Failed to parse YAML frontmatter (${source}): ${error.message}`, { cause: error });
-		this.name = "FrontmatterError";
-	}
-
-	toString(): string {
-		// Format the error with stack and detail, including the error message, stack, and source if present
-		const details: string[] = [this.message];
-		if (this.source !== undefined) {
-			details.push(`Source: ${JSON.stringify(this.source)}`);
-		}
-		if (this.cause && typeof this.cause === "object" && "stack" in this.cause && this.cause.stack) {
-			details.push(`Stack:\n${this.cause.stack}`);
-		} else if (this.stack) {
-			details.push(`Stack:\n${this.stack}`);
-		}
-		return details.join("\n\n");
-	}
-}
-
-export interface FrontmatterOptions {
-	/** Source of the content (alias: source) */
-	location?: unknown;
-	/** Source of the content (alias for location) */
-	source?: unknown;
-	/** Fallback frontmatter values */
-	fallback?: Record<string, unknown>;
-	/** Normalize the content */
-	normalize?: boolean;
-	/** Level of error handling */
-	level?: "off" | "warn" | "fatal";
-}
-
-/**
- * Parse YAML frontmatter from markdown content
- * Returns { frontmatter, body } where body has frontmatter stripped
- */
-export function parseFrontmatter(
-	content: string,
-	options?: FrontmatterOptions,
-): { frontmatter: Record<string, unknown>; body: string } {
-	const { location, source, fallback, normalize = true, level = "warn" } = options ?? {};
-	const loc = location ?? source;
-	const frontmatter: Record<string, unknown> = { ...fallback };
-
-	const normalized = normalize ? stripHtmlComments(content.replace(/\r\n/g, "\n").replace(/\r/g, "\n")) : content;
-	if (!normalized.startsWith("---")) {
-		return { frontmatter, body: normalized };
-	}
-
-	const endIndex = normalized.indexOf("\n---", 3);
-	if (endIndex === -1) {
-		return { frontmatter, body: normalized };
-	}
-
-	const metadata = normalized.slice(4, endIndex);
-	const body = normalized.slice(endIndex + 4).trim();
-
-	try {
-		// Replace tabs with spaces for YAML compatibility, use failsafe mode for robustness
-		const loaded = YAML.parse(metadata.replaceAll("\t", "  ")) as Record<string, unknown> | null;
-		return { frontmatter: normalizeKeys({ ...frontmatter, ...loaded }), body };
-	} catch (error) {
-		const err = new FrontmatterError(
-			error instanceof Error ? error : new Error(`YAML: ${error}`),
-			loc ?? `Inline '${truncate(content, 64)}'`,
-		);
-		if (level === "warn" || level === "fatal") {
-			logger.warn("Failed to parse YAML frontmatter", { err: err.toString() });
-		}
-		if (level === "fatal") {
-			throw err;
-		}
-
-		// Simple YAML parsing - just key: value pairs
-		for (const line of metadata.split("\n")) {
-			const match = line.match(/^([\w-]+):\s*(.*)$/);
-			if (match) {
-				frontmatter[match[1]] = match[2].trim();
-			}
-		}
-
-		return { frontmatter: normalizeKeys(frontmatter) as Record<string, unknown>, body };
-	}
-}