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

package/src/core/compaction/utils.ts

@@ -0,0 +1,153 @@
+/**
+ * Shared utilities for compaction and branch summarization.
+ */
+
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { Message } from "@oh-my-pi/pi-ai";
+import summarizationSystemPrompt from "../../prompts/summarization-system.md" with { type: "text" };
+
+// ============================================================================
+// File Operation Tracking
+// ============================================================================
+
+export interface FileOperations {
+	read: Set<string>;
+	written: Set<string>;
+	edited: Set<string>;
+}
+
+export function createFileOps(): FileOperations {
+	return {
+		read: new Set(),
+		written: new Set(),
+		edited: new Set(),
+	};
+}
+
+/**
+ * Extract file operations from tool calls in an assistant message.
+ */
+export function extractFileOpsFromMessage(message: AgentMessage, fileOps: FileOperations): void {
+	if (message.role !== "assistant") return;
+	if (!("content" in message) || !Array.isArray(message.content)) return;
+
+	for (const block of message.content) {
+		if (typeof block !== "object" || block === null) continue;
+		if (!("type" in block) || block.type !== "toolCall") continue;
+		if (!("arguments" in block) || !("name" in block)) continue;
+
+		const args = block.arguments as Record<string, unknown> | undefined;
+		if (!args) continue;
+
+		const path = typeof args.path === "string" ? args.path : undefined;
+		if (!path) continue;
+
+		switch (block.name) {
+			case "read":
+				fileOps.read.add(path);
+				break;
+			case "write":
+				fileOps.written.add(path);
+				break;
+			case "edit":
+				fileOps.edited.add(path);
+				break;
+		}
+	}
+}
+
+/**
+ * Compute final file lists from file operations.
+ * Returns readFiles (files only read, not modified) and modifiedFiles.
+ */
+export function computeFileLists(fileOps: FileOperations): { readFiles: string[]; modifiedFiles: string[] } {
+	const modified = new Set([...fileOps.edited, ...fileOps.written]);
+	const readOnly = [...fileOps.read].filter((f) => !modified.has(f)).sort();
+	const modifiedFiles = [...modified].sort();
+	return { readFiles: readOnly, modifiedFiles };
+}
+
+/**
+ * Format file operations as XML tags for summary.
+ */
+export function formatFileOperations(readFiles: string[], modifiedFiles: string[]): string {
+	const sections: string[] = [];
+	if (readFiles.length > 0) {
+		sections.push(`<read-files>\n${readFiles.join("\n")}\n</read-files>`);
+	}
+	if (modifiedFiles.length > 0) {
+		sections.push(`<modified-files>\n${modifiedFiles.join("\n")}\n</modified-files>`);
+	}
+	if (sections.length === 0) return "";
+	return `\n\n${sections.join("\n\n")}`;
+}
+
+// ============================================================================
+// Message Serialization
+// ============================================================================
+
+/**
+ * Serialize LLM messages to text for summarization.
+ * This prevents the model from treating it as a conversation to continue.
+ * Call convertToLlm() first to handle custom message types.
+ */
+export function serializeConversation(messages: Message[]): string {
+	const parts: string[] = [];
+
+	for (const msg of messages) {
+		if (msg.role === "user") {
+			const content =
+				typeof msg.content === "string"
+					? msg.content
+					: msg.content
+							.filter((c): c is { type: "text"; text: string } => c.type === "text")
+							.map((c) => c.text)
+							.join("");
+			if (content) parts.push(`[User]: ${content}`);
+		} else if (msg.role === "assistant") {
+			const textParts: string[] = [];
+			const thinkingParts: string[] = [];
+			const toolCalls: string[] = [];
+
+			for (const block of msg.content) {
+				if (block.type === "text") {
+					textParts.push(block.text);
+				} else if (block.type === "thinking") {
+					thinkingParts.push(block.thinking);
+				} else if (block.type === "toolCall") {
+					const args = block.arguments as Record<string, unknown>;
+					const argsStr = Object.entries(args)
+						.map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+						.join(", ");
+					toolCalls.push(`${block.name}(${argsStr})`);
+				}
+			}
+
+			if (thinkingParts.length > 0) {
+				parts.push(`[Assistant thinking]: ${thinkingParts.join("\n")}`);
+			}
+			if (textParts.length > 0) {
+				parts.push(`[Assistant]: ${textParts.join("\n")}`);
+			}
+			if (toolCalls.length > 0) {
+				parts.push(`[Assistant tool calls]: ${toolCalls.join("; ")}`);
+			}
+		} else if (msg.role === "toolResult") {
+			const content = msg.content
+				.filter((c): c is { type: "text"; text: string } => c.type === "text")
+				.map((c) => c.text)
+				.join("");
+			if (content) {
+				parts.push(`[Tool result]: ${content}`);
+			}
+		}
+	}
+
+	return parts.join("\n\n");
+}
+
+// ============================================================================
+// Summarization System Prompt
+// ============================================================================
+
+export const SUMMARIZATION_SYSTEM_PROMPT = summarizationSystemPrompt;

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

