my-pi 0.0.13 → 0.1.1

package/dist/{api-CWEizv2k.js → api-Dxi4curf.js}

@@ -1,4 +1,4 @@
-import { InteractiveMode as InteractiveMode$1, SessionManager, SettingsManager, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, defineTool, getAgentDir, parseFrontmatter, runPrintMode as runPrintMode$1 } from "@mariozechner/pi-coding-agent";
+import { BorderedLoader, InteractiveMode as InteractiveMode$1, SessionManager, SettingsManager, convertToLlm, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, defineTool, getAgentDir, parseFrontmatter, runPrintMode as runPrintMode$1, serializeConversation } from "@mariozechner/pi-coding-agent";
 import { cpSync, existsSync, globSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -6,6 +6,7 @@ import { Type } from "@sinclair/typebox";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { Container, SettingsList, Text, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { complete } from "@mariozechner/pi-ai";
 import { readFile } from "node:fs/promises";
 import { EventEmitter } from "node:events";
 import { createHash, randomUUID } from "node:crypto";
@@ -380,7 +381,7 @@ const BUILTIN_EXTENSIONS = [
 	{
 		key: "handoff",
 		label: "Handoff",
-		description: "Session handoff export and /handoff command",
+		description: "AI-generated session handoff with editor review and new-session prefill",
 		cli_flag: "--no-handoff",
 		aliases: ["handoff"]
 	},
@@ -408,6 +409,31 @@ const BUILTIN_EXTENSIONS = [
 		description: "Language Server Protocol tools (diagnostics, hover, definition, references)",
 		cli_flag: "--no-lsp",
 		aliases: ["lsp", "language-server"]
+	},
+	{
+		key: "session-name",
+		label: "Session name",
+		description: "AI-powered session auto-naming and /session-name command",
+		cli_flag: "--no-session-name",
+		aliases: [
+			"session-name",
+			"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() {
@@ -471,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 = "[ ]";
@@ -534,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",
@@ -565,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(" ");
@@ -636,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;
 						}
@@ -789,52 +846,407 @@ async function filter_output(pi) {
 }
 //#endregion
 //#region src/extensions/handoff.ts
+const SYSTEM_PROMPT$1 = `You are a context transfer assistant. Given a conversation history and the user's goal for a new thread, generate a focused prompt that:
+
+1. Summarizes relevant context from the conversation (decisions made, approaches taken, key findings)
+2. Lists any relevant files that were discussed or modified
+3. Clearly states the next task based on the user's goal
+4. Is self-contained - the new thread should be able to proceed without the old conversation
+
+Format your response as a prompt the user can send to start the new thread. Be concise but include all necessary context. Do not include any preamble like "Here's the prompt" - just output the prompt itself.
+
+Example output format:
+## Context
+We've been working on X. Key decisions:
+- Decision 1
+- Decision 2
+
+Files involved:
+- path/to/file1.ts
+- path/to/file2.ts
+
+## Task
+[Clear description of what to do next based on user's goal]`;
 async function handoff(pi) {
-	const history = [];
-	pi.on("message_end", async (event) => {
-		const msg = event.message;
-		if (!msg) return;
-		const content = msg.content;
-		if (!Array.isArray(content)) return;
-		const text = content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
-		if (!text) return;
-		const summary = text.length > 200 ? text.slice(0, 200) + "..." : text;
-		history.push({
-			role: msg.role || "unknown",
-			summary,
-			timestamp: Date.now()
-		});
-	});
 	pi.registerCommand("handoff", {
-		description: "Export session context as a handoff prompt for a new session",
+		description: "Transfer context to a new focused session with an AI-generated prompt",
 		handler: async (args, ctx) => {
-			const task = args.trim();
-			if (history.length === 0) {
-				ctx.ui.notify("No conversation history to hand off", "warning");
+			if (!ctx.hasUI) {
+				ctx.ui.notify("handoff requires interactive mode", "error");
 				return;
 			}
-			const handoff = `## Handoff from Previous Session
-
-### Context
-The previous session covered the following:
-
-${history.map((h) => `[${h.role}] ${h.summary}`).join("\n\n")}
-
-### Task
-${task || "Continue from where the previous session left off."}
-
-### Instructions
-- Review the context above to understand what was done
-- Do NOT repeat work that was already completed
-- Focus on the task described above
-`;
-			const filename = `handoff-${Date.now()}.md`;
-			writeFileSync(join(ctx.cwd, filename), handoff, "utf-8");
-			ctx.ui.notify(`Handoff written to ${filename}\n\nUse: my-pi < ${filename}`);
+			if (!ctx.model) {
+				ctx.ui.notify("No model selected", "error");
+				return;
+			}
+			const goal = args.trim();
+			if (!goal) {
+				ctx.ui.notify("Usage: /handoff <goal for new thread>", "error");
+				return;
+			}
+			const messages = ctx.sessionManager.getBranch().filter((entry) => entry.type === "message").map((entry) => entry.message);
+			if (messages.length === 0) {
+				ctx.ui.notify("No conversation to hand off", "error");
+				return;
+			}
+			const conversation_text = serializeConversation(convertToLlm(messages));
+			const current_session_file = ctx.sessionManager.getSessionFile();
+			const model = ctx.model;
+			const result = await ctx.ui.custom((tui, theme, _kb, done) => {
+				const loader = new BorderedLoader(tui, theme, "Generating handoff prompt...");
+				loader.onAbort = () => done(null);
+				const generate = async () => {
+					const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+					if (!auth.ok || !auth.apiKey) throw new Error(auth.ok ? `No API key for ${model.provider}` : auth.error);
+					const response = await complete(model, {
+						systemPrompt: SYSTEM_PROMPT$1,
+						messages: [{
+							role: "user",
+							content: [{
+								type: "text",
+								text: `## Conversation History\n\n${conversation_text}\n\n## User's Goal for New Thread\n\n${goal}`
+							}],
+							timestamp: Date.now()
+						}]
+					}, {
+						apiKey: auth.apiKey,
+						headers: auth.headers,
+						signal: loader.signal
+					});
+					if (response.stopReason === "aborted") return null;
+					return response.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+				};
+				generate().then(done).catch((err) => {
+					console.error("Handoff generation failed:", err);
+					done(null);
+				});
+				return loader;
+			});
+			if (result === null) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+			const edited_prompt = await ctx.ui.editor("Edit handoff prompt", result);
+			if (edited_prompt === void 0) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+			if ((await ctx.newSession({ parentSession: current_session_file })).cancelled) {
+				ctx.ui.notify("New session cancelled", "info");
+				return;
+			}
+			ctx.ui.setEditorText(edited_prompt);
+			ctx.ui.notify("Handoff ready. Submit when ready.", "info");
 		}
 	});
 }
 //#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;
@@ -3132,6 +3544,122 @@ Always pass \`--json\` for structured output.` };
 	});
 }
 //#endregion
+//#region src/extensions/session-name.ts
+const SYSTEM_PROMPT = `You are a session naming assistant. Given a conversation history, generate a short, descriptive session name (2-5 words) that captures the main topic or task.
+
+Guidelines:
+- Be concise but specific
+- Use kebab-case or natural language
+- Focus on the core task/question
+- Avoid generic names like "discussion" or "conversation"
+- No quotes, no punctuation at the end
+
+Examples:
+- "fix auth bug" -> "fix-auth-bug" or "authentication fix"
+- "how do I deploy to vercel" -> "vercel deployment"
+- "explain react hooks" -> "react hooks explanation"
+- "optimize database queries" -> "db query optimization"
+
+Output ONLY the session name, nothing else.`;
+const AUTO_NAME_THRESHOLD = 1;
+const MAX_CHARS = 4e3;
+const MAX_NAME_LEN = 50;
+function clean_name(value) {
+	return value.replace(/^["']|["']$/g, "").replace(/\n/g, " ").replace(/\s+/g, " ").trim().slice(0, MAX_NAME_LEN);
+}
+function truncate_conversation(value) {
+	return value.length > MAX_CHARS ? value.slice(0, MAX_CHARS) + "\n..." : value;
+}
+async function generate_session_name(ctx, model, conversation_text, signal) {
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+	if (!auth.ok || !auth.apiKey) throw new Error(auth.ok ? `No API key for ${model.provider}` : auth.error);
+	const response = await complete(model, {
+		systemPrompt: SYSTEM_PROMPT,
+		messages: [{
+			role: "user",
+			content: [{
+				type: "text",
+				text: `## Conversation History\n\n${truncate_conversation(conversation_text)}\n\nGenerate a concise session name for this conversation.`
+			}],
+			timestamp: Date.now()
+		}]
+	}, {
+		apiKey: auth.apiKey,
+		headers: auth.headers,
+		signal
+	});
+	if (response.stopReason === "aborted") return null;
+	return clean_name(response.content.filter((c) => c.type === "text").map((c) => c.text.trim()).join(" "));
+}
+async function session_name(pi) {
+	let auto_named_attempted = false;
+	pi.on("agent_end", async (_event, ctx) => {
+		if (!ctx.hasUI || !ctx.model) return;
+		if (pi.getSessionName() || auto_named_attempted) return;
+		const branch = ctx.sessionManager.getBranch();
+		if (branch.filter((entry) => entry.type === "message" && entry.message.role === "user").length < AUTO_NAME_THRESHOLD) return;
+		auto_named_attempted = true;
+		const messages = branch.filter((entry) => entry.type === "message").map((entry) => entry.message);
+		if (messages.length === 0) return;
+		const conversation_text = serializeConversation(convertToLlm(messages));
+		generate_session_name(ctx, ctx.model, conversation_text).then((name) => {
+			if (!name) return;
+			pi.setSessionName(name);
+			ctx.ui.notify(`Auto-named: ${name}`, "info");
+		}).catch((err) => {
+			console.error("Auto-naming failed:", err);
+		});
+	});
+	pi.on("session_start", async () => {
+		auto_named_attempted = false;
+	});
+	pi.registerCommand("session-name", {
+		description: "Set, show, or auto-generate the current session name",
+		handler: async (args, ctx) => {
+			const trimmed = args.trim();
+			if (!trimmed) {
+				const current = pi.getSessionName();
+				ctx.ui.notify(current ? `Session: ${current}` : "No session name set", "info");
+				return;
+			}
+			if (trimmed === "--auto" || trimmed === "-a") {
+				if (!ctx.hasUI || !ctx.model) {
+					ctx.ui.notify("Auto-naming requires interactive mode and a selected model", "error");
+					return;
+				}
+				const messages = ctx.sessionManager.getBranch().filter((entry) => entry.type === "message").map((entry) => entry.message);
+				if (messages.length === 0) {
+					ctx.ui.notify("No conversation to analyze", "error");
+					return;
+				}
+				const conversation_text = serializeConversation(convertToLlm(messages));
+				const result = await ctx.ui.custom((tui, theme, _kb, done) => {
+					const loader = new BorderedLoader(tui, theme, "Generating session name...");
+					loader.onAbort = () => done(null);
+					generate_session_name(ctx, ctx.model, conversation_text, loader.signal).then(done).catch((err) => {
+						console.error("Auto-naming failed:", err);
+						done(null);
+					});
+					return loader;
+				});
+				if (result === null) {
+					ctx.ui.notify("Auto-naming cancelled", "info");
+					return;
+				}
+				if (!result) {
+					ctx.ui.notify("Failed to generate name", "error");
+					return;
+				}
+				pi.setSessionName(result);
+				ctx.ui.notify(`Session named: ${result}`, "info");
+				return;
+			}
+			pi.setSessionName(clean_name(trimmed));
+			ctx.ui.notify(`Session named: ${clean_name(trimmed)}`, "info");
+		}
+	});
+}
+//#endregion
 //#region src/skills/config.ts
 const DEFAULT_CONFIG$1 = {
 	version: 1,
@@ -4480,7 +5008,10 @@ const BUILTIN_EXTENSION_FACTORIES = {
 	handoff,
 	recall,
 	"prompt-presets": prompt_presets,
-	lsp: lsp_default
+	lsp: lsp_default,
+	"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";
@@ -4497,6 +5028,9 @@ function get_force_disabled_builtins(options) {
 	if (!options.recall) force_disabled.add("recall");
 	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) {
@@ -4518,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, 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));
@@ -4530,7 +5064,10 @@ async function create_my_pi(options = {}) {
 		handoff,
 		recall,
 		prompt_presets,
-		lsp
+		lsp,
+		session_name,
+		confirm_destructive,
+		hooks_resolution
 	});
 	const managed_extension_factories = [
 		create_telemetry_extension({
@@ -4588,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-CWEizv2k.js.map
+//# sourceMappingURL=api-Dxi4curf.js.map