@oh-my-pi/pi-coding-agent 0.1.0

package/src/prompts/tools/lsp.md

@@ -0,0 +1,14 @@
+Interact with Language Server Protocol (LSP) servers to get code intelligence features.
+
+Standard operations:
+- diagnostics: Get errors/warnings for a file
+- workspace_diagnostics: Check entire project for errors (uses tsc, cargo check, go build, etc.)
+- definition: Go to symbol definition
+- references: Find all references to a symbol
+- hover: Get type info and documentation
+- symbols: List symbols in a file (functions, classes, etc.)
+- workspace_symbols: Search for symbols across the project
+- rename: Rename a symbol across the codebase
+- actions: List and apply code actions (quick fixes, refactors)
+- incoming_calls: Find all callers of a function
+- outgoing_calls: Find all functions called by a function

package/src/prompts/tools/output.md

@@ -0,0 +1,23 @@
+# TaskOutput
+
+Retrieves complete output from background tasks spawned with the Task tool.
+
+## When to Use
+
+Use TaskOutput when:
+- Task tool returns truncated preview with "Output truncated" message
+- You need full output to debug errors or analyze detailed results
+- Task tool's summary shows substantial line/character counts but preview is incomplete
+- You're analyzing multi-step task output requiring full context
+
+Do NOT use when:
+- Task preview already shows complete output (no truncation indicator)
+- Summary alone answers your question
+
+## Parameters
+
+- `ids`: Array of output IDs from Task results (e.g., `["reviewer_0", "explore_1"]`)
+- `format` (optional):
+  - `"raw"` (default): Full output with ANSI codes preserved
+  - `"json"`: Structured object with metadata
+  - `"stripped"`: Plain text with ANSI codes removed for parsing

package/src/prompts/tools/read.md

@@ -0,0 +1,25 @@
+Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- By default, it reads up to {{DEFAULT_MAX_LINES}} lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- Any lines longer than 500 characters will be truncated
+- Results are returned using cat -n format, with line numbers starting at 1
+- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.
+- This tool can read PDF files (.pdf). PDFs are processed page by page, extracting both text and visual content for analysis.
+- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
+- This tool can only read files, not directories. To read a directory, use an ls command via the bash tool.
+- You can call multiple tools in a single response. It is always better to speculatively read multiple potentially useful files in parallel.
+- You will regularly be asked to read screenshots. If the user provides a path to a screenshot, ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths.
+- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
+
+Empty files trigger a warning. Directory paths return an ls-style listing. Missing files return an error with closest matches (gitignore respected).
+
+## Best Practices
+
+- Parallelize reads when exploring related files
+- Read before editing (required in current session)
+- Trust user-provided paths; attempt the read
+- Screenshots: Read tool renders images visually
+- Skip re-reading after edits (Edit/Write report errors)

package/src/prompts/tools/web-fetch.md

@@ -0,0 +1,8 @@
+Fetches and analyzes web content by retrieving a URL
+
+Use this tool when you need to:
+- Extract specific information from web pages (documentation, articles, API references)
+- Analyze GitHub issues, pull requests, or repository content
+- Retrieve information from Stack Overflow, Wikipedia, Reddit, NPM, arXiv, or technical blogs
+- Access RSS/Atom feeds or JSON endpoints
+- Read PDF or DOCX files hosted at a URL

package/src/prompts/tools/web-search.md

@@ -0,0 +1,10 @@
+Allows OMP to search the web and use the results to inform responses
+- Provides up-to-date information for current events and recent data
+- Returns search result information formatted as search result blocks, including links as markdown hyperlinks
+- Use this tool for accessing information beyond Claude's knowledge cutoff
+- Searches are performed automatically within a single API call
+
+Common: system_prompt (guides response style)
+Anthropic-specific: max_tokens
+Perplexity-specific: model (sonar/sonar-pro), search_recency_filter, search_domain_filter, search_context_size, return_related_questions
+Exa-specific: num_results

package/src/prompts/tools/write.md

