my-pi 0.1.0 → 0.1.1

package/README.md

@@ -321,6 +321,8 @@ In interactive mode:
 - `/extensions` — open the built-in extensions manager
 - `/extensions list` — print built-in extensions with saved/effective
   state
+- `/extensions enable|disable|toggle` — without a key, open the
+  interactive toggle list
 - `/extensions enable <key>` / `/extensions disable <key>` — toggle a
   built-in extension
 - `/skills` — open the interactive skills manager (unified list with

package/dist/{api-1ZXLxSgP.js → api-Dxi4curf.js}

@@ -420,6 +420,20 @@ const BUILTIN_EXTENSIONS = [
 			"session",
 			"auto-name"
 		]
+	},
+	{
+		key: "confirm-destructive",
+		label: "Confirm destructive",
+		description: "Prompt before destructive session actions like clear, switch, and fork",
+		cli_flag: "--no-confirm-destructive",
+		aliases: ["confirm-destructive", "confirm"]
+	},
+	{
+		key: "hooks-resolution",
+		label: "Hooks resolution",
+		description: "Claude Code style PostToolUse hook compatibility from .claude, .rulesync, and .pi configs",
+		cli_flag: "--no-hooks",
+		aliases: ["hooks-resolution", "hooks"]
 	}
 ];
 function get_builtin_extensions_config_path() {
@@ -483,6 +497,33 @@ function find_builtin_extension(query) {
 	].some((value) => value.toLowerCase() === normalized));
 }
 //#endregion
+//#region src/extensions/confirm-destructive.ts
+async function confirm_destructive(pi) {
+	pi.on("session_before_switch", async (event, ctx) => {
+		if (!ctx.hasUI) return;
+		if (event.reason === "new") {
+			if (!await ctx.ui.confirm("Clear session?", "This will delete all messages in the current session.")) {
+				ctx.ui.notify("Clear cancelled", "info");
+				return { cancel: true };
+			}
+			return;
+		}
+		if (ctx.sessionManager.getEntries().some((e) => e.type === "message" && e.message.role === "user")) {
+			if (!await ctx.ui.confirm("Switch session?", "You have messages in the current session. Switch anyway?")) {
+				ctx.ui.notify("Switch cancelled", "info");
+				return { cancel: true };
+			}
+		}
+	});
+	pi.on("session_before_fork", async (event, ctx) => {
+		if (!ctx.hasUI) return;
+		if (await ctx.ui.select(`Fork from entry ${event.entryId.slice(0, 8)}?`, ["Yes, create fork", "No, stay in current session"]) !== "Yes, create fork") {
+			ctx.ui.notify("Fork cancelled", "info");
+			return { cancel: true };
+		}
+	});
+}
+//#endregion
 //#region src/extensions/extensions.ts
 const ENABLED$2 = "[x]";
 const DISABLED$2 = "[ ]";
