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

package/src/core/export-html/template.macro.ts

@@ -0,0 +1,24 @@
+/**
+ * Bun macro that inlines HTML template with CSS/JS at compile time.
+ * This runs during `bun build` and embeds the result as a string.
+ */
+export async function getTemplate(): Promise<string> {
+	const dir = new URL(".", import.meta.url).pathname;
+
+	// Read all files
+	const html = await Bun.file(`${dir}template.html`).text();
+	const css = await Bun.file(`${dir}template.css`).text();
+	const js = await Bun.file(`${dir}template.js`).text();
+
+	// Minify CSS
+	const minifiedCss = css
+		.replace(/\/\*[\s\S]*?\*\//g, "")
+		.replace(/\s+/g, " ")
+		.replace(/\s*([{}:;,])\s*/g, "$1")
+		.trim();
+
+	// Inline everything
+	return html
+		.replace("<template-css/>", `<style>${minifiedCss}</style>`)
+		.replace("<template-js/>", `<script>${js}</script>`);
+}

package/src/core/file-mentions.ts

@@ -0,0 +1,54 @@
+/**
+ * Auto-read file mentions from user prompts.
+ *
+ * When users reference files with @path syntax (e.g., "@src/foo.ts"),
+ * we automatically inject the file contents as a FileMentionMessage
+ * so the agent doesn't need to read them manually.
+ */
+
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { FileMentionMessage } from "./messages";
+import { createReadTool } from "./tools/read";
+
+/** Regex to match @filepath patterns in text */
+const FILE_MENTION_REGEX = /@((?:[^\s@]+\/)*[^\s@]+\.[a-zA-Z0-9]+)/g;
+
+/** Extract all @filepath mentions from text */
+export function extractFileMentions(text: string): string[] {
+	const matches = [...text.matchAll(FILE_MENTION_REGEX)];
+	return [...new Set(matches.map((m) => m[1]))];
+}
+
+/**
+ * Generate a FileMentionMessage containing the contents of mentioned files.
+ * Returns empty array if no files could be read.
+ */
+export async function generateFileMentionMessages(filePaths: string[], cwd: string): Promise<AgentMessage[]> {
+	if (filePaths.length === 0) return [];
+
+	const readTool = createReadTool(cwd);
+	const files: FileMentionMessage["files"] = [];
+
+	for (const filePath of filePaths) {
+		try {
+			const result = await readTool.execute("auto-read", { path: filePath });
+			const textContent = result.content.find((c) => c.type === "text");
+			if (textContent && textContent.type === "text") {
+				const lineCount = textContent.text.split("\n").length;
+				files.push({ path: filePath, content: textContent.text, lineCount });
+			}
+		} catch {
+			// File doesn't exist or isn't readable - skip silently
+		}
+	}
+
+	if (files.length === 0) return [];
+
+	const message: FileMentionMessage = {
+		role: "fileMention",
+		files,
+		timestamp: Date.now(),
+	};
+
+	return [message];
+}

package/src/core/hooks/index.ts

@@ -0,0 +1,16 @@
+// biome-ignore assist/source/organizeImports: biome is not smart
+export {
+	discoverAndLoadHooks,
+	loadHooks,
+	type AppendEntryHandler,
+	type BranchHandler,
+	type LoadedHook,
+	type LoadHooksResult,
+	type NavigateTreeHandler,
+	type NewSessionHandler,
+	type SendMessageHandler,
+} from "./loader";
+export { execCommand, HookRunner, type HookErrorListener } from "./runner";
+export { wrapToolsWithHooks, wrapToolWithHooks } from "./tool-wrapper";
+export * from "./types";
+export type { UsageStatistics, ReadonlySessionManager } from "../session-manager";

package/src/core/hooks/loader.ts

@@ -0,0 +1,288 @@
+/**
+ * Hook loader - loads TypeScript hook modules using native Bun import.
+ */
+
+import * as os from "node:os";
+import * as path from "node:path";
+import * as typebox from "@sinclair/typebox";
+import { hookCapability } from "../../capability/hook";
+import type { Hook } from "../../discovery";
+import { loadSync } from "../../discovery";
+import * as piCodingAgent from "../../index";
+import { logger } from "../logger";
+import type { HookMessage } from "../messages";
+import type { SessionManager } from "../session-manager";
+import { execCommand } from "./runner";
+import type { ExecOptions, HookAPI, HookFactory, HookMessageRenderer, RegisteredCommand } from "./types";
+
+/**
+ * Generic handler function type.
+ */
+type HandlerFn = (...args: unknown[]) => Promise<unknown>;
+
+/**
+ * Send message handler type for pi.sendMessage().
+ */
+export type SendMessageHandler = <T = unknown>(
+	message: Pick<HookMessage<T>, "customType" | "content" | "display" | "details">,
+	triggerTurn?: boolean,
+) => void;
+
+/**
+ * Append entry handler type for pi.appendEntry().
+ */
+export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
+
+/**
+ * New session handler type for ctx.newSession() in HookCommandContext.
+ */
+export type NewSessionHandler = (options?: {
+	parentSession?: string;
+	setup?: (sessionManager: SessionManager) => Promise<void>;
+}) => Promise<{ cancelled: boolean }>;
+
+/**
+ * Branch handler type for ctx.branch() in HookCommandContext.
+ */
+export type BranchHandler = (entryId: string) => Promise<{ cancelled: boolean }>;
+
+/**
+ * Navigate tree handler type for ctx.navigateTree() in HookCommandContext.
+ */
+export type NavigateTreeHandler = (
+	targetId: string,
+	options?: { summarize?: boolean },
+) => Promise<{ cancelled: boolean }>;
+
+/**
+ * Registered handlers for a loaded hook.
+ */
+export interface LoadedHook {
+	/** Original path from config */
+	path: string;
+	/** Resolved absolute path */
+	resolvedPath: string;
+	/** Map of event type to handler functions */
+	handlers: Map<string, HandlerFn[]>;
+	/** Map of customType to hook message renderer */
+	messageRenderers: Map<string, HookMessageRenderer>;
+	/** Map of command name to registered command */
+	commands: Map<string, RegisteredCommand>;
+	/** Set the send message handler for this hook's pi.sendMessage() */
+	setSendMessageHandler: (handler: SendMessageHandler) => void;
+	/** Set the append entry handler for this hook's pi.appendEntry() */
+	setAppendEntryHandler: (handler: AppendEntryHandler) => void;
+}
+
+/**
+ * Result of loading hooks.
+ */
+export interface LoadHooksResult {
+	/** Successfully loaded hooks */
+	hooks: LoadedHook[];
+	/** Errors encountered during loading */
+	errors: Array<{ path: string; error: string }>;
+}
+
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+
+function normalizeUnicodeSpaces(str: string): string {
+	return str.replace(UNICODE_SPACES, " ");
+}
+
+function expandPath(p: string): string {
+	const normalized = normalizeUnicodeSpaces(p);
+	if (normalized.startsWith("~/")) {
+		return path.join(os.homedir(), normalized.slice(2));
+	}
+	if (normalized.startsWith("~")) {
+		return path.join(os.homedir(), normalized.slice(1));
+	}
+	return normalized;
+}
+
+/**
+ * Resolve hook path.
+ * - Absolute paths used as-is
+ * - Paths starting with ~ expanded to home directory
+ * - Relative paths resolved from cwd
+ */
+function resolveHookPath(hookPath: string, cwd: string): string {
+	const expanded = expandPath(hookPath);
+
+	if (path.isAbsolute(expanded)) {
+		return expanded;
+	}
+
+	// Relative paths resolved from cwd
+	return path.resolve(cwd, expanded);
+}
+
+/**
+ * Create a HookAPI instance that collects handlers, renderers, and commands.
+ * Returns the API, maps, and functions to set handlers later.
+ */
+function createHookAPI(
+	handlers: Map<string, HandlerFn[]>,
+	cwd: string,
+): {
+	api: HookAPI;
+	messageRenderers: Map<string, HookMessageRenderer>;
+	commands: Map<string, RegisteredCommand>;
+	setSendMessageHandler: (handler: SendMessageHandler) => void;
+	setAppendEntryHandler: (handler: AppendEntryHandler) => void;
+} {
+	let sendMessageHandler: SendMessageHandler | null = null;
+	let appendEntryHandler: AppendEntryHandler | null = null;
+	const messageRenderers = new Map<string, HookMessageRenderer>();
+	const commands = new Map<string, RegisteredCommand>();
+
+	// Cast to HookAPI - the implementation is more general (string event names)
+	// but the interface has specific overloads for type safety in hooks
+	const api = {
+		on(event: string, handler: HandlerFn): void {
+			if (!handlers.has(event)) {
+				handlers.set(event, []);
+			}
+			handlers.get(event)!.push(handler);
+		},
+		sendMessage<T = unknown>(message: HookMessage<T>, triggerTurn?: boolean): void {
+			if (!sendMessageHandler) {
+				throw new Error("sendMessage handler not initialized");
+			}
+			sendMessageHandler(message, triggerTurn);
+		},
+		appendEntry<T = unknown>(customType: string, data?: T): void {
+			if (!appendEntryHandler) {
+				throw new Error("appendEntry handler not initialized");
+			}
+			appendEntryHandler(customType, data);
+		},
+		registerMessageRenderer<T = unknown>(customType: string, renderer: HookMessageRenderer<T>): void {
+			messageRenderers.set(customType, renderer as HookMessageRenderer);
+		},
+		registerCommand(name: string, options: { description?: string; handler: RegisteredCommand["handler"] }): void {
+			commands.set(name, { name, ...options });
+		},
+		exec(command: string, args: string[], options?: ExecOptions) {
+			return execCommand(command, args, options?.cwd ?? cwd, options);
+		},
+		logger,
+		typebox,
+		pi: piCodingAgent,
+	} as HookAPI;
+
+	return {
+		api,
+		messageRenderers,
+		commands,
+		setSendMessageHandler: (handler: SendMessageHandler) => {
+			sendMessageHandler = handler;
+		},
+		setAppendEntryHandler: (handler: AppendEntryHandler) => {
+			appendEntryHandler = handler;
+		},
+	};
+}
+
+/**
+ * Load a single hook module using native Bun import.
+ */
+async function loadHook(hookPath: string, cwd: string): Promise<{ hook: LoadedHook | null; error: string | null }> {
+	const resolvedPath = resolveHookPath(hookPath, cwd);
+
+	try {
+		// Import the module using native Bun import
+		const module = await import(resolvedPath);
+		const factory = module.default as HookFactory;
+
+		if (typeof factory !== "function") {
+			return { hook: null, error: "Hook must export a default function" };
+		}
+
+		// Create handlers map and API
+		const handlers = new Map<string, HandlerFn[]>();
+		const { api, messageRenderers, commands, setSendMessageHandler, setAppendEntryHandler } = createHookAPI(
+			handlers,
+			cwd,
+		);
+
+		// Call factory to register handlers
+		factory(api);
+
+		return {
+			hook: {
+				path: hookPath,
+				resolvedPath,
+				handlers,
+				messageRenderers,
+				commands,
+				setSendMessageHandler,
+				setAppendEntryHandler,
+			},
+			error: null,
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		return { hook: null, error: `Failed to load hook: ${message}` };
+	}
+}
+
+/**
+ * Load all hooks from configuration.
+ * @param paths - Array of hook file paths
+ * @param cwd - Current working directory for resolving relative paths
+ */
+export async function loadHooks(paths: string[], cwd: string): Promise<LoadHooksResult> {
+	const hooks: LoadedHook[] = [];
+	const errors: Array<{ path: string; error: string }> = [];
+
+	for (const hookPath of paths) {
+		const { hook, error } = await loadHook(hookPath, cwd);
+
+		if (error) {
+			errors.push({ path: hookPath, error });
+			continue;
+		}
+
+		if (hook) {
+			hooks.push(hook);
+		}
+	}
+
+	return { hooks, errors };
+}
+
+/**
+ * Discover and load hooks from all registered providers.
+ * Uses the capability API to discover hook paths from:
+ * 1. OMP native configs (.omp/.pi hooks/)
+ * 2. Installed plugins
+ * 3. Other editor/IDE configurations
+ *
+ * Plus any explicitly configured paths from settings.
+ */
+export async function discoverAndLoadHooks(configuredPaths: string[], cwd: string): Promise<LoadHooksResult> {
+	const allPaths: string[] = [];
+	const seen = new Set<string>();
+
+	// Helper to add paths without duplicates
+	const addPaths = (paths: string[]) => {
+		for (const p of paths) {
+			const resolved = path.resolve(p);
+			if (!seen.has(resolved)) {
+				seen.add(resolved);
+				allPaths.push(p);
+			}
+		}
+	};
+
+	// 1. Discover hooks via capability API
+	const discovered = loadSync<Hook>(hookCapability.id, { cwd });
+	addPaths(discovered.items.map((hook) => hook.path));
+
+	// 2. Explicitly configured paths (can override/add)
+	addPaths(configuredPaths.map((p) => resolveHookPath(p, cwd)));
+
+	return loadHooks(allPaths, cwd);
+}