@@ -0,0 +1,10 @@
+Creates or overwrites a file at the specified path.
+
+When to use:
+- Creating new files explicitly required by the task
+- Replacing entire file contents when editing would be more complex
+
+Critical requirements:
+- Prefer Edit tool for modifying existing files (more precise, preserves formatting)
+- Create documentation files (*.md, README) only when explicitly requested
+- Include emojis only when explicitly requested

package/src/utils/changelog.ts

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync } from "node:fs";
+
+export interface ChangelogEntry {
+	major: number;
+	minor: number;
+	patch: number;
+	content: string;
+}
+
+/**
+ * Parse changelog entries from CHANGELOG.md
+ * Scans for ## lines and collects content until next ## or EOF
+ */
+export function parseChangelog(changelogPath: string): ChangelogEntry[] {
+	if (!existsSync(changelogPath)) {
+		return [];
+	}
+
+	try {
+		const content = readFileSync(changelogPath, "utf-8");
+		const lines = content.split("\n");
+		const entries: ChangelogEntry[] = [];
+
+		let currentLines: string[] = [];
+		let currentVersion: { major: number; minor: number; patch: number } | null = null;
+
+		for (const line of lines) {
+			// Check if this is a version header (## [x.y.z] ...)
+			if (line.startsWith("## ")) {
+				// Save previous entry if exists
+				if (currentVersion && currentLines.length > 0) {
+					entries.push({
+						...currentVersion,
+						content: currentLines.join("\n").trim(),
+					});
+				}
+
+				// Try to parse version from this line
+				const versionMatch = line.match(/##\s+\[?(\d+)\.(\d+)\.(\d+)\]?/);
+				if (versionMatch) {
+					currentVersion = {
+						major: Number.parseInt(versionMatch[1], 10),
+						minor: Number.parseInt(versionMatch[2], 10),
+						patch: Number.parseInt(versionMatch[3], 10),
+					};
+					currentLines = [line];
+				} else {
+					// Reset if we can't parse version
+					currentVersion = null;
+					currentLines = [];
+				}
+			} else if (currentVersion) {
+				// Collect lines for current version
+				currentLines.push(line);
+			}
+		}
+
+		// Save last entry
+		if (currentVersion && currentLines.length > 0) {
+			entries.push({
+				...currentVersion,
+				content: currentLines.join("\n").trim(),
+			});
+		}
+
+		return entries;
+	} catch (error) {
+		console.error(`Warning: Could not parse changelog: ${error}`);
+		return [];
+	}
+}
+
+/**
+ * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+export function compareVersions(v1: ChangelogEntry, v2: ChangelogEntry): number {
+	if (v1.major !== v2.major) return v1.major - v2.major;
+	if (v1.minor !== v2.minor) return v1.minor - v2.minor;
+	return v1.patch - v2.patch;
+}
+
+/**
+ * Get entries newer than lastVersion
+ */
+export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): ChangelogEntry[] {
+	// Parse lastVersion
+	const parts = lastVersion.split(".").map(Number);
+	const last: ChangelogEntry = {
+		major: parts[0] || 0,
+		minor: parts[1] || 0,
+		patch: parts[2] || 0,
+		content: "",
+	};
+
+	return entries.filter((entry) => compareVersions(entry, last) > 0);
+}
+
+// Re-export getChangelogPath from paths.ts for convenience
+export { getChangelogPath } from "../config";

package/src/utils/clipboard.ts