@@ -546,6 +587,66 @@ function save_extension_enabled(key, enabled) {
 }
 function create_extensions_extension(options = {}) {
 	const force_disabled = to_force_disabled_set(options.force_disabled);
+	async function show_manager(ctx) {
+		if (!ctx.hasUI) return false;
+		const states = resolve_builtin_extension_states(force_disabled);
+		const initial_enabled = new Set(states.filter((state) => state.saved_enabled).map((state) => state.key));
+		const current_enabled = new Set(initial_enabled);
+		await ctx.ui.custom((tui, theme, _kb, done) => {
+			const items = states.map(to_setting_item$1);
+			const container = new Container();
+			container.addChild({
+				render: () => {
+					const saved_enabled = current_enabled.size;
+					const saved_disabled = states.length - saved_enabled;
+					const enabled_now = [...current_enabled].filter((key) => !force_disabled.has(key)).length;
+					const disabled_now = states.length - enabled_now;
+					return [
+						theme.fg("accent", theme.bold("Built-in extensions")),
+						theme.fg("muted", `${saved_enabled} saved enabled • ${saved_disabled} saved disabled • ${enabled_now} enabled now • ${disabled_now} disabled now`),
+						""
+					];
+				},
+				invalidate: () => {}
+			});
+			const settings_list = new SettingsList(items, Math.min(Math.max(items.length + 4, 8), 16), {
+				cursor: theme.fg("accent", "›"),
+				label: (text, selected) => selected ? theme.fg("accent", text) : text,
+				value: (text, selected) => {
+					const color = text === ENABLED$2 ? "success" : "dim";
+					const rendered = theme.fg(color, text);
+					return selected ? theme.bold(theme.fg("accent", rendered)) : rendered;
+				},
+				description: (text) => theme.fg("muted", text),
+				hint: (text) => theme.fg("dim", text)
+			}, (id, new_value) => {
+				const key = id;
+				const enabled = new_value === ENABLED$2;
+				if (enabled) current_enabled.add(key);
+				else current_enabled.delete(key);
+				save_extension_enabled(key, enabled);
+			}, () => done(void 0), { enableSearch: true });
+			container.addChild(settings_list);
+			container.addChild(new Text(theme.fg("dim", "esc close • search filters • changes save immediately • CLI --no-* flags still win in this process"), 0, 1));
+			return {
+				render(width) {
+					return container.render(width);
+				},
+				invalidate() {
+					container.invalidate();
+				},
+				handleInput(data) {
+					settings_list.handleInput(data);
+					tui.requestRender();
+				}
+			};
+		});
+		if (!sets_equal$2(initial_enabled, current_enabled)) {
+			ctx.ui.notify(force_disabled.size > 0 ? "Reloading to apply updated built-in extensions. CLI --no-* flags still force-disable some extensions in this process." : "Reloading to apply updated built-in extensions...", "info");
+			await ctx.reload();
+		}
+		return true;
+	}
 	return async function extensions(pi) {
 		const subs = [
 			"list",
@@ -577,65 +678,8 @@ function create_extensions_extension(options = {}) {
 			},
 			handler: async (args, ctx) => {
 				const trimmed = args.trim();
-				if (!trimmed && ctx.hasUI) {
-					const states = resolve_builtin_extension_states(force_disabled);
-					const initial_enabled = new Set(states.filter((state) => state.saved_enabled).map((state) => state.key));
-					const current_enabled = new Set(initial_enabled);
-					await ctx.ui.custom((tui, theme, _kb, done) => {
-						const items = states.map(to_setting_item$1);
-						const container = new Container();
-						container.addChild({
-							render: () => {
-								const saved_enabled = current_enabled.size;
-								const saved_disabled = states.length - saved_enabled;
-								const enabled_now = [...current_enabled].filter((key) => !force_disabled.has(key)).length;
-								const disabled_now = states.length - enabled_now;
-								return [
-									theme.fg("accent", theme.bold("Built-in extensions")),
-									theme.fg("muted", `${saved_enabled} saved enabled • ${saved_disabled} saved disabled • ${enabled_now} enabled now • ${disabled_now} disabled now`),
-									""
-								];
-							},
-							invalidate: () => {}
-						});
-						const settings_list = new SettingsList(items, Math.min(Math.max(items.length + 4, 8), 16), {
-							cursor: theme.fg("accent", "›"),
-							label: (text, selected) => selected ? theme.fg("accent", text) : text,
-							value: (text, selected) => {
-								const color = text === ENABLED$2 ? "success" : "dim";
-								const rendered = theme.fg(color, text);
-								return selected ? theme.bold(theme.fg("accent", rendered)) : rendered;
-							},
-							description: (text) => theme.fg("muted", text),
-							hint: (text) => theme.fg("dim", text)
-						}, (id, new_value) => {
-							const key = id;
-							const enabled = new_value === ENABLED$2;
-							if (enabled) current_enabled.add(key);
-							else current_enabled.delete(key);
-							save_extension_enabled(key, enabled);
-						}, () => done(void 0), { enableSearch: true });
-						container.addChild(settings_list);
-						container.addChild(new Text(theme.fg("dim", "esc close • search filters • changes save immediately • CLI --no-* flags still win in this process"), 0, 1));
-						return {
-							render(width) {
-								return container.render(width);
-							},
-							invalidate() {
-								container.invalidate();
-							},
-							handleInput(data) {
-								settings_list.handleInput(data);
-								tui.requestRender();
-							}
-						};
-					});
-					if (!sets_equal$2(initial_enabled, current_enabled)) {
-						ctx.ui.notify(force_disabled.size > 0 ? "Reloading to apply updated built-in extensions. CLI --no-* flags still force-disable some extensions in this process." : "Reloading to apply updated built-in extensions...", "info");
-						await ctx.reload();
-						return;
-					}
-					return;
+				if (!trimmed) {
+					if (await show_manager(ctx)) return;
 				}
 				const [sub, ...rest] = (trimmed || "list").split(/\s+/);
 				const arg = rest.join(" ");
@@ -648,6 +692,7 @@ function create_extensions_extension(options = {}) {
 					case "disable":
 					case "toggle": {
 						if (!arg) {
+							if (await show_manager(ctx)) return;
 							ctx.ui.notify(`Usage: /extensions ${sub} <key>`, "warning");
 							return;
 						}
@@ -896,6 +941,312 @@ async function handoff(pi) {
 	});
 }
 //#endregion
+//#region src/extensions/hooks-resolution.ts
+const HOOK_TIMEOUT_MS = 600 * 1e3;
+function is_file(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+function as_record(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	return value;
+}
+function walk_up_directories(start_dir, stop_dir) {
+	const directories = [];
+	const has_stop_dir = stop_dir !== void 0;
+	let current = resolve(start_dir);
+	let parent = dirname(current);
+	let reached_stop_dir = has_stop_dir && current === stop_dir;
+	let reached_filesystem_root = parent === current;
+	directories.push(current);
+	while (!reached_stop_dir && !reached_filesystem_root) {
+		current = parent;
+		parent = dirname(current);
+		reached_stop_dir = has_stop_dir && current === stop_dir;
+		reached_filesystem_root = parent === current;
+		directories.push(current);
+	}
+	return directories;
+}
+function find_nearest_git_root(start_dir) {
+	for (const directory of walk_up_directories(start_dir)) if (existsSync(join(directory, ".git"))) return directory;
+}
+function has_hooks_config(directory) {
+	return is_file(join(directory, ".claude", "settings.json")) || is_file(join(directory, ".rulesync", "hooks.json")) || is_file(join(directory, ".pi", "hooks.json"));
+}
+function find_project_dir(cwd) {
+	const git_root = find_nearest_git_root(cwd);
+	for (const directory of walk_up_directories(cwd, git_root)) if (has_hooks_config(directory)) return directory;
+	return git_root ?? resolve(cwd);
+}
+function read_json_file(path) {
+	if (!is_file(path)) return void 0;
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+function resolve_hook_command(command, project_dir) {
+	return command.replace(/\$CLAUDE_PROJECT_DIR\b/g, project_dir);
+}
+function compile_matcher(matcher_text) {
+	if (matcher_text === void 0) return void 0;
+	try {
+		return new RegExp(matcher_text);
+	} catch {
+		return;
+	}
+}
+function create_hook(event_name, matcher_text, command, source, project_dir) {
+	const matcher = compile_matcher(matcher_text);
+	if (matcher_text !== void 0 && matcher === void 0) return void 0;
+	return {
+		event_name,
+		matcher,
+		matcher_text,
+		command: resolve_hook_command(command, project_dir),
+		source
+	};
+}
+function get_hook_entries(hooks_record, event_name) {
+	const keys = event_name === "PostToolUse" ? ["PostToolUse", "postToolUse"] : ["PostToolUseFailure", "postToolUseFailure"];
+	for (const key of keys) {
+		const value = hooks_record[key];
+		if (Array.isArray(value)) return value;
+	}
+	return [];
+}
+function parse_claude_settings_hooks(config, source, project_dir) {
+	const root = as_record(config);
+	const hooks_root = root ? as_record(root.hooks) : void 0;
+	if (!hooks_root) return [];
+	const hooks = [];
+	for (const event_name of ["PostToolUse", "PostToolUseFailure"]) {
+		const entries = get_hook_entries(hooks_root, event_name);
+		for (const entry of entries) {
+			const entry_record = as_record(entry);
+			if (!entry_record || !Array.isArray(entry_record.hooks)) continue;
+			const matcher_text = typeof entry_record.matcher === "string" ? entry_record.matcher : void 0;
+			for (const nested_hook of entry_record.hooks) {
+				const nested_record = as_record(nested_hook);
+				if (!nested_record) continue;
+				if (nested_record.type !== "command") continue;
+				if (typeof nested_record.command !== "string") continue;
+				const hook = create_hook(event_name, matcher_text, nested_record.command, source, project_dir);
+				if (hook) hooks.push(hook);
+			}
+		}
+	}
+	return hooks;
+}
+function parse_simple_hooks_file(config, source, project_dir) {
+	const root = as_record(config);
+	const hooks_root = root ? as_record(root.hooks) : void 0;
+	if (!hooks_root) return [];
+	const hooks = [];
+	for (const event_name of ["PostToolUse", "PostToolUseFailure"]) {
+		const entries = get_hook_entries(hooks_root, event_name);
+		for (const entry of entries) {
+			const entry_record = as_record(entry);
+			if (!entry_record || typeof entry_record.command !== "string") continue;
+			const hook = create_hook(event_name, typeof entry_record.matcher === "string" ? entry_record.matcher : void 0, entry_record.command, source, project_dir);
+			if (hook) hooks.push(hook);
+		}
+	}
+	return hooks;
+}
+function load_hooks(cwd) {
+	const project_dir = find_project_dir(cwd);
+	const hooks = [];
+	const claude_settings_path = join(project_dir, ".claude", "settings.json");
+	const rulesync_hooks_path = join(project_dir, ".rulesync", "hooks.json");
+	const pi_hooks_path = join(project_dir, ".pi", "hooks.json");
+	const claude_settings = read_json_file(claude_settings_path);
+	if (claude_settings !== void 0) hooks.push(...parse_claude_settings_hooks(claude_settings, claude_settings_path, project_dir));
+	const rulesync_hooks = read_json_file(rulesync_hooks_path);
+	if (rulesync_hooks !== void 0) hooks.push(...parse_simple_hooks_file(rulesync_hooks, rulesync_hooks_path, project_dir));
+	const pi_hooks = read_json_file(pi_hooks_path);
+	if (pi_hooks !== void 0) hooks.push(...parse_simple_hooks_file(pi_hooks, pi_hooks_path, project_dir));
+	return {
+		project_dir,
+		hooks
+	};
+}
+function to_claude_tool_name(tool_name) {
+	if (tool_name === "ls") return "LS";
+	if (tool_name.length === 0) return tool_name;
+	return tool_name[0].toUpperCase() + tool_name.slice(1);
+}
+function matches_hook(hook, tool_name) {
+	if (!hook.matcher) return true;
+	const claude_tool_name = to_claude_tool_name(tool_name);
+	hook.matcher.lastIndex = 0;
+	if (hook.matcher.test(tool_name)) return true;
+	hook.matcher.lastIndex = 0;
+	return hook.matcher.test(claude_tool_name);
+}
+function extract_text_content(content) {
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const item_record = item;
+		if (item_record.type === "text" && typeof item_record.text === "string") parts.push(item_record.text);
+	}
+	return parts.join("\n");
+}
+function normalize_tool_input(input) {
+	const normalized = { ...input };
+	const path_value = typeof input.path === "string" ? input.path : void 0;
+	if (path_value !== void 0) {
+		normalized.file_path = path_value;
+		normalized.filePath = path_value;
+	}
+	return normalized;
+}
+function build_tool_response(event, normalized_input) {
+	const response = {
+		is_error: event.isError,
+		isError: event.isError,
+		content: event.content,
+		text: extract_text_content(event.content),
+		details: event.details ?? null
+	};
+	const file_path = typeof normalized_input.file_path === "string" ? normalized_input.file_path : void 0;
+	if (file_path !== void 0) {
+		response.file_path = file_path;
+		response.filePath = file_path;
+	}
+	return response;
+}
+function build_hook_payload(event, event_name, ctx, project_dir) {
+	const normalized_input = normalize_tool_input(event.input);
+	return {
+		session_id: ctx.sessionManager.getSessionFile() ?? "ephemeral",
+		cwd: ctx.cwd,
+		claude_project_dir: project_dir,
+		hook_event_name: event_name,
+		tool_name: to_claude_tool_name(event.toolName),
+		tool_call_id: event.toolCallId,
+		tool_input: normalized_input,
+		tool_response: build_tool_response(event, normalized_input)
+	};
+}
+async function run_command_hook(command, cwd, payload) {
+	return await new Promise((resolve) => {
+		const started_at = Date.now();
+		const child = spawn("bash", ["-lc", command], {
+			cwd,
+			env: {
+				...process.env,
+				CLAUDE_PROJECT_DIR: cwd
+			},
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		let timed_out = false;
+		let resolved = false;
+		const finish = (code) => {
+			if (resolved) return;
+			resolved = true;
+			resolve({
+				code,
+				stdout,
+				stderr,
+				elapsed_ms: Date.now() - started_at,
+				timed_out
+			});
+		};
+		const timeout = setTimeout(() => {
+			timed_out = true;
+			child.kill("SIGTERM");
+			setTimeout(() => {
+				child.kill("SIGKILL");
+			}, 1e3).unref?.();
+		}, HOOK_TIMEOUT_MS);
+		timeout.unref?.();
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString("utf8");
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString("utf8");
+		});
+		child.on("error", (error) => {
+			clearTimeout(timeout);
+			stderr += `${error.message}\n`;
+			finish(-1);
+		});
+		child.on("close", (code) => {
+			clearTimeout(timeout);
+			finish(code ?? -1);
+		});
+		try {
+			child.stdin.write(JSON.stringify(payload));
+			child.stdin.end();
+		} catch (error) {
+			stderr += `${error instanceof Error ? error.message : String(error)}\n`;
+		}
+	});
+}
+function hook_event_name_for_result(event) {
+	return event.isError ? "PostToolUseFailure" : "PostToolUse";
+}
+function format_duration$1(elapsed_ms) {
+	if (elapsed_ms < 1e3) return `${elapsed_ms}ms`;
+	return `${(elapsed_ms / 1e3).toFixed(1)}s`;
+}
+function hook_name(command) {
+	const sh_path_match = command.match(/[^\s|;&]+\.sh\b/);
+	if (sh_path_match) return basename(sh_path_match[0]);
+	return basename(command.trim().split(/\s+/)[0] ?? "hook");
+}
+function create_hooks_resolution_extension(options = {}) {
+	const load_hooks_impl = options.load_hooks ?? load_hooks;
+	const run_command_hook_impl = options.run_command_hook ?? run_command_hook;
+	return async function hooks_resolution(pi) {
+		let state = {
+			project_dir: process.cwd(),
+			hooks: []
+		};
+		const refresh_hooks = (cwd) => {
+			state = load_hooks_impl(cwd);
+		};
+		pi.on("session_start", (_event, ctx) => {
+			refresh_hooks(ctx.cwd);
+		});
+		pi.on("tool_result", async (event, ctx) => {
+			if (state.hooks.length === 0) return;
+			const event_name = hook_event_name_for_result(event);
+			const matching_hooks = state.hooks.filter((hook) => hook.event_name === event_name && matches_hook(hook, event.toolName));
+			if (matching_hooks.length === 0) return;
+			const payload = build_hook_payload(event, event_name, ctx, state.project_dir);
+			const executed_commands = /* @__PURE__ */ new Set();
+			for (const hook of matching_hooks) {
+				if (executed_commands.has(hook.command)) continue;
+				executed_commands.add(hook.command);
+				const result = await run_command_hook_impl(hook.command, state.project_dir, payload);
+				const name = hook_name(hook.command);
+				const duration = format_duration$1(result.elapsed_ms);
+				if (ctx.hasUI) if (result.code === 0) ctx.ui.notify(`Hook \`${name}\` ran (${duration})`, "info");
+				else {
+					const error_line = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+					ctx.ui.notify(`Hook \`${name}\` failed (${duration}): ${error_line}`, "warning");
+				}
+			}
+		});
+	};
+}
+var hooks_resolution_default = create_hooks_resolution_extension();
+//#endregion
 //#region src/lsp/client.ts
 var LspClientStartError = class extends Error {
 	command;
@@ -4658,7 +5009,9 @@ const BUILTIN_EXTENSION_FACTORIES = {
 	recall,
 	"prompt-presets": prompt_presets,
 	lsp: lsp_default,
-	"session-name": session_name
+	"session-name": session_name,
+	"confirm-destructive": confirm_destructive,
+	"hooks-resolution": hooks_resolution_default
 };
 const PACKAGE_THEME_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "themes");
 const PI_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
@@ -4676,6 +5029,8 @@ function get_force_disabled_builtins(options) {
 	if (!options.prompt_presets) force_disabled.add("prompt-presets");
 	if (!options.lsp) force_disabled.add("lsp");
 	if (!options.session_name) force_disabled.add("session-name");
+	if (!options.confirm_destructive) force_disabled.add("confirm-destructive");
+	if (!options.hooks_resolution) force_disabled.add("hooks-resolution");
 	return force_disabled;
 }
 function create_builtin_extension_factory(key, extension, force_disabled) {
@@ -4697,7 +5052,7 @@ function create_extensions_override(managed_inline_paths) {
 	};
 }
 async function create_my_pi(options = {}) {
-	const { cwd = process.cwd(), agent_dir, extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, prompt_presets = true, lsp = true, session_name = true, telemetry, telemetry_db_path, model, system_prompt, append_system_prompt } = options;
+	const { cwd = process.cwd(), agent_dir, extensions = [], extensionFactories: user_factories = [], mcp = true, skills = true, chain = true, filter_output = true, handoff = true, recall = true, prompt_presets = true, lsp = true, session_name = true, confirm_destructive = true, hooks_resolution = true, telemetry, telemetry_db_path, model, system_prompt, append_system_prompt } = options;
 	const effective_agent_dir = resolve_agent_dir(cwd, agent_dir);
 	if (agent_dir) process.env[PI_AGENT_DIR_ENV] = effective_agent_dir;
 	const resolved_extensions = extensions.map((p) => resolve(cwd, p));
@@ -4710,7 +5065,9 @@ async function create_my_pi(options = {}) {
 		recall,
 		prompt_presets,
 		lsp,
-		session_name
+		session_name,
+		confirm_destructive,
+		hooks_resolution
 	});
 	const managed_extension_factories = [
 		create_telemetry_extension({
@@ -4768,4 +5125,4 @@ async function create_my_pi(options = {}) {
 //#endregion
 export { create_my_pi as n, runPrintMode$1 as r, InteractiveMode$1 as t };
 
-//# sourceMappingURL=api-1ZXLxSgP.js.map
+//# sourceMappingURL=api-Dxi4curf.js.map