@oh-my-pi/pi-coding-agent 1.341.0 → 2.0.1337

package/src/core/compaction/branch-summarization.ts

@@ -13,9 +13,9 @@ import {
 	createBranchSummaryMessage,
 	createCompactionSummaryMessage,
 	createHookMessage,
-} from "../messages.js";
-import type { ReadonlySessionManager, SessionEntry } from "../session-manager.js";
-import { estimateTokens } from "./compaction.js";
+} from "../messages";
+import type { ReadonlySessionManager, SessionEntry } from "../session-manager";
+import { estimateTokens } from "./compaction";
 import {
 	computeFileLists,
 	createFileOps,
@@ -24,7 +24,7 @@ import {
 	formatFileOperations,
 	SUMMARIZATION_SYSTEM_PROMPT,
 	serializeConversation,
-} from "./utils.js";
+} from "./utils";
 
 // ============================================================================
 // Types
@@ -44,7 +44,7 @@ export interface BranchSummaryDetails {
 	modifiedFiles: string[];
 }
 
-export type { FileOperations } from "./utils.js";
+export type { FileOperations } from "./utils";
 
 export interface BranchPreparation {
 	/** Messages extracted for summarization, in chronological order */

package/src/core/compaction/compaction.ts

@@ -8,8 +8,8 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, Model, Usage } from "@oh-my-pi/pi-ai";
 import { complete, completeSimple } from "@oh-my-pi/pi-ai";
-import { convertToLlm, createBranchSummaryMessage, createHookMessage } from "../messages.js";
-import type { CompactionEntry, SessionEntry } from "../session-manager.js";
+import { convertToLlm, createBranchSummaryMessage, createHookMessage } from "../messages";
+import type { CompactionEntry, SessionEntry } from "../session-manager";
 import {
 	computeFileLists,
 	createFileOps,
@@ -18,7 +18,7 @@ import {
 	formatFileOperations,
 	SUMMARIZATION_SYSTEM_PROMPT,
 	serializeConversation,
-} from "./utils.js";
+} from "./utils";
 
 // ============================================================================
 // File Operation Tracking

package/src/core/compaction/index.ts

@@ -2,6 +2,6 @@
  * Compaction and summarization utilities.
  */
 
-export * from "./branch-summarization.js";
-export * from "./compaction.js";
-export * from "./utils.js";
+export * from "./branch-summarization";
+export * from "./compaction";
+export * from "./utils";

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,232 @@
+/**
+ * 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 * as fs from "node:fs";
+import * as path from "node:path";
+import * as typebox from "@sinclair/typebox";
+import { CONFIG_DIR_NAME, getAgentDir } 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}` };
+	}
+}
+
+/**
+ * Discover command modules from a directory.
+ * Loads index.ts files from subdirectories (e.g., commands/deploy/index.ts).
+ */
+function discoverCommandsInDir(dir: string): string[] {
+	if (!fs.existsSync(dir)) {
+		return [];
+	}
+
+	const commands: string[] = [];
+
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			if (entry.isDirectory() || entry.isSymbolicLink()) {
+				// Check for index.ts in subdirectory
+				const indexPath = path.join(dir, entry.name, "index.ts");
+				if (fs.existsSync(indexPath)) {
+					commands.push(indexPath);
+				}
+			}
+		}
+	} catch {
+		return [];
+	}
+
+	return commands;
+}
+
+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 from standard locations:
+ * - agentDir/commands/[name]/index.ts (user)
+ * - cwd/.pi/commands/[name]/index.ts (project)
+ */
+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 addPaths = (modulePaths: string[], source: CustomCommandSource) => {
+		for (const p of modulePaths) {
+			const resolved = path.resolve(p);
+			if (!seen.has(resolved)) {
+				seen.add(resolved);
+				paths.push({ path: p, source });
+			}
+		}
+	};
+
+	// 1. User commands: agentDir/commands/
+	const userCommandsDir = path.join(agentDir, "commands");
+	addPaths(discoverCommandsInDir(userCommandsDir), "user");
+
+	// 2. Project commands: cwd/.pi/commands/
+	const projectCommandsDir = path.join(cwd, CONFIG_DIR_NAME, "commands");
+	addPaths(discoverCommandsInDir(projectCommandsDir), "project");
+
+	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

@@ -2,7 +2,7 @@
  * Custom tools module.
  */
 
