my-pi 0.1.1 → 0.1.3

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

@@ -60,6 +60,10 @@ function parse_chain_yaml(raw) {
 	if (current && current_step) current.steps.push(current_step);
 	return chains;
 }
+function should_inject_chain_prompt(event) {
+	const selected_tools = event.systemPromptOptions?.selectedTools;
+	return !selected_tools || selected_tools.includes("run_chain");
+}
 function parse_agent_file(filePath) {
 	try {
 		const { frontmatter, body } = parseFrontmatter(readFileSync(filePath, "utf-8"));
@@ -290,6 +294,7 @@ async function chain(pi) {
 	});
 	pi.on("before_agent_start", async (event) => {
 		if (!active_chain || chains.length === 0) return {};
+		if (!should_inject_chain_prompt(event)) return {};
 		const flow = active_chain.steps.map((s) => s.agent).join(" -> ");
 		const step_list = active_chain.steps.map((s, i) => {
 			const desc = agents.get(s.agent.toLowerCase())?.description || "unknown";
@@ -340,7 +345,7 @@ Switch chains with /chain <name>.` };
 }
 //#endregion
 //#region src/extensions/config.ts
-const DEFAULT_CONFIG$2 = {
+const DEFAULT_CONFIG$3 = {
 	version: 1,
 	enabled: {}
 };
@@ -434,6 +439,17 @@ const BUILTIN_EXTENSIONS = [
 		description: "Claude Code style PostToolUse hook compatibility from .claude, .rulesync, and .pi configs",
 		cli_flag: "--no-hooks",
 		aliases: ["hooks-resolution", "hooks"]
+	},
+	{
+		key: "working-indicator",
+		label: "Working indicator",
+		description: "Customizable streaming working indicator with /working-indicator command",
+		cli_flag: "--no-working-indicator",
+		aliases: [
+			"working-indicator",
+			"indicator",
+			"spinner"
+		]
 	}
 ];
 function get_builtin_extensions_config_path() {
@@ -441,7 +457,7 @@ function get_builtin_extensions_config_path() {
 }
 function load_builtin_extensions_config() {
 	const path = get_builtin_extensions_config_path();
-	if (!existsSync(path)) return { ...DEFAULT_CONFIG$2 };
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG$3 };
 	try {
 		const raw = readFileSync(path, "utf-8");
 		const parsed = JSON.parse(raw);
@@ -455,7 +471,7 @@ function load_builtin_extensions_config() {
 			enabled
 		};
 	} catch {
-		return { ...DEFAULT_CONFIG$2 };
+		return { ...DEFAULT_CONFIG$3 };
 	}
 }
 function save_builtin_extensions_config(config) {
@@ -2515,6 +2531,14 @@ function load_mcp_config(cwd) {
 }
 //#endregion
 //#region src/extensions/mcp.ts
+function create_server_states(configs) {
+	return new Map(configs.map((config) => [config.name, {
+		config,
+		tool_names: [],
+		enabled: true,
+		status: "disconnected"
+	}]));
+}
 function remove_server_tools_from_active(pi, tool_names) {
 	const tool_set = new Set(tool_names);
 	pi.setActiveTools(pi.getActiveTools().filter((tool) => !tool_set.has(tool)));
@@ -2527,16 +2551,56 @@ function format_server_status(state) {
 		default: return state.enabled ? "not connected yet" : "disabled";
 	}
 }
+function count_pending_enabled_servers(servers) {
+	return Array.from(servers.values()).filter((state) => state.enabled && state.status !== "connected").length;
+}
+function update_mcp_status(ctx, servers) {
+	if (servers.size === 0) {
+		ctx.ui.setStatus("mcp", void 0);
+		return;
+	}
+	const states = Array.from(servers.values());
+	const enabled = states.filter((state) => state.enabled).length;
+	const connected = states.filter((state) => state.enabled && state.status === "connected").length;
+	const connecting = states.filter((state) => state.enabled && state.status === "connecting").length;
+	const failed = states.filter((state) => state.enabled && state.status === "failed").length;
+	const fragments = [`MCP ${connected}/${enabled} connected`];
+	if (connecting > 0) fragments.push(`${connecting} connecting`);
+	if (failed > 0) fragments.push(`${failed} failed`);
+	ctx.ui.setStatus("mcp", ctx.ui.theme.fg("dim", fragments.join(" · ")));
+}
+function set_connect_feedback(ctx, pending_server_count) {
+	const label = pending_server_count === 1 ? "Connecting 1 MCP server..." : `Connecting ${pending_server_count} MCP servers...`;
+	ctx.ui.setWorkingMessage(label);
+	ctx.ui.setWorkingIndicator({
+		frames: [
+			ctx.ui.theme.fg("dim", "·"),
+			ctx.ui.theme.fg("muted", "•"),
+			ctx.ui.theme.fg("accent", "●"),
+			ctx.ui.theme.fg("muted", "•")
+		],
+		intervalMs: 120
+	});
+	ctx.ui.setStatus("mcp", ctx.ui.theme.fg("dim", label));
+	return () => {
+		ctx.ui.setWorkingMessage();
+		ctx.ui.setWorkingIndicator();
+	};
+}
+function should_wait_for_mcp_connections(event) {
+	const selected_tools = event.systemPromptOptions?.selectedTools;
+	return !selected_tools || selected_tools.some((tool) => tool.startsWith("mcp__"));
+}
 async function mcp(pi) {
-	const configs = load_mcp_config(process.cwd());
-	const servers = new Map(configs.map((config) => [config.name, {
-		config,
-		tool_names: [],
-		enabled: true,
-		status: "disconnected"
-	}]));
+	let initialized_cwd = null;
+	let servers = /* @__PURE__ */ new Map();
 	const registered_tool_names = /* @__PURE__ */ new Set();
-	const connect_server = async (state) => {
+	const ensure_servers = (cwd) => {
+		if (initialized_cwd !== null) return;
+		servers = create_server_states(load_mcp_config(cwd));
+		initialized_cwd = cwd;
+	};
+	const connect_server = async (state, ctx) => {
 		if (state.status === "connected") return;
 		if (state.connect_promise) {
 			await state.connect_promise;
@@ -2545,6 +2609,7 @@ async function mcp(pi) {
 		state.connect_promise = (async () => {
 			state.status = "connecting";
 			state.error = void 0;
+			if (ctx) update_mcp_status(ctx, servers);
 			const client = new McpClient(state.config);
 			try {
 				await client.connect();
@@ -2588,19 +2653,39 @@ async function mcp(pi) {
 				throw error;
 			} finally {
 				state.connect_promise = void 0;
+				if (ctx) update_mcp_status(ctx, servers);
 			}
 		})();
 		await state.connect_promise;
 	};
 	const connect_all_servers = async (options = {}) => {
-		await Promise.allSettled(Array.from(servers.values()).filter((state) => state.enabled).filter((state) => options.include_failed || state.status !== "failed").map((state) => connect_server(state)));
+		await Promise.allSettled(Array.from(servers.values()).filter((state) => state.enabled).filter((state) => options.include_failed || state.status !== "failed").map((state) => connect_server(state, options.ctx)));
+		if (options.ctx) update_mcp_status(options.ctx, servers);
 	};
-	pi.on("session_start", async () => {
-		connect_all_servers();
+	pi.on("session_start", async (_event, ctx) => {
+		ensure_servers(ctx.cwd);
+		update_mcp_status(ctx, servers);
+		connect_all_servers({ ctx });
 	});
-	pi.on("before_agent_start", async (event) => {
-		await connect_all_servers();
-		return event;
+	pi.on("before_agent_start", async (event, ctx) => {
+		ensure_servers(ctx.cwd);
+		if (!should_wait_for_mcp_connections(event)) {
+			connect_all_servers({ ctx });
+			return event;
+		}
+		const pending_server_count = count_pending_enabled_servers(servers);
+		if (pending_server_count === 0) {
+			update_mcp_status(ctx, servers);
+			return event;
+		}
+		const restore_feedback = set_connect_feedback(ctx, pending_server_count);
+		try {
+			await connect_all_servers({ ctx });
+			return event;
+		} finally {
+			restore_feedback();
+			update_mcp_status(ctx, servers);
+		}
 	});
 	pi.registerCommand("mcp", {
 		description: "Manage MCP servers (list, enable, disable)",
@@ -2624,6 +2709,7 @@ async function mcp(pi) {
 			return null;
 		},
 		handler: async (args, ctx) => {
+			ensure_servers(ctx.cwd);
 			const [sub, ...rest] = args.trim().split(/\s+/);
 			const name = rest.join(" ");
 			switch (sub || "list") {
@@ -2634,6 +2720,7 @@ async function mcp(pi) {
 					}
 					const lines = [];
 					for (const [sname, state] of servers.entries()) lines.push(`${sname} (${format_server_status(state)}) — ${state.tool_names.length} tools${state.error ? ` — ${state.error}` : ""}`);
+					update_mcp_status(ctx, servers);
 					ctx.ui.notify(lines.join("\n"));
 					break;
 				}
@@ -2650,7 +2737,8 @@ async function mcp(pi) {
 					server.enabled = true;
 					if (server.status === "connected") {
 						const active = pi.getActiveTools();
-						pi.setActiveTools([...active, ...server.tool_names]);
+						pi.setActiveTools([...new Set([...active, ...server.tool_names])]);
+						update_mcp_status(ctx, servers);
 						ctx.ui.notify(`Enabled ${name}`);
 						return;
 					}
@@ -2658,7 +2746,8 @@ async function mcp(pi) {
 						server.status = "disconnected";
 						server.error = void 0;
 					}
-					connect_server(server);
+					update_mcp_status(ctx, servers);
+					connect_server(server, ctx);
 					ctx.ui.notify(`Enabling ${name} and connecting in background`);
 					break;
 				}
@@ -2674,6 +2763,7 @@ async function mcp(pi) {
 					}
 					server.enabled = false;
 					remove_server_tools_from_active(pi, server.tool_names);
+					update_mcp_status(ctx, servers);
 					ctx.ui.notify(`Disabled ${name}`);
 					break;
 				}
@@ -2681,13 +2771,14 @@ async function mcp(pi) {
 			}
 		}
 	});
-	pi.on("session_shutdown", async () => {
+	pi.on("session_shutdown", async (_event, ctx) => {
 		await Promise.allSettled(Array.from(servers.values()).map(async (server) => {
 			await server.connect_promise?.catch(() => {});
 			await server.client?.disconnect();
 			server.client = void 0;
 			if (server.status !== "failed") server.status = "disconnected";
 		}));
+		ctx.ui.setStatus("mcp", void 0);
 	});
 }
 //#endregion
@@ -2959,6 +3050,24 @@ function format_token_count(count) {
 	if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
 	return `${Math.round(count / 1e6)}M`;
 }
+function render_footer_status_line(theme, width, left_items, right_item) {
+	const left = sanitize_status_text(left_items.join(" "));
+	const right = right_item ? sanitize_status_text(right_item) : "";
+	if (!left && !right) return void 0;
+	if (!right) return truncateToWidth(theme.fg("dim", left), width, theme.fg("dim", "..."));
+	if (!left) {
+		const themed_right = theme.fg("dim", right);
+		const right_width = visibleWidth(themed_right);
+		return right_width >= width ? truncateToWidth(themed_right, width, theme.fg("dim", "...")) : `${" ".repeat(width - right_width)}${themed_right}`;
+	}
+	const right_width = visibleWidth(right);
+	if (right_width >= width) return truncateToWidth(theme.fg("dim", right), width, theme.fg("dim", "..."));
+	const min_gap = 1;
+	const truncated_left = truncateToWidth(left, Math.max(0, width - right_width - min_gap), "...");
+	const left_width = visibleWidth(truncated_left);
+	const gap = Math.max(min_gap, width - left_width - right_width);
+	return theme.fg("dim", truncated_left) + " ".repeat(gap) + theme.fg("dim", right);
+}
 function get_current_thinking_level(ctx) {
 	const entries = ctx.sessionManager.getEntries();
 	for (let i = entries.length - 1; i >= 0; i--) {
@@ -3038,14 +3147,8 @@ function render_footer_lines(ctx, theme, footer_data, width, active_base_name, a
 	const dim_remainder = theme.fg("dim", remainder);
 	const lines = [truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "...")), dim_stats_left + dim_remainder];
 	const prompt_status = get_footer_prompt_status(active_base_name, active_layers);
-	if (prompt_status) {
-		const themed_status = theme.fg("dim", prompt_status);
-		const status_width = visibleWidth(themed_status);
-		const aligned_status = status_width >= width ? truncateToWidth(themed_status, width, theme.fg("dim", "...")) : `${" ".repeat(width - status_width)}${themed_status}`;
-		lines.push(aligned_status);
-	}
-	const other_statuses = Array.from(footer_data.getExtensionStatuses().entries()).filter(([key]) => key !== "preset").sort(([a], [b]) => a.localeCompare(b)).map(([, text]) => sanitize_status_text(text));
-	if (other_statuses.length > 0) lines.push(truncateToWidth(other_statuses.join(" "), width, theme.fg("dim", "...")));
+	const combined_status_line = render_footer_status_line(theme, width, Array.from(footer_data.getExtensionStatuses().entries()).filter(([key]) => key !== "preset").sort(([a], [b]) => a.localeCompare(b)).map(([, text]) => sanitize_status_text(text)), prompt_status);
+	if (combined_status_line) lines.push(combined_status_line);
 	return lines;
 }
 function set_status(ctx, active_base_name, active_layers) {
@@ -3508,6 +3611,10 @@ async function prompt_presets(pi) {
 //#endregion
 //#region src/extensions/recall.ts
 const DEFAULT_DB_PATH = join(process.env.HOME, ".pi", "pirecall.db");
+function should_inject_recall_prompt(event) {
+	const selected_tools = event.systemPromptOptions?.selectedTools;
+	return !selected_tools || selected_tools.includes("bash");
+}
 function sync_recall_db_in_background() {
 	if (!existsSync(DEFAULT_DB_PATH)) return;
 	try {
@@ -3523,6 +3630,7 @@ async function recall(pi) {
 		sync_recall_db_in_background();
 	});
 	pi.on("before_agent_start", async (event) => {
+		if (!should_inject_recall_prompt(event)) return {};
 		return { systemPrompt: event.systemPrompt + `
 
 ## Session Recall
@@ -3661,7 +3769,7 @@ async function session_name(pi) {
 }
 //#endregion
 //#region src/skills/config.ts
-const DEFAULT_CONFIG$1 = {
+const DEFAULT_CONFIG$2 = {
 	version: 1,
 	enabled: {},
 	defaults: "all-disabled"
@@ -3671,7 +3779,7 @@ function get_config_path() {
 }
 function load_skills_config() {
 	const path = get_config_path();
-	if (!existsSync(path)) return { ...DEFAULT_CONFIG$1 };
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG$2 };
 	try {
 		const raw = readFileSync(path, "utf-8");
 		const parsed = JSON.parse(raw);
@@ -3681,7 +3789,7 @@ function load_skills_config() {
 			defaults: parsed.defaults ?? "all-enabled"
 		};
 	} catch {
-		return { ...DEFAULT_CONFIG$1 };
+		return { ...DEFAULT_CONFIG$2 };
 	}
 }
 function save_skills_config(config) {
@@ -4408,7 +4516,7 @@ async function skills(pi) {
 }
 //#endregion
 //#region src/extensions/telemetry-config.ts
-const DEFAULT_CONFIG = {
+const DEFAULT_CONFIG$1 = {
 	version: 1,
 	enabled: false
 };
@@ -4424,15 +4532,15 @@ function resolve_telemetry_db_path(cwd, override_path) {
 }
 function load_telemetry_config() {
 	const path = get_telemetry_config_path();
-	if (!existsSync(path)) return { ...DEFAULT_CONFIG };
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG$1 };
 	try {
 		const parsed = JSON.parse(readFileSync(path, "utf-8"));
 		return {
-			version: typeof parsed.version === "number" ? parsed.version : DEFAULT_CONFIG.version,
-			enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : DEFAULT_CONFIG.enabled
+			version: typeof parsed.version === "number" ? parsed.version : DEFAULT_CONFIG$1.version,
+			enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : DEFAULT_CONFIG$1.enabled
 		};
 	} catch {
-		return { ...DEFAULT_CONFIG };
+		return { ...DEFAULT_CONFIG$1 };
 	}
 }
 function save_telemetry_config(config) {
@@ -4591,6 +4699,10 @@ function infer_run_outcome(event) {
 		error_message: null
 	};
 }
+function describe_session_shutdown(event) {
+	const base = `session shutdown (${event.reason})`;
+	return event.targetSessionFile ? `${base} → ${event.targetSessionFile}` : base;
+}
 function format_telemetry_status(options) {
 	const override_label = options.override === void 0 ? "none" : options.override ? "--telemetry" : "--no-telemetry";
 	return [
@@ -4983,12 +5095,12 @@ function create_telemetry_extension(options = {}) {
 				headers_json: summarize_headers(event.headers)
 			});
 		});
-		pi.on("session_shutdown", async () => {
+		pi.on("session_shutdown", async (event) => {
 			if (store && active_run) store.finish_run({
 				id: active_run.id,
 				ended_at: now(),
 				success: null,
-				error_message: "session shutdown"
+				error_message: describe_session_shutdown(event)
 			});
 			close_store();
 			active_run = null;
@@ -4999,6 +5111,108 @@ function create_telemetry_extension(options = {}) {
 }
 create_telemetry_extension();
 //#endregion
+//#region src/extensions/working-indicator-config.ts
+const DEFAULT_CONFIG = {
+	version: 1,
+	mode: "default"
+};
+function get_working_indicator_config_path() {
+	return join(getAgentDir(), "working-indicator.json");
+}
+function load_working_indicator_config() {
+	const path = get_working_indicator_config_path();
+	if (!existsSync(path)) return { ...DEFAULT_CONFIG };
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		return {
+			version: typeof parsed.version === "number" ? parsed.version : DEFAULT_CONFIG.version,
+			mode: is_working_indicator_mode(parsed.mode) ? parsed.mode : DEFAULT_CONFIG.mode
+		};
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}
+function save_working_indicator_config(config) {
+	const path = get_working_indicator_config_path();
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const tmp = `${path}.tmp-${Date.now()}`;
+	writeFileSync(tmp, JSON.stringify(config, null, "	") + "\n", { mode: 384 });
+	renameSync(tmp, path);
+}
+function is_working_indicator_mode(value) {
+	return value === "default" || value === "dot" || value === "none";
+}
+//#endregion
+//#region src/extensions/working-indicator.ts
+const COMMAND_MODES = [
+	"dot",
+	"none",
+	"reset"
+];
+function get_working_indicator(ctx, mode) {
+	switch (mode) {
+		case "dot": return { frames: [ctx.ui.theme.fg("accent", "●")] };
+		case "none": return { frames: [] };
+		case "default": return;
+	}
+}
+function describe_working_indicator_mode(mode) {
+	switch (mode) {
+		case "dot": return "static dot";
+		case "none": return "hidden";
+		case "default": return "pi default spinner";
+	}
+}
+function parse_working_indicator_mode(input) {
+	const normalized = input.trim().toLowerCase();
+	if (!normalized) return null;
+	if (normalized === "reset" || normalized === "default") return "default";
+	if (normalized === "dot" || normalized === "none") return normalized;
+	return null;
+}
+function apply_working_indicator(ctx, mode) {
+	ctx.ui.setWorkingIndicator(get_working_indicator(ctx, mode));
+}
+async function working_indicator(pi) {
+	let mode = load_working_indicator_config().mode;
+	pi.on("session_start", async (_event, ctx) => {
+		mode = load_working_indicator_config().mode;
+		apply_working_indicator(ctx, mode);
+	});
+	pi.registerCommand("working-indicator", {
+		description: "Set the streaming working indicator: dot, none, or reset",
+		getArgumentCompletions: (prefix) => {
+			const value = prefix.trim().toLowerCase();
+			return COMMAND_MODES.filter((entry) => entry.startsWith(value)).map((entry) => ({
+				value: entry,
+				label: entry
+			}));
+		},
+		handler: async (args, ctx) => {
+			const next = parse_working_indicator_mode(args);
+			if (next === null) {
+				if (!args.trim()) {
+					ctx.ui.notify(`Working indicator: ${describe_working_indicator_mode(mode)}`, "info");
+					return;
+				}
+				ctx.ui.notify("Usage: /working-indicator [dot|none|reset]", "error");
+				return;
+			}
+			mode = next;
+			save_working_indicator_config({
+				version: 1,
+				mode
+			});
+			apply_working_indicator(ctx, mode);
+			ctx.ui.notify(`Working indicator set to: ${describe_working_indicator_mode(mode)}`, "info");
+		}
+	});
+}
+//#endregion
 //#region src/api.ts
 const BUILTIN_EXTENSION_FACTORIES = {
 	mcp,
@@ -5011,7 +5225,8 @@ const BUILTIN_EXTENSION_FACTORIES = {
 	lsp: lsp_default,
 	"session-name": session_name,
 	"confirm-destructive": confirm_destructive,
-	"hooks-resolution": hooks_resolution_default
+	"hooks-resolution": hooks_resolution_default,
+	"working-indicator": working_indicator
 };
 const PACKAGE_THEME_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "themes");
 const PI_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
@@ -5031,6 +5246,7 @@ function get_force_disabled_builtins(options) {
 	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");
+	if (!options.working_indicator) force_disabled.add("working-indicator");
 	return force_disabled;
 }
 function create_builtin_extension_factory(key, extension, force_disabled) {
@@ -5052,7 +5268,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, confirm_destructive = true, hooks_resolution = 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, working_indicator = 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));
@@ -5067,7 +5283,8 @@ async function create_my_pi(options = {}) {
 		lsp,
 		session_name,
 		confirm_destructive,
-		hooks_resolution
+		hooks_resolution,
+		working_indicator
 	});
 	const managed_extension_factories = [
 		create_telemetry_extension({
@@ -5125,4 +5342,4 @@ async function create_my_pi(options = {}) {
 //#endregion
 export { create_my_pi as n, runPrintMode$1 as r, InteractiveMode$1 as t };
 
-//# sourceMappingURL=api-Dxi4curf.js.map
+//# sourceMappingURL=api-q7uQTUHx.js.map