@oh-my-pi/pi-coding-agent 4.0.1 → 4.2.0

package/src/core/custom-commands/bundled/review/index.ts

@@ -14,6 +14,7 @@
 
 import reviewRequestTemplate from "../../../../prompts/review-request.md" with { type: "text" };
 import type { HookCommandContext } from "../../../hooks/types";
+import { renderPromptTemplate } from "../../../prompt-templates";
 import type { CustomCommand, CustomCommandAPI } from "../../types";
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -164,20 +165,6 @@ function getRecommendedAgentCount(stats: DiffStats): number {
 	return Math.min(16, fileCount);
 }
 
-/**
- * Format diff stats as a markdown table for the prompt.
- */
-function formatFileTable(files: FileDiff[]): string {
-	if (files.length === 0) return "_No files to review._";
-
-	const rows = files.map((f) => {
-		const ext = getFileExt(f.path);
-		return `| ${f.path} | +${f.linesAdded}/-${f.linesRemoved} | ${ext} |`;
-	});
-
-	return `| File | +/- | Type |\n|------|-----|------|\n${rows.join("\n")}`;
-}
-
 /**
  * Extract first N lines of actual diff content (excluding headers) for preview.
  */
@@ -203,33 +190,6 @@ function getDiffPreview(hunks: string, maxLines: number): string {
 	return contentLines.join("\n");
 }
 
-/**
- * Format condensed diff previews for large changesets.
- */
-function formatDiffPreviews(files: FileDiff[], linesPerFile: number): string {
-	const parts: string[] = [];
-
-	for (const f of files) {
-		const preview = getDiffPreview(f.hunks, linesPerFile);
-		if (preview.trim()) {
-			parts.push(`#### ${f.path}\n\`\`\`diff\n${preview}\n\`\`\``);
-		}
-	}
-
-	return parts.join("\n\n");
-}
-
-/**
- * Format excluded files list for the prompt.
- */
-function formatExcluded(excluded: DiffStats["excluded"]): string {
-	if (excluded.length === 0) return "";
-
-	const items = excluded.map((e) => `- \`${e.path}\` (+${e.linesAdded}/-${e.linesRemoved}) — ${e.reason}`);
-
-	return `### Excluded Files (${excluded.length})\n\n${items.join("\n")}`;
-}
-
 // Thresholds for diff inclusion
 const MAX_DIFF_CHARS = 50_000; // Don't include diff above this
 const MAX_FILES_FOR_INLINE_DIFF = 20; // Don't include diff if more files than this
@@ -241,59 +201,27 @@ function buildReviewPrompt(mode: string, stats: DiffStats, rawDiff: string): str
 	const agentCount = getRecommendedAgentCount(stats);
 	const skipDiff = rawDiff.length > MAX_DIFF_CHARS || stats.files.length > MAX_FILES_FOR_INLINE_DIFF;
 	const totalLines = stats.totalAdded + stats.totalRemoved;