@@ -0,0 +1,156 @@
+/**
+ * /review command - Interactive code review launcher
+ *
+ * Provides a menu to select review mode:
+ * 1. Review against a base branch (PR style)
+ * 2. Review uncommitted changes
+ * 3. Review a specific commit
+ * 4. Custom review instructions
+ */
+
+import type { HookCommandContext } from "../../../hooks/types";
+import type { CustomCommand, CustomCommandAPI } from "../../types";
+
+export function createReviewCommand(api: CustomCommandAPI): CustomCommand {
+	return {
+		name: "review",
+		description: "Launch interactive code review",
+
+		async execute(_args: string[], ctx: HookCommandContext): Promise<string | undefined> {
+			if (!ctx.hasUI) {
+				return "Use the Task tool to run the 'reviewer' agent to review recent code changes.";
+			}
+
+			// Main menu
+			const mode = await ctx.ui.select("Review Mode", [
+				"1. Review against a base branch (PR Style)",
+				"2. Review uncommitted changes",
+				"3. Review a specific commit",
+				"4. Custom review instructions",
+			]);
+
+			if (!mode) return undefined;
+
+			const modeNum = parseInt(mode[0], 10);
+
+			switch (modeNum) {
+				case 1: {
+					// PR-style review against base branch
+					const branches = await getGitBranches(api);
+					if (branches.length === 0) {
+						ctx.ui.notify("No git branches found", "error");
+						return undefined;
+					}
+
+					const baseBranch = await ctx.ui.select("Select base branch to compare against", branches);
+					if (!baseBranch) return undefined;
+
+					const currentBranch = await getCurrentBranch(api);
+					return `Use the Task tool to run the "reviewer" agent with this task:
+
+Review the changes between "${baseBranch}" and "${currentBranch}".
+
+Run \`git diff ${baseBranch}...${currentBranch}\` to see the changes, then analyze the modified files.`;
+				}
+
+				case 2: {
+					// Uncommitted changes
+					const status = await getGitStatus(api);
+					if (!status.trim()) {
+						ctx.ui.notify("No uncommitted changes found", "warning");
+						return undefined;
+					}
+
+					return `Use the Task tool to run the "reviewer" agent with this task:
+
+Review all uncommitted changes in the working directory.
+
+Run \`git diff\` for unstaged changes and \`git diff --cached\` for staged changes.`;
+				}
+
+				case 3: {
+					// Specific commit
+					const commits = await getRecentCommits(api, 20);
+					if (commits.length === 0) {
+						ctx.ui.notify("No commits found", "error");
+						return undefined;
+					}
+
+					const selected = await ctx.ui.select("Select commit to review", commits);
+					if (!selected) return undefined;
+
+					// Extract commit hash from selection (format: "abc1234 message")
+					const hash = selected.split(" ")[0];
+
+					return `Use the Task tool to run the "reviewer" agent with this task:
+
+Review commit ${hash}.
+
+Run \`git show ${hash}\` to see the changes introduced by this commit.`;
+				}
+
+				case 4: {
+					// Custom instructions
+					const instructions = await ctx.ui.editor(
+						"Enter custom review instructions",
+						"Review the following:\n\n",
+					);
+					if (!instructions?.trim()) return undefined;
+
+					return `Use the Task tool to run the "reviewer" agent with this task:
+
+${instructions}`;
+				}
+
+				default:
+					return undefined;
+			}
+		},
+	};
+}
+
+async function getGitBranches(api: CustomCommandAPI): Promise<string[]> {
+	try {
+		const result = await api.exec("git", ["branch", "-a", "--format=%(refname:short)"]);
+		if (result.code !== 0) return [];
+		return result.stdout
+			.split("\n")
+			.map((b) => b.trim())
+			.filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+
+async function getCurrentBranch(api: CustomCommandAPI): Promise<string> {
+	try {
+		const result = await api.exec("git", ["branch", "--show-current"]);
+		return result.stdout.trim() || "HEAD";
+	} catch {
+		return "HEAD";
+	}
+}
+
+async function getGitStatus(api: CustomCommandAPI): Promise<string> {
+	try {
+		const result = await api.exec("git", ["status", "--porcelain"]);
+		return result.stdout;
+	} catch {
+		return "";
+	}
+}
+
+async function getRecentCommits(api: CustomCommandAPI, count: number): Promise<string[]> {
+	try {
+		const result = await api.exec("git", ["log", `-${count}`, "--oneline", "--no-decorate"]);
+		if (result.code !== 0) return [];
+		return result.stdout
+			.split("\n")
+			.map((c) => c.trim())
+			.filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+
+export default createReviewCommand;

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

@@ -0,0 +1,15 @@
+export {
+	type DiscoverCustomCommandsOptions,
+	type DiscoverCustomCommandsResult,
+	discoverCustomCommands,
+	type LoadCustomCommandsOptions,
+	loadCustomCommands,
+} from "./loader";
+export type {
+	CustomCommand,
+	CustomCommandAPI,
+	CustomCommandFactory,
+	CustomCommandSource,
+	CustomCommandsLoadResult,
+	LoadedCustomCommand,
+} from "./types";

package/src/core/custom-commands/loader.ts

@@ -0,0 +1,226 @@
+/**
+ * Custom command loader - loads TypeScript command modules using native Bun import.
+ *
+ * Dependencies (@sinclair/typebox and pi-coding-agent) are injected via the CustomCommandAPI
+ * to avoid import resolution issues with custom commands loaded from user directories.
+ */
+
+import { type Dirent, existsSync, readdirSync } from "node:fs";
+import * as path from "node:path";
+import * as typebox from "@sinclair/typebox";
+import { getAgentDir, getConfigDirs } from "../../config";
+import * as piCodingAgent from "../../index";
+import { execCommand } from "../exec";
+import { createReviewCommand } from "./bundled/review";
+import type {
+	CustomCommand,
+	CustomCommandAPI,
+	CustomCommandFactory,
+	CustomCommandSource,
+	CustomCommandsLoadResult,
+	LoadedCustomCommand,
+} from "./types";
+
+/**
+ * Load a single command module using native Bun import.
+ */
+async function loadCommandModule(
+	commandPath: string,
+	_cwd: string,
+	sharedApi: CustomCommandAPI,
+): Promise<{ commands: CustomCommand[] | null; error: string | null }> {
+	try {
+		const module = await import(commandPath);
+		const factory = (module.default ?? module) as CustomCommandFactory;
+
+		if (typeof factory !== "function") {
+			return { commands: null, error: "Command must export a default function" };
+		}
+
+		const result = await factory(sharedApi);
+		const commands = Array.isArray(result) ? result : [result];
+
+		// Validate commands
+		for (const cmd of commands) {
+			if (!cmd.name || typeof cmd.name !== "string") {
+				return { commands: null, error: "Command must have a name" };
+			}
+			if (!cmd.description || typeof cmd.description !== "string") {
+				return { commands: null, error: `Command "${cmd.name}" must have a description` };
+			}
+			if (typeof cmd.execute !== "function") {
+				return { commands: null, error: `Command "${cmd.name}" must have an execute function` };
+			}
+		}
+
+		return { commands, error: null };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		return { commands: null, error: `Failed to load command: ${message}` };
+	}
+}
+
+export interface DiscoverCustomCommandsOptions {
+	/** Current working directory. Default: process.cwd() */
+	cwd?: string;
+	/** Agent config directory. Default: from getAgentDir() */
+	agentDir?: string;
+}
+
+export interface DiscoverCustomCommandsResult {
+	/** Paths to command modules */
+	paths: Array<{ path: string; source: CustomCommandSource }>;
+}
+
+/**
+ * Discover custom command modules (TypeScript slash commands).
+ * Markdown slash commands are handled by core/slash-commands.ts.
+ */
+export function discoverCustomCommands(options: DiscoverCustomCommandsOptions = {}): DiscoverCustomCommandsResult {
+	const cwd = options.cwd ?? process.cwd();
+	const agentDir = options.agentDir ?? getAgentDir();
+	const paths: Array<{ path: string; source: CustomCommandSource }> = [];
+	const seen = new Set<string>();
+
+	const addPath = (commandPath: string, source: CustomCommandSource): void => {
+		const resolved = path.resolve(commandPath);
+		if (seen.has(resolved)) return;
+		seen.add(resolved);
+		paths.push({ path: resolved, source });
+	};
+
+	const commandDirs: Array<{ path: string; source: CustomCommandSource }> = [];
+	if (agentDir) {
+		const userCommandsDir = path.join(agentDir, "commands");
+		if (existsSync(userCommandsDir)) {
+			commandDirs.push({ path: userCommandsDir, source: "user" });
+		}
+	}
+
+	for (const entry of getConfigDirs("commands", { cwd, existingOnly: true })) {
+		const source = entry.level === "user" ? "user" : "project";
+		if (!commandDirs.some((d) => d.path === entry.path)) {
+			commandDirs.push({ path: entry.path, source });
+		}
+	}
+
+	const indexCandidates = ["index.ts", "index.js", "index.mjs", "index.cjs"];
+	for (const { path: commandsDir, source } of commandDirs) {
+		let entries: Dirent[];
+		try {
+			entries = readdirSync(commandsDir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+			const commandDir = path.join(commandsDir, entry.name);
+
+			for (const filename of indexCandidates) {
+				const candidate = path.join(commandDir, filename);
+				if (existsSync(candidate)) {
+					addPath(candidate, source);
+					break;
+				}
+			}
+		}
+	}
+
+	return { paths };
+}
+
+export interface LoadCustomCommandsOptions {
+	/** Current working directory. Default: process.cwd() */
+	cwd?: string;
+	/** Agent config directory. Default: from getAgentDir() */
+	agentDir?: string;
+}
+
+/**
+ * Load bundled commands (shipped with pi-coding-agent).
+ */
+function loadBundledCommands(sharedApi: CustomCommandAPI): LoadedCustomCommand[] {
+	const bundled: LoadedCustomCommand[] = [];
+
+	// Add bundled commands here
+	const reviewCommand = createReviewCommand(sharedApi);
+	bundled.push({
+		path: "bundled:review",
+		resolvedPath: "bundled:review",
+		command: reviewCommand,
+		source: "bundled",
+	});
+
+	return bundled;
+}
+
+/**
+ * Discover and load custom commands from standard locations.
+ */
+export async function loadCustomCommands(options: LoadCustomCommandsOptions = {}): Promise<CustomCommandsLoadResult> {
+	const cwd = options.cwd ?? process.cwd();
+	const agentDir = options.agentDir ?? getAgentDir();
+
+	const { paths } = discoverCustomCommands({ cwd, agentDir });
+
+	const commands: LoadedCustomCommand[] = [];
+	const errors: Array<{ path: string; error: string }> = [];
+	const seenNames = new Set<string>();
+
+	// Shared API object - all commands get the same instance
+	const sharedApi: CustomCommandAPI = {
+		cwd,
+		exec: (command: string, args: string[], execOptions) =>
+			execCommand(command, args, execOptions?.cwd ?? cwd, execOptions),
+		typebox,
+		pi: piCodingAgent,
+	};
+
+	// 1. Load bundled commands first (lowest priority - can be overridden)
+	for (const loaded of loadBundledCommands(sharedApi)) {
+		seenNames.add(loaded.command.name);
+		commands.push(loaded);
+	}
+
+	// 2. Load user/project commands (can override bundled)
+	for (const { path: commandPath, source } of paths) {
+		const { commands: loadedCommands, error } = await loadCommandModule(commandPath, cwd, sharedApi);
+
+		if (error) {
+			errors.push({ path: commandPath, error });
+			continue;
+		}
+
+		if (loadedCommands) {
+			for (const command of loadedCommands) {
+				// Allow overriding bundled commands, but not user/project conflicts
+				const existingIdx = commands.findIndex((c) => c.command.name === command.name);
+				if (existingIdx !== -1) {
+					const existing = commands[existingIdx];
+					if (existing.source === "bundled") {
+						// Override bundled command
+						commands.splice(existingIdx, 1);
+						seenNames.delete(command.name);
+					} else {
+						// Conflict between user/project commands
+						errors.push({
+							path: commandPath,
+							error: `Command name "${command.name}" conflicts with existing command`,
+						});
+						continue;
+					}
+				}
+
+				seenNames.add(command.name);
+				commands.push({
+					path: commandPath,
+					resolvedPath: path.resolve(commandPath),
+					command,
+					source,
+				});
+			}
+		}
+	}
+
+	return { commands, errors };
+}

package/src/core/custom-commands/types.ts

@@ -0,0 +1,112 @@
+/**
+ * Custom command types.
+ *
+ * Custom commands are TypeScript modules that define executable slash commands.
+ * Unlike markdown commands which expand to prompts, custom commands can execute
+ * arbitrary logic with full access to the hook context.
+ */
+
+import type { ExecOptions, ExecResult, HookCommandContext } from "../hooks/types";
+
+// Re-export for custom commands to use
+export type { ExecOptions, ExecResult, HookCommandContext };
+
+/**
+ * API passed to custom command factory.
+ * Similar to HookAPI but focused on command needs.
+ */
+export interface CustomCommandAPI {
+	/** Current working directory */
+	cwd: string;
+	/** Execute a shell command */
+	exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
+	/** Injected @sinclair/typebox module */
+	typebox: typeof import("@sinclair/typebox");
+	/** Injected pi-coding-agent exports */
+	pi: typeof import("../../index.js");
+}
+
+/**
+ * Custom command definition.
+ *
+ * Commands can either:
+ * - Return a string to be sent to the LLM as a prompt
+ * - Return void/undefined to do nothing (fire-and-forget)
+ *
+ * @example
+ * ```typescript
+ * const factory: CustomCommandFactory = (pi) => ({
+ *	  name: "deploy",
+ *	  description: "Deploy current branch to staging",
+ *	  async execute(args, ctx) {
+ *		 const env = args[0] || "staging";
+ *		 const confirmed = await ctx.ui.confirm("Deploy", `Deploy to ${env}?`);
+ *		 if (!confirmed) return;
+ *
+ *		 const result = await pi.exec("./deploy.sh", [env]);
+ *		 if (result.exitCode !== 0) {
+ *			ctx.ui.notify(`Deploy failed: ${result.stderr}`, "error");
+ *			return;
+ *		 }
+ *
+ *		 ctx.ui.notify("Deploy successful!", "info");
+ *		 // No return = no prompt sent to LLM
+ *	  }
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Return a prompt to send to the LLM
+ * const factory: CustomCommandFactory = (pi) => ({
+ *	  name: "git:status",
+ *	  description: "Show git status and suggest actions",
+ *	  async execute(args, ctx) {
+ *		 const result = await pi.exec("git", ["status", "--porcelain"]);
+ *		 return `Here's the git status:\n\`\`\`\n${result.stdout}\`\`\`\nSuggest what to do next.`;
+ *	  }
+ * });
+ * ```
+ */
+export interface CustomCommand {
+	/** Command name (can include namespace like "git:commit") */
+	name: string;
+	/** Description shown in command autocomplete */
+	description: string;
+	/**
+	 * Execute the command.
+	 * @param args - Parsed command arguments
+	 * @param ctx - Command context with UI and session control
+	 * @returns String to send as prompt, or void for fire-and-forget
+	 */
+	execute(args: string[], ctx: HookCommandContext): Promise<string | undefined> | string | undefined;
+}
+
+/**
+ * Factory function that creates custom command(s).
+ * Can return a single command or an array of commands.
+ */
+export type CustomCommandFactory = (
+	api: CustomCommandAPI,
+) => CustomCommand | CustomCommand[] | Promise<CustomCommand | CustomCommand[]>;
+
+/** Source of a loaded custom command */
+export type CustomCommandSource = "bundled" | "user" | "project";
+
+/** Loaded custom command with metadata */
+export interface LoadedCustomCommand {
+	/** Original path to the command module */
+	path: string;
+	/** Resolved absolute path */
+	resolvedPath: string;
+	/** The command definition */
+	command: CustomCommand;
+	/** Where the command was loaded from */
+	source: CustomCommandSource;
+}
+
+/** Result from loading custom commands */
+export interface CustomCommandsLoadResult {
+	commands: LoadedCustomCommand[];
+	errors: Array<{ path: string; error: string }>;
+}

package/src/core/custom-tools/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Custom tools module.
+ */
+
+export { discoverAndLoadCustomTools, loadCustomTools } from "./loader";
+export type {
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	CustomTool,
+	CustomToolAPI,
+	CustomToolContext,
+	CustomToolFactory,
+	CustomToolResult,
+	CustomToolSessionEvent,
+	CustomToolsLoadResult,
+	CustomToolUIContext,
+	ExecResult,
+	LoadedCustomTool,
+	RenderResultOptions,
+	ToolLoadError,
+} from "./types";
+export { wrapCustomTool, wrapCustomTools } from "./wrapper";