@@ -0,0 +1,265 @@
+import { platform } from "node:os";
+
+async function spawnWithTimeout(cmd: string[], input: string, timeoutMs: number): Promise<void> {
+	const proc = Bun.spawn(cmd, { stdin: "pipe" });
+
+	const timeoutPromise = new Promise<never>((_, reject) => {
+		setTimeout(() => reject(new Error("Clipboard operation timed out")), timeoutMs);
+	});
+
+	try {
+		proc.stdin.write(input);
+		proc.stdin.end();
+		await Promise.race([proc.exited, timeoutPromise]);
+
+		if (proc.exitCode !== 0) {
+			throw new Error(`Command failed with exit code ${proc.exitCode}`);
+		}
+	} finally {
+		proc.kill();
+	}
+}
+
+async function spawnAndRead(cmd: string[], timeoutMs: number): Promise<Buffer | null> {
+	const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+
+	const timeoutPromise = new Promise<never>((_, reject) => {
+		setTimeout(() => reject(new Error("Clipboard operation timed out")), timeoutMs);
+	});
+
+	try {
+		const [exitCode, stdout] = await Promise.race([
+			Promise.all([proc.exited, new Response(proc.stdout).arrayBuffer()]),
+			timeoutPromise,
+		]);
+
+		if (exitCode !== 0) {
+			return null;
+		}
+
+		return Buffer.from(stdout);
+	} catch {
+		return null;
+	} finally {
+		proc.kill();
+	}
+}
+
+export async function copyToClipboard(text: string): Promise<void> {
+	const p = platform();
+	const timeout = 5000;
+
+	try {
+		if (p === "darwin") {
+			await spawnWithTimeout(["pbcopy"], text, timeout);
+		} else if (p === "win32") {
+			await spawnWithTimeout(["clip"], text, timeout);
+		} else {
+			// Linux - try xclip first, fall back to xsel
+			try {
+				await spawnWithTimeout(["xclip", "-selection", "clipboard"], text, timeout);
+			} catch {
+				await spawnWithTimeout(["xsel", "--clipboard", "--input"], text, timeout);
+			}
+		}
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		if (p === "linux") {
+			throw new Error(`Failed to copy to clipboard. Install xclip or xsel: ${msg}`);
+		}
+		throw new Error(`Failed to copy to clipboard: ${msg}`);
+	}
+}
+
+export interface ClipboardImage {
+	data: string; // base64 encoded
+	mimeType: string;
+}
+
+/**
+ * Read image from system clipboard if available.
+ * Returns null if no image is in clipboard or clipboard access fails.
+ *
+ * Supported platforms:
+ * - Linux: requires xclip
+ * - macOS: uses osascript + pbpaste
+ * - Windows: uses PowerShell
+ */
+export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
+	const p = platform();
+	const timeout = 3000;
+
+	try {
+		if (p === "linux") {
+			return await readImageLinux(timeout);
+		} else if (p === "darwin") {
+			return await readImageMacOS(timeout);
+		} else if (p === "win32") {
+			return await readImageWindows(timeout);
+		}
+	} catch {
+		// Clipboard access failed silently
+	}
+
+	return null;
+}
+
+async function readImageLinux(timeout: number): Promise<ClipboardImage | null> {
+	// Try Wayland first (wl-paste), then X11 (xclip)
+	const wayland = await readImageWayland(timeout);
+	if (wayland) return wayland;
+
+	return await readImageX11(timeout);
+}
+
+async function readImageWayland(timeout: number): Promise<ClipboardImage | null> {
+	// wl-paste --list-types shows available MIME types
+	const types = await spawnAndRead(["wl-paste", "--list-types"], timeout);
+	if (!types) return null;
+
+	const typeList = types.toString("utf-8");
+
+	// Try PNG first, then JPEG
+	const imageTypes = [
+		{ type: "image/png", mimeType: "image/png" },
+		{ type: "image/jpeg", mimeType: "image/jpeg" },
+	];
+
+	for (const { type, mimeType } of imageTypes) {
+		if (typeList.includes(type)) {
+			const imageData = await spawnAndRead(["wl-paste", "--type", type], timeout);
+			if (imageData && imageData.length > 0) {
+				return {
+					data: imageData.toString("base64"),
+					mimeType,
+				};
+			}
+		}
+	}
+
+	return null;
+}
+
+async function readImageX11(timeout: number): Promise<ClipboardImage | null> {
+	// Check available targets in clipboard
+	const targets = await spawnAndRead(["xclip", "-selection", "clipboard", "-t", "TARGETS", "-o"], timeout);
+	if (!targets) return null;
+
+	const targetList = targets.toString("utf-8");
+
+	// Try PNG first (preferred), then JPEG
+	const imageTypes = [
+		{ target: "image/png", mimeType: "image/png" },
+		{ target: "image/jpeg", mimeType: "image/jpeg" },
+		{ target: "image/jpg", mimeType: "image/jpeg" },
+	];
+
+	for (const { target, mimeType } of imageTypes) {
+		if (targetList.includes(target)) {
+			const imageData = await spawnAndRead(["xclip", "-selection", "clipboard", "-t", target, "-o"], timeout);
+			if (imageData && imageData.length > 0) {
+				return {
+					data: imageData.toString("base64"),
+					mimeType,
+				};
+			}
+		}
+	}
+
+	return null;
+}
+
+async function readImageMacOS(timeout: number): Promise<ClipboardImage | null> {
+	// Use osascript to check clipboard class and read PNG data
+	// First check if clipboard has image data
+	const checkScript = `
+		try
+			clipboard info for «class PNGf»
+			return "png"
+		on error
+			try
+				clipboard info for «class JPEG»
+				return "jpeg"
+			on error
+				return "none"
+			end try
+		end try
+	`;
+
+	const checkProc = Bun.spawn(["osascript", "-e", checkScript], { stdout: "pipe", stderr: "pipe" });
+	const checkResult = await Promise.race([
+		new Response(checkProc.stdout).text(),
+		new Promise<string>((_, reject) => setTimeout(() => reject(new Error("timeout")), timeout)),
+	]).catch(() => "none");
+
+	await checkProc.exited;
+	const imageType = checkResult.trim();
+
+	if (imageType === "none") return null;
+
+	// Read the actual image data using a temp file approach
+	// osascript can't output binary directly, so we write to a temp file
+	const tempFile = `/tmp/omp-clipboard-${Date.now()}.${imageType === "png" ? "png" : "jpg"}`;
+	const clipboardClass = imageType === "png" ? "«class PNGf»" : "«class JPEG»";
+
+	const readScript = `
+		set imageData to the clipboard as ${clipboardClass}
+		set filePath to POSIX file "${tempFile}"
+		set fileRef to open for access filePath with write permission
+		write imageData to fileRef
+		close access fileRef
+	`;
+
+	const writeProc = Bun.spawn(["osascript", "-e", readScript], { stdout: "pipe", stderr: "pipe" });
+	await Promise.race([
+		writeProc.exited,
+		new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeout)),
+	]).catch(() => null);
+
+	try {
+		const file = Bun.file(tempFile);
+		if (await file.exists()) {
+			const buffer = await file.arrayBuffer();
+			await Bun.write(tempFile, ""); // Clear file
+			const { unlink } = await import("fs/promises");
+			await unlink(tempFile).catch(() => {});
+
+			if (buffer.byteLength > 0) {
+				return {
+					data: Buffer.from(buffer).toString("base64"),
+					mimeType: imageType === "png" ? "image/png" : "image/jpeg",
+				};
+			}
+		}
+	} catch {
+		// File read failed
+	}
+
+	return null;
+}
+
+async function readImageWindows(timeout: number): Promise<ClipboardImage | null> {
+	// PowerShell script to read image from clipboard as base64
+	const script = `
+		Add-Type -AssemblyName System.Windows.Forms
+		$clipboard = [System.Windows.Forms.Clipboard]::GetImage()
+		if ($clipboard -ne $null) {
+			$ms = New-Object System.IO.MemoryStream
+			$clipboard.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+			[Convert]::ToBase64String($ms.ToArray())
+		}
+	`;
+
+	const result = await spawnAndRead(["powershell", "-NoProfile", "-Command", script], timeout);
+	if (result && result.length > 0) {
+		const base64 = result.toString("utf-8").trim();
+		if (base64.length > 0) {
+			return {
+				data: base64,
+				mimeType: "image/png",
+			};
+		}
+	}
+
+	return null;
+}