-export { discoverAndLoadCustomTools, loadCustomTools } from "./loader.js";
+export { discoverAndLoadCustomTools, loadCustomTools } from "./loader";
 export type {
 	AgentToolResult,
 	AgentToolUpdateCallback,
@@ -17,5 +17,5 @@ export type {
 	ExecResult,
 	LoadedCustomTool,
 	RenderResultOptions,
-} from "./types.js";
-export { wrapCustomTool, wrapCustomTools } from "./wrapper.js";
+} from "./types";
+export { wrapCustomTool, wrapCustomTools } from "./wrapper";

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

@@ -9,14 +9,15 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as typebox from "@sinclair/typebox";
-import { getAgentDir } from "../../config.js";
-import * as piCodingAgent from "../../index.js";
-import { theme } from "../../modes/interactive/theme/theme.js";
-import type { ExecOptions } from "../exec.js";
-import { execCommand } from "../exec.js";
-import type { HookUIContext } from "../hooks/types.js";
-import { getAllPluginToolPaths } from "../plugins/loader.js";
-import type { CustomToolAPI, CustomToolFactory, CustomToolsLoadResult, LoadedCustomTool } from "./types.js";
+import { getAgentDir } from "../../config";
+import * as piCodingAgent from "../../index";
+import { theme } from "../../modes/interactive/theme/theme";
+import type { ExecOptions } from "../exec";
+import { execCommand } from "../exec";
+import type { HookUIContext } from "../hooks/types";
+import { logger } from "../logger";
+import { getAllPluginToolPaths } from "../plugins/loader";
+import type { CustomToolAPI, CustomToolFactory, CustomToolsLoadResult, LoadedCustomTool } from "./types";
 
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 
@@ -128,6 +129,7 @@ export async function loadCustomTools(
 			execCommand(command, args, options?.cwd ?? cwd, options),
 		ui: createNoOpUIContext(),
 		hasUI: false,
+		logger,
 		typebox,
 		pi: piCodingAgent,
 	};

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

@@ -9,11 +9,12 @@ import type { AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agen
 import type { Model } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { Static, TSchema } from "@sinclair/typebox";
-import type { Theme } from "../../modes/interactive/theme/theme.js";
-import type { ExecOptions, ExecResult } from "../exec.js";
-import type { HookUIContext } from "../hooks/types.js";
-import type { ModelRegistry } from "../model-registry.js";
-import type { ReadonlySessionManager } from "../session-manager.js";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import type { ExecOptions, ExecResult } from "../exec";
+import type { HookUIContext } from "../hooks/types";
+import type { Logger } from "../logger";
+import type { ModelRegistry } from "../model-registry";
+import type { ReadonlySessionManager } from "../session-manager";
 
 /** Alias for clarity */
 export type CustomToolUIContext = HookUIContext;
@@ -22,7 +23,7 @@ export type CustomToolUIContext = HookUIContext;
 export type { AgentToolResult, AgentToolUpdateCallback };
 
 // Re-export for backward compatibility
-export type { ExecOptions, ExecResult } from "../exec.js";
+export type { ExecOptions, ExecResult } from "../exec";
 
 /** API passed to custom tool factory (stable across session changes) */
 export interface CustomToolAPI {
@@ -34,6 +35,8 @@ export interface CustomToolAPI {
 	ui: CustomToolUIContext;
 	/** Whether UI is available (false in print/RPC mode) */
 	hasUI: boolean;
+	/** File logger for error/warning/debug messages */
+	logger: Logger;
 	/** Injected @sinclair/typebox module */
 	typebox: typeof import("@sinclair/typebox");
 	/** Injected pi-coding-agent exports */
@@ -119,6 +122,8 @@ export interface CustomTool<TParams extends TSchema = TSchema, TDetails = any> {
 	description: string;
 	/** Parameter schema (TypeBox) */
 	parameters: TParams;
+	/** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
+	hidden?: boolean;
 
 	/**
 	 * Execute the tool.

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

@@ -3,7 +3,7 @@
  */
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { CustomTool, CustomToolContext, LoadedCustomTool } from "./types.js";
+import type { CustomTool, CustomToolContext, LoadedCustomTool } from "./types";
 
 /**
  * Wrap a CustomTool into an AgentTool.
@@ -15,6 +15,7 @@ export function wrapCustomTool(tool: CustomTool, getContext: () => CustomToolCon
 		label: tool.label,
 		description: tool.description,
 		parameters: tool.parameters,
+		hidden: tool.hidden,
 		execute: (toolCallId, params, signal, onUpdate, context) =>
 			tool.execute(toolCallId, params, onUpdate, context ?? getContext(), signal),
 	};