-
-	// Build distribution guidance
-	const distributionGuidance =
-		`Based on the diff weight (~${totalLines} lines across ${stats.files.length} files), ` +
-		(agentCount === 1 ? `use **1 reviewer agent**.` : `spawn **${agentCount} reviewer agents** in parallel.`);
-
-	// Build grouping guidance (only for multi-agent)
-	const groupingGuidance =
-		agentCount > 1
-			? `Group files by locality (related changes together). For example:
-- Files in the same directory or module → same agent
-- Files that implement related functionality → same agent
-- Test files with their implementation files → same agent
-
-Use the Task tool with \`agent: "reviewer"\` and the batch \`tasks\` array to run reviews in parallel.`
-			: "";
-
-	// Build diff section
-	let diffSection: string;
-	if (!skipDiff) {
-		diffSection = `### Diff
-
-<diff>
-${rawDiff.trim()}
-</diff>`;
-	} else {
-		const linesPerFile = Math.max(5, Math.floor(100 / stats.files.length));
-		diffSection = `### Diff Previews
-
-_Full diff too large (${stats.files.length} files). Showing first ~${linesPerFile} lines per file. Reviewers should fetch full diffs for assigned files._
-
-${formatDiffPreviews(stats.files, linesPerFile)}`;
-	}
-
-	// Build diff instruction
-	const diffInstruction = skipDiff
-		? "Run `git diff` or `git show` to get the diff for assigned files"
-		: "Use the diff hunks provided below (don't re-run git diff)";
-
-	// Replace template variables
-	return reviewRequestTemplate
-		.replace("{MODE}", mode)
-		.replace("{FILE_COUNT}", String(stats.files.length))
-		.replace("{LINES_ADDED}", String(stats.totalAdded))
-		.replace("{LINES_REMOVED}", String(stats.totalRemoved))
-		.replace("{FILE_TABLE}", formatFileTable(stats.files))
-		.replace("{EXCLUDED_SECTION}", stats.excluded.length > 0 ? formatExcluded(stats.excluded) : "")
-		.replace("{DISTRIBUTION_GUIDANCE}", distributionGuidance)
-		.replace("{GROUPING_GUIDANCE}", groupingGuidance)
-		.replace("{DIFF_INSTRUCTION}", diffInstruction)
-		.replace("{DIFF_SECTION}", diffSection)
-		.replace(/\n{3,}/g, "\n\n") // Collapse multiple blank lines
-		.trim();
+	const linesPerFile = skipDiff ? Math.max(5, Math.floor(100 / stats.files.length)) : 0;
+
+	const filesWithExt = stats.files.map((f) => ({
+		...f,
+		ext: getFileExt(f.path),
+		hunksPreview: skipDiff ? getDiffPreview(f.hunks, linesPerFile) : "",
+	}));
+
+	return renderPromptTemplate(reviewRequestTemplate, {
+		mode,
+		files: filesWithExt,
+		excluded: stats.excluded,
+		totalAdded: stats.totalAdded,
+		totalRemoved: stats.totalRemoved,
+		totalLines,
+		agentCount,
+		multiAgent: agentCount > 1,
+		skipDiff,
+		rawDiff: rawDiff.trim(),
+		linesPerFile,
+	});
 }
 
 export function createReviewCommand(api: CustomCommandAPI): CustomCommand {

package/src/core/custom-share.ts

@@ -0,0 +1,66 @@
+/**
+ * Custom share script loader.
+ *
+ * Allows users to define a custom share handler at ~/.omp/agent/share.ts
+ * that will be used instead of the default GitHub Gist sharing.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "../config";
+
+export interface CustomShareResult {
+	/** URL to display/open (optional - script may handle everything itself) */
+	url?: string;
+	/** Additional message to show the user */
+	message?: string;
+}
+
+export type CustomShareFn = (htmlPath: string) => Promise<CustomShareResult | string | undefined>;
+
+interface LoadedCustomShare {
+	path: string;
+	fn: CustomShareFn;
+}
+
+const SHARE_SCRIPT_CANDIDATES = ["share.ts", "share.js", "share.mjs"];
+
+/**
+ * Get the path to the custom share script if it exists.
+ */
+export function getCustomSharePath(): string | null {
+	const agentDir = getAgentDir();
+
+	for (const candidate of SHARE_SCRIPT_CANDIDATES) {
+		const scriptPath = join(agentDir, candidate);
+		if (existsSync(scriptPath)) {
+			return scriptPath;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Load the custom share script if it exists.
+ */
+export async function loadCustomShare(): Promise<LoadedCustomShare | null> {
+	const scriptPath = getCustomSharePath();
+	if (!scriptPath) {
+		return null;
+	}
+
+	try {
+		const module = await import(scriptPath);
+		const fn = module.default;
+
+		if (typeof fn !== "function") {
+			throw new Error("share script must export a default function");
+		}
+
+		return { path: scriptPath, fn };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to load share script: ${message}`);
+	}
+}

package/src/core/history-storage.ts

@@ -0,0 +1,174 @@
+import { Database } from "bun:sqlite";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "../config";
+import { logger } from "./logger";
+
+export interface HistoryEntry {
+	id: number;
+	prompt: string;
+	created_at: number;
+	cwd?: string;
+}
+
+type Statement = ReturnType<Database["prepare"]>;
+
+type HistoryRow = {
+	id: number;
+	prompt: string;
+	created_at: number;
+	cwd: string | null;
+};
+
+export class HistoryStorage {
+	private db: Database;
+	private static instance?: HistoryStorage;
+
+	// Prepared statements
+	private insertStmt: Statement;
+	private recentStmt: Statement;
+	private searchStmt: Statement;
+	private lastPromptStmt: Statement;
+
+	// In-memory cache of last prompt to avoid sync DB reads on add
+	private lastPromptCache: string | null = null;
+
+	private constructor(dbPath: string) {
+		this.ensureDir(dbPath);
+
+		this.db = new Database(dbPath);
+
+		const hasFts = this.db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='history_fts'").get();
+
+		this.db.exec(`
+PRAGMA journal_mode=WAL;
+PRAGMA synchronous=NORMAL;
+
+CREATE TABLE IF NOT EXISTS history (
+	id INTEGER PRIMARY KEY AUTOINCREMENT,
+	prompt TEXT NOT NULL,
+	created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+	cwd TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_history_created_at ON history(created_at DESC);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS history_fts USING fts5(prompt, content='history', content_rowid='id');
+
+CREATE TRIGGER IF NOT EXISTS history_ai AFTER INSERT ON history BEGIN
+	INSERT INTO history_fts(rowid, prompt) VALUES (new.id, new.prompt);
+END;
+`);
+
+		if (!hasFts) {
+			try {
+				this.db.run("INSERT INTO history_fts(history_fts) VALUES('rebuild')");
+			} catch (error) {
+				logger.warn("HistoryStorage FTS rebuild failed", { error: String(error) });
+			}
+		}
+
+		this.insertStmt = this.db.prepare("INSERT INTO history (prompt, cwd) VALUES (?, ?)");
+		this.recentStmt = this.db.prepare(
+			"SELECT id, prompt, created_at, cwd FROM history ORDER BY created_at DESC, id DESC LIMIT ?",
+		);
+		this.searchStmt = this.db.prepare(
+			"SELECT h.id, h.prompt, h.created_at, h.cwd FROM history_fts f JOIN history h ON h.id = f.rowid WHERE history_fts MATCH ? ORDER BY h.created_at DESC, h.id DESC LIMIT ?",
+		);
+		this.lastPromptStmt = this.db.prepare("SELECT prompt FROM history ORDER BY id DESC LIMIT 1");
+
+		const last = this.lastPromptStmt.get() as { prompt?: string } | undefined;
+		this.lastPromptCache = last?.prompt ?? null;
+	}
+
+	static open(dbPath: string = join(getAgentDir(), "history.db")): HistoryStorage {
+		if (!HistoryStorage.instance) {
+			HistoryStorage.instance = new HistoryStorage(dbPath);
+		}
+		return HistoryStorage.instance;
+	}
+
+	add(prompt: string, cwd?: string): void {
+		const trimmed = prompt.trim();
+		if (!trimmed) return;
+		if (this.lastPromptCache === trimmed) return;
+
+		this.lastPromptCache = trimmed;
+
+		setImmediate(() => {
+			try {
+				this.insertStmt.run(trimmed, cwd ?? null);
+			} catch (error) {
+				logger.error("HistoryStorage add failed", { error: String(error) });
+			}
+		});
+	}
+
+	getRecent(limit: number): HistoryEntry[] {
+		const safeLimit = this.normalizeLimit(limit);
+		if (safeLimit === 0) return [];
+
+		try {
+			const rows = this.recentStmt.all(safeLimit) as HistoryRow[];
+			return rows.map((row) => this.toEntry(row));
+		} catch (error) {
+			logger.error("HistoryStorage getRecent failed", { error: String(error) });
+			return [];
+		}
+	}
+
+	search(query: string, limit: number): HistoryEntry[] {
+		const safeLimit = this.normalizeLimit(limit);
+		if (safeLimit === 0) return [];
+
+		const ftsQuery = this.buildFtsQuery(query);
+		if (!ftsQuery) return [];
+
+		try {
+			const rows = this.searchStmt.all(ftsQuery, safeLimit) as HistoryRow[];
+			return rows.map((row) => this.toEntry(row));
+		} catch (error) {
+			logger.error("HistoryStorage search failed", { error: String(error) });
+			return [];
+		}
+	}
+
+	private ensureDir(dbPath: string): void {
+		const dir = dirname(dbPath);
+		const result = Bun.spawnSync(["mkdir", "-p", dir]);
+		if (result.exitCode !== 0) {
+			const stderr = result.stderr ? new TextDecoder().decode(result.stderr) : "";
+			throw new Error(`Failed to create history directory: ${dir} ${stderr}`.trim());
+		}
+	}
+
+	private normalizeLimit(limit: number): number {
+		if (!Number.isFinite(limit)) return 0;
+		const clamped = Math.max(0, Math.floor(limit));
+		return Math.min(clamped, 1000);
+	}
+
+	private buildFtsQuery(query: string): string | null {
+		const tokens = query
+			.trim()
+			.split(/\s+/)
+			.map((token) => token.trim())
+			.filter(Boolean);
+
+		if (tokens.length === 0) return null;
+
+		return tokens
+			.map((token) => {
+				const escaped = token.replace(/"/g, '""');
+				return `"${escaped}"*`;
+			})
+			.join(" ");
+	}
+
+	private toEntry(row: HistoryRow): HistoryEntry {
+		return {
+			id: row.id,
+			prompt: row.prompt,
+			created_at: row.created_at,
+			cwd: row.cwd ?? undefined,
+		};
+	}
+}

package/src/core/index.ts

@@ -25,6 +25,7 @@ export {
 	loadExtensionFromFactory,
 	type ToolDefinition,
 } from "./extensions/index";
+export { HistoryStorage } from "./history-storage";
 export {
 	createMCPManager,
 	discoverAndLoadMCPTools,

package/src/core/keybindings.ts

@@ -26,6 +26,7 @@ export type AppAction =
 	| "expandTools"
 	| "toggleThinking"
 	| "externalEditor"
+	| "historySearch"
 	| "followUp"
 	| "dequeue";
 
@@ -53,6 +54,7 @@ export const DEFAULT_APP_KEYBINDINGS: Record<AppAction, KeyId | KeyId[]> = {
 	cycleModelForward: "ctrl+p",
 	cycleModelBackward: "shift+ctrl+p",
 	selectModel: "ctrl+l",
+	historySearch: "ctrl+r",
 	expandTools: "ctrl+o",
 	toggleThinking: "ctrl+t",
 	externalEditor: "ctrl+g",
@@ -78,6 +80,7 @@ const APP_ACTIONS: AppAction[] = [
 	"cycleModelForward",
 	"cycleModelBackward",
 	"selectModel",
+	"historySearch",
 	"expandTools",
 	"toggleThinking",
 	"externalEditor",