package/src/utils/fuzzy.ts

@@ -0,0 +1,108 @@
+// Fuzzy search. Matches if all query characters appear in order (not necessarily consecutive).
+// Lower score = better match.
+
+export interface FuzzyMatch {
+	matches: boolean;
+	score: number;
+}
+
+export function fuzzyMatch(query: string, text: string): FuzzyMatch {
+	const queryLower = query.toLowerCase();
+	const textLower = text.toLowerCase();
+
+	if (queryLower.length === 0) {
+		return { matches: true, score: 0 };
+	}
+
+	if (queryLower.length > textLower.length) {
+		return { matches: false, score: 0 };
+	}
+
+	let queryIndex = 0;
+	let score = 0;
+	let lastMatchIndex = -1;
+	let consecutiveMatches = 0;
+
+	for (let i = 0; i < textLower.length && queryIndex < queryLower.length; i++) {
+		if (textLower[i] === queryLower[queryIndex]) {
+			const isWordBoundary = i === 0 || /[\s\-_./]/.test(textLower[i - 1]!);
+
+			// Reward consecutive character matches (e.g., typing "foo" matches "foobar" better than "f_o_o")
+			if (lastMatchIndex === i - 1) {
+				consecutiveMatches++;
+				score -= consecutiveMatches * 5;
+			} else {
+				consecutiveMatches = 0;
+				// Penalize gaps between matched characters
+				if (lastMatchIndex >= 0) {
+					score += (i - lastMatchIndex - 1) * 2;
+				}
+			}
+
+			// Reward matches at word boundaries (start of words are more likely intentional targets)
+			if (isWordBoundary) {
+				score -= 10;
+			}
+
+			// Slight penalty for matches later in the string (prefer earlier matches)
+			score += i * 0.1;
+
+			lastMatchIndex = i;
+			queryIndex++;
+		}
+	}
+
+	// Not all query characters were found in order
+	if (queryIndex < queryLower.length) {
+		return { matches: false, score: 0 };
+	}
+
+	return { matches: true, score };
+}
+
+// Filter and sort items by fuzzy match quality (best matches first)
+// Supports space-separated tokens: all tokens must match, sorted by match count then score
+export function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[] {
+	if (!query.trim()) {
+		return items;
+	}
+
+	// Split query into tokens
+	const tokens = query
+		.trim()
+		.split(/\s+/)
+		.filter((t) => t.length > 0);
+
+	if (tokens.length === 0) {
+		return items;
+	}
+
+	const results: { item: T; totalScore: number }[] = [];
+
+	for (const item of items) {
+		const text = getText(item);
+		let totalScore = 0;
+		let allMatch = true;
+
+		// Check each token against the text - ALL must match
+		for (const token of tokens) {
+			const match = fuzzyMatch(token, text);
+			if (match.matches) {
+				totalScore += match.score;
+			} else {
+				allMatch = false;
+				break;
+			}
+		}
+
+		// Only include if all tokens match
+		if (allMatch) {
+			results.push({ item, totalScore });
+		}
+	}
+
+	// Sort by score (asc, lower is better)
+	results.sort((a, b) => a.totalScore - b.totalScore);
+
+	return results.map((r) => r.item);
+}

package/src/utils/mime.ts

@@ -0,0 +1,30 @@
+import { open } from "node:fs/promises";
+import { fileTypeFromBuffer } from "file-type";
+
+const IMAGE_MIME_TYPES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
+
+const FILE_TYPE_SNIFF_BYTES = 4100;
+
+export async function detectSupportedImageMimeTypeFromFile(filePath: string): Promise<string | null> {
+	const fileHandle = await open(filePath, "r");
+	try {
+		const buffer = Buffer.alloc(FILE_TYPE_SNIFF_BYTES);
+		const { bytesRead } = await fileHandle.read(buffer, 0, FILE_TYPE_SNIFF_BYTES, 0);
+		if (bytesRead === 0) {
+			return null;
+		}
+
+		const fileType = await fileTypeFromBuffer(buffer.subarray(0, bytesRead));
+		if (!fileType) {
+			return null;
+		}
+
+		if (!IMAGE_MIME_TYPES.has(fileType.mime)) {
+			return null;
+		}
+
+		return fileType.mime;
+	} finally {
+		await fileHandle.close();
+	}
+}