@oh-my-pi/pi-coding-agent 13.18.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/gh-cli.ts

@@ -1,125 +0,0 @@
-import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
-
-export interface GhCommandResult {
-	exitCode: number;
-	stdout: string;
-	stderr: string;
-}
-
-export interface GhCommandOptions {
-	repoProvided?: boolean;
-	trimOutput?: boolean;
-}
-
-export function isGhAvailable(): boolean {
-	return Boolean(Bun.which("gh"));
-}
-
-function formatGhFailure(args: string[], stdout: string, stderr: string, options?: GhCommandOptions): string {
-	const output = stderr || stdout;
-	const message = output.trim();
-
-	if (message.includes("gh auth login") || message.includes("not logged into any GitHub hosts")) {
-		return "GitHub CLI is not authenticated. Run `gh auth login`.";
-	}
-
-	if (
-		!options?.repoProvided &&
-		(message.includes("not a git repository") ||
-			message.includes("no git remotes found") ||
-			message.includes("unable to determine current repository"))
-	) {
-		return "GitHub repository context is unavailable. Pass `repo` explicitly or run the tool inside a GitHub checkout.";
-	}
-
-	if (message.length > 0) {
-		return message;
-	}
-
-	return `GitHub CLI command failed: gh ${args.join(" ")}`;
-}
-
-export async function runGhCommand(
-	cwd: string,
-	args: string[],
-	signal?: AbortSignal,
-	options?: GhCommandOptions,
-): Promise<GhCommandResult> {
-	throwIfAborted(signal);
-
-	if (!isGhAvailable()) {
-		throw new ToolError("GitHub CLI (gh) is not installed. Install it from https://cli.github.com/.");
-	}
-
-	try {
-		const child = Bun.spawn(["gh", ...args], {
-			cwd,
-			stdin: "ignore",
-			stdout: "pipe",
-			stderr: "pipe",
-			windowsHide: true,
-			signal,
-		});
-
-		if (!child.stdout || !child.stderr) {
-			throw new ToolError("Failed to capture GitHub CLI output.");
-		}
-
-		const [stdout, stderr, exitCode] = await Promise.all([
-			new Response(child.stdout).text(),
-			new Response(child.stderr).text(),
-			child.exited,
-		]);
-
-		throwIfAborted(signal);
-
-		return {
-			exitCode: exitCode ?? 0,
-			stdout: options?.trimOutput === false ? stdout : stdout.trim(),
-			stderr: options?.trimOutput === false ? stderr : stderr.trim(),
-		};
-	} catch (error) {
-		if (signal?.aborted) {
-			throw new ToolAbortError();
-		}
-		throw error;
-	}
-}
-
-export async function runGhJson<T>(
-	cwd: string,
-	args: string[],
-	signal?: AbortSignal,
-	options?: GhCommandOptions,
-): Promise<T> {
-	const result = await runGhCommand(cwd, args, signal, options);
-
-	if (result.exitCode !== 0) {
-		throw new ToolError(formatGhFailure(args, result.stdout, result.stderr, options));
-	}
-
-	if (!result.stdout) {
-		throw new ToolError("GitHub CLI returned empty output.");
-	}
-
-	try {
-		return JSON.parse(result.stdout) as T;
-	} catch {
-		throw new ToolError("GitHub CLI returned invalid JSON output.");
-	}
-}
-
-export async function runGhText(
-	cwd: string,
-	args: string[],
-	signal?: AbortSignal,
-	options?: GhCommandOptions,
-): Promise<string> {
-	const result = await runGhCommand(cwd, args, signal, options);
-
-	if (result.exitCode !== 0) {
-		throw new ToolError(formatGhFailure(args, result.stdout, result.stderr, options));
-	}
-
-	return result.stdout;
-}

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;
-}