@diegopetrucci/pi-extensions 0.1.57 → 0.1.59

package/extensions/oracle/index.ts

@@ -2,8 +2,8 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { StringEnum } from "@earendil-works/pi-ai";
-import { getAgentDir, getMarkdownTheme, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { StringEnum, type Usage } from "@earendil-works/pi-ai";
+import { getAgentDir, getMarkdownTheme, type AgentToolResult, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
@@ -25,7 +25,14 @@ interface UsageStats {
 	output: number;
 	cacheRead: number;
 	cacheWrite: number;
+	cacheWrite1h?: number;
+	reasoning?: number;
+	totalTokens: number;
 	cost: number;
+	costInput: number;
+	costOutput: number;
+	costCacheRead: number;
+	costCacheWrite: number;
 	turns: number;
 	contextTokens: number;
 }
@@ -231,7 +238,7 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 		"MiniMaxAI/MiniMax-M2.5",
 		"Qwen/Qwen3-Coder-Next",
 	],
-	"kimi-coding": ["k2p7", "kimi-k2-thinking", "kimi-for-coding"],
+	"kimi-coding": ["k3", "kimi-for-coding", "kimi-for-coding-highspeed"],
 	minimax: ["MiniMax-M3", "MiniMax-M2.7-highspeed", "MiniMax-M2.7"],
 	"minimax-cn": ["MiniMax-M3", "MiniMax-M2.7-highspeed", "MiniMax-M2.7"],
 	mistral: [
@@ -359,17 +366,35 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 		"z-ai/glm-5.2",
 		"z-ai/glm-5.1",
 	],
+	"qwen-token-plan": [
+		"qwen3.8-max-preview",
+		"qwen3.7-max",
+		"qwen3.7-plus",
+		"qwen3.6-plus",
+		"deepseek-v4-pro",
+		"glm-5.2",
+		"kimi-k2.7-code",
+		"minimax-m2.5",
+	],
+	"qwen-token-plan-cn": [
+		"qwen3.8-max-preview",
+		"qwen3.7-max",
+		"qwen3.7-plus",
+		"qwen3.6-plus",
+		"deepseek-v4-pro",
+		"glm-5.2",
+		"kimi-k2.7-code",
+		"minimax-m2.5",
+	],
 	together: [
 		"deepseek-ai/DeepSeek-V4-Pro",
 		"zai-org/GLM-5.2",
-		"zai-org/GLM-5.1",
 		"moonshotai/Kimi-K2.7-Code",
 		"moonshotai/Kimi-K2.6",
 		"Qwen/Qwen3.7-Max",
 		"Qwen/Qwen3.6-Plus",
 		"MiniMaxAI/MiniMax-M3",
 		"MiniMaxAI/MiniMax-M2.7",
-		"Qwen/Qwen3.5-397B-A17B",
 		"openai/gpt-oss-120b",
 		"openai/gpt-oss-20b",
 		"nvidia/nemotron-3-ultra-550b-a55b",
@@ -417,13 +442,8 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 	],
 	xai: [
 		"grok-4.5",
-		"grok-4.20-0309-reasoning",
-		"grok-4.20-0309-non-reasoning",
 		"grok-4.3",
 		"grok-build-0.1",
-		"grok-code-fast-1",
-		"grok-3-fast",
-		"grok-3",
 	],
 	xiaomi: ["mimo-v2.5-pro", "mimo-v2.5", "mimo-v2-pro", "mimo-v2-omni", "mimo-v2-flash"],
 	"xiaomi-token-plan-ams": ["mimo-v2.5-pro", "mimo-v2.5", "mimo-v2-pro"],
@@ -434,7 +454,8 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 		"nvidia/nemotron-3-super-120b-a12b",
 		"moonshotai/kimi-k2.6",
 		"z-ai/glm-5.2",
-		"qwen/qwen3.5-122b-a10b",
+		"minimaxai/minimax-m3",
+		"mistralai/mistral-large-3-675b-instruct-2512",
 		"openai/gpt-oss-120b",
 		"nvidia/nemotron-3-nano-omni-30b-a3b-reasoning",
 		"nvidia/nemotron-3-nano-30b-a3b",
@@ -501,12 +522,91 @@ function createEmptyUsage(): UsageStats {
 		output: 0,
 		cacheRead: 0,
 		cacheWrite: 0,
+		totalTokens: 0,
 		cost: 0,
+		costInput: 0,
+		costOutput: 0,
+		costCacheRead: 0,
+		costCacheWrite: 0,
 		turns: 0,
 		contextTokens: 0,
 	};
 }
 
+function cloneUsageStats(stats: UsageStats): UsageStats {
+	return { ...stats };
+}
+
+function mergeUsageStats(target: UsageStats, source: UsageStats | undefined): UsageStats {
+	if (!source) return target;
+	target.input += source.input;
+	target.output += source.output;
+	target.cacheRead += source.cacheRead;
+	target.cacheWrite += source.cacheWrite;
+	if (source.cacheWrite1h !== undefined) {
+		target.cacheWrite1h = (target.cacheWrite1h ?? 0) + source.cacheWrite1h;
+	}
+	if (source.reasoning !== undefined) {
+		target.reasoning = (target.reasoning ?? 0) + source.reasoning;
+	}
+	target.totalTokens += source.totalTokens;
+	target.cost += source.cost;
+	target.costInput += source.costInput;
+	target.costOutput += source.costOutput;
+	target.costCacheRead += source.costCacheRead;
+	target.costCacheWrite += source.costCacheWrite;
+	target.turns += source.turns;
+	target.contextTokens = source.contextTokens || target.contextTokens;
+	return target;
+}
+
+function usageStatsToToolUsage(stats: UsageStats): Usage {
+	return {
+		input: stats.input,
+		output: stats.output,
+		cacheRead: stats.cacheRead,
+		cacheWrite: stats.cacheWrite,
+		...(stats.cacheWrite1h !== undefined ? { cacheWrite1h: stats.cacheWrite1h } : {}),
+		...(stats.reasoning !== undefined ? { reasoning: stats.reasoning } : {}),
+		totalTokens: stats.totalTokens,
+		cost: {
+			input: stats.costInput,
+			output: stats.costOutput,
+			cacheRead: stats.costCacheRead,
+			cacheWrite: stats.costCacheWrite,
+			total: stats.cost,
+		},
+	};
+}
+
+function addUsageStats(
+	target: UsageStats,
+	source: Usage | undefined,
+	options: { countTurn?: boolean; updateContextTokens?: boolean } = {},
+): void {
+	if (!source) return;
+	if (options.countTurn) target.turns += 1;
+	target.input += source.input || 0;
+	target.output += source.output || 0;
+	target.cacheRead += source.cacheRead || 0;
+	target.cacheWrite += source.cacheWrite || 0;
+	if (source.cacheWrite1h !== undefined) {
+		target.cacheWrite1h = (target.cacheWrite1h ?? 0) + source.cacheWrite1h;
+	}
+	if (source.reasoning !== undefined) {
+		target.reasoning = (target.reasoning ?? 0) + source.reasoning;
+	}
+	target.totalTokens += source.totalTokens || 0;
+	target.cost += source.cost?.total || 0;
+	target.costInput += source.cost?.input || 0;
+	target.costOutput += source.cost?.output || 0;
+	target.costCacheRead += source.cost?.cacheRead || 0;
+	target.costCacheWrite += source.cost?.cacheWrite || 0;
+	if (options.updateContextTokens) {
+		target.contextTokens = source.totalTokens || target.contextTokens;
+	}
+}
+
 function getOracleConfigPath(): string {
 	return path.join(getAgentDir(), "extensions", ORACLE_CONFIG_FILE);
 }
@@ -595,6 +695,7 @@ function formatUsage(stats: UsageStats): string {
 	if (stats.output) parts.push(`↓${formatTokens(stats.output)}`);
 	if (stats.cacheRead) parts.push(`R${formatTokens(stats.cacheRead)}`);
 	if (stats.cacheWrite) parts.push(`W${formatTokens(stats.cacheWrite)}`);
+	if (stats.reasoning) parts.push(`T${formatTokens(stats.reasoning)}`);
 	if (stats.cost) parts.push(`$${stats.cost.toFixed(4)}`);
 	if (stats.contextTokens) parts.push(`ctx:${formatTokens(stats.contextTokens)}`);
 	return parts.join(" ");
@@ -934,6 +1035,7 @@ async function runOracle(
 	signal: AbortSignal | undefined,
 	onUpdate: ((result: { content: Array<{ type: "text"; text: string }>; details: OracleDetails }) => void) | undefined,
 	defaultCwd: string,
+	spawnImpl: typeof spawn = spawn,
 ): Promise<{ ok: true; output: string; details: OracleDetails } | { ok: false; error: string; details: OracleDetails }> {
 	const cwd = params.cwd ?? defaultCwd;
 	const includeBash = params.includeBash ?? false;
@@ -985,7 +1087,7 @@ async function runOracle(
 	let wasAborted = false;
 
 	const exitCode = await new Promise<number>((resolve) => {
-		const proc = spawn(invocation.command, invocation.args, {
+		const proc = spawnImpl(invocation.command, invocation.args, {
 			cwd,
 			shell: false,
 			stdio: ["ignore", "pipe", "pipe"],
@@ -1023,18 +1125,16 @@ async function runOracle(
 				const errorMessageField = event.message.errorMessage;
 				lastErrorMessage = typeof errorMessageField === "string" ? errorMessageField : undefined;
 
-				const messageUsage = event.message.usage;
-				if (messageUsage) {
-					usage.turns += 1;
-					usage.input += messageUsage.input || 0;
-					usage.output += messageUsage.output || 0;
-					usage.cacheRead += messageUsage.cacheRead || 0;
-					usage.cacheWrite += messageUsage.cacheWrite || 0;
-					usage.cost += messageUsage.cost?.total || 0;
-					usage.contextTokens = messageUsage.totalTokens || usage.contextTokens;
-				}
-
+				addUsageStats(usage, event.message.usage as Usage | undefined, {
+					countTurn: true,
+					updateContextTokens: true,
+				});
 				emit();
+				return;
+			}
+
+			if (event.type === "compaction_end") {
+				addUsageStats(usage, event.result?.usage as Usage | undefined);
 			}
 		};
 
@@ -1050,26 +1150,53 @@ async function runOracle(
 			emit();
 		});
 
+		let closed = false;
+		let killTimer: ReturnType<typeof setTimeout> | undefined;
+		let abortListener: (() => void) | undefined;
+
+		const childHasExited = () => proc.exitCode !== null || proc.signalCode !== null;
+		const clearEscalation = () => {
+			if (killTimer) {
+				clearTimeout(killTimer);
+				killTimer = undefined;
+			}
+		};
+		const cleanup = () => {
+			clearEscalation();
+			if (signal && abortListener) {
+				signal.removeEventListener("abort", abortListener);
+				abortListener = undefined;
+			}
+		};
+
+		proc.on("exit", () => {
+			clearEscalation();
+		});
+
 		proc.on("close", (code) => {
+			closed = true;
+			cleanup();
 			if (buffer.trim()) processLine(buffer);
 			resolve(code ?? 0);
 		});
 
 		proc.on("error", (error) => {
+			cleanup();
 			stderr += `${error instanceof Error ? error.message : String(error)}\n`;
 			resolve(1);
 		});
 
 		if (signal) {
-			const killProc = () => {
+			abortListener = () => {
 				wasAborted = true;
 				proc.kill("SIGTERM");
-				setTimeout(() => {
-					if (!proc.killed) proc.kill("SIGKILL");
+				if (closed || childHasExited()) return;
+				killTimer = setTimeout(() => {
+					if (!closed && !childHasExited()) proc.kill("SIGKILL");
 				}, 5000);
 			};
-			if (signal.aborted) killProc();
-			else signal.addEventListener("abort", killProc, { once: true });
+			if (signal.aborted) abortListener();
+			else signal.addEventListener("abort", abortListener, { once: true });
 		}
 	});
 
@@ -1078,6 +1205,7 @@ async function runOracle(
 	details.durationMs = Date.now() - startedAt;
 
 	if (wasAborted) {
+		if (details.exitCode === 0) details.exitCode = 1;
 		return { ok: false, error: "Oracle was aborted.", details };
 	}
 
@@ -1087,6 +1215,7 @@ async function runOracle(
 	// so callers can distinguish transient provider errors from a genuinely
 	// empty response.
 	if (lastStopReason === "error" || lastStopReason === "aborted") {
+		if (details.exitCode === 0) details.exitCode = 1;
 		return {
 			ok: false,
 			error: formatOracleModelError(lastStopReason, lastErrorMessage),
@@ -1103,6 +1232,7 @@ async function runOracle(
 	}
 
 	if (!finalOutput.trim()) {
+		if (details.exitCode === 0) details.exitCode = 1;
 		return {
 			ok: false,
 			error: details.stderr || "Oracle finished without returning any text.",
@@ -1123,14 +1253,26 @@ function renderCollapsedText(text: string, lineLimit = COLLAPSED_LINE_LIMIT): st
 	return [...lines.slice(0, lineLimit), `... (${lines.length - lineLimit} more lines)`].join("\n");
 }
 
+type OracleExtensionDeps = {
+	spawnImpl?: typeof spawn;
+};
+
 export const __test__ = {
+	createOracleExtension,
 	findAvailableModel,
+	isModelAvailabilityError,
 	parseModelPreference,
+	runOracle,
 	resolveThinkingLevel,
 	selectOracleModel,
 };
 
 export default function oracleExtension(pi: ExtensionAPI) {
+	createOracleExtension(pi);
+}
+
+function createOracleExtension(pi: ExtensionAPI, deps: OracleExtensionDeps = {}) {
+	const spawnImpl = deps.spawnImpl ?? spawn;
 	const activeRuns = new Map<string, OracleUiRun>();
 	let preferences: OraclePreferences = {};
 
@@ -1276,6 +1418,13 @@ export default function oracleExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	pi.on("tool_result", async (event) => {
+		if (event.toolName !== "oracle") return undefined;
+		const details = event.details as OracleDetails | undefined;
+		if ((details?.exitCode ?? 0) === 0) return undefined;
+		return { isError: true };
+	});
+
 	pi.registerTool({
 		name: "oracle",
 		label: "Oracle",
@@ -1284,10 +1433,11 @@ export default function oracleExtension(pi: ExtensionAPI) {
 		promptSnippet:
 			"Consult a read-only oracle that auto-selects the strongest reasoning model on the current provider/subscription.",
 		promptGuidelines: [
-			"Use this tool sparingly when you want a second opinion, deeper analysis, code review, debugging help, or a higher-reasoning pass.",
-			"Do not use it for routine low-value work; it is slower than the main agent.",
-			"The oracle is read-only by default. Set includeBash only when shell-based inspection is genuinely useful.",
-			"The oracle requests xhigh by default for reasoning models; defaults and explicit thinkingLevel overrides are clamped to the effective model-supported level when the model is matched.",
+			"Use oracle sparingly when you want a second opinion, deeper analysis, code review, debugging help, or a higher-reasoning pass.",
+			"Do not use oracle for routine low-value work; oracle is slower than the main agent.",
+			"The oracle tool is read-only by default and only exposes read, grep, find, and ls unless oracle includeBash is enabled.",
+			"Set oracle includeBash only when the extra bash inspection tool is genuinely useful; keep oracle relying on read, grep, find, and ls otherwise.",
+			"The oracle tool requests xhigh by default for reasoning models; oracle defaults and explicit thinkingLevel overrides are clamped to the effective model-supported level when the model is matched.",
 		],
 		parameters: OracleParams,
 
@@ -1312,6 +1462,14 @@ export default function oracleExtension(pi: ExtensionAPI) {
 			try {
 				const attempts: OracleSelection[] = [];
 				const seen = new Set<string>();
+				const aggregateUsage = createEmptyUsage();
+				const finalizeResult = (
+					result: { content: Array<{ type: "text"; text: string }>; details: OracleDetails },
+				): AgentToolResult<OracleDetails> => ({
+					...result,
+					details: { ...result.details, usage: cloneUsageStats(aggregateUsage) },
+					usage: usageStatsToToolUsage(aggregateUsage),
+				});
 				const pushAttempt = (candidate: OracleSelection | undefined) => {
 					if (!candidate) return;
 					const key = `${candidate.provider}/${candidate.modelId}`.toLowerCase();
@@ -1353,7 +1511,7 @@ export default function oracleExtension(pi: ExtensionAPI) {
 				} else {
 					const selectionResult = await selectOracleModel(ctx, configuredThinkingLevel);
 					if (!selectionResult.ok) {
-						return {
+						return finalizeResult({
 							content: [{ type: "text", text: selectionResult.error }],
 							details: {
 								modelRef: "",
@@ -1370,7 +1528,7 @@ export default function oracleExtension(pi: ExtensionAPI) {
 								durationMs: 0,
 								cwd: params.cwd ?? ctx.cwd,
 							},
-						};
+						});
 					}
 					for (const candidate of selectionResult.ordered) pushAttempt(candidate);
 				}
@@ -1394,25 +1552,26 @@ export default function oracleExtension(pi: ExtensionAPI) {
 					uiRun.selection = attempt;
 					updateOracleUi(ctx, activeRuns);
 
-					const result = await runOracle(attempt, { ...params, task }, signal, handleUpdate, ctx.cwd);
+					const result = await runOracle(attempt, { ...params, task }, signal, handleUpdate, ctx.cwd, spawnImpl);
+					mergeUsageStats(aggregateUsage, result.details.usage);
 					if (result.ok) {
-						return {
+						return finalizeResult({
 							content: [{ type: "text", text: result.output }],
 							details: result.details,
-						};
+						});
 					}
 
 					lastErrorResult = result;
 					const canFallBack = index < attempts.length - 1 && isModelAvailabilityError(result.error);
 					if (!canFallBack) {
-						return {
+						return finalizeResult({
 							content: [{ type: "text", text: result.error }],
 							details: result.details,
-						};
+						});
 					}
 				}
 
-				return {
+				return finalizeResult({
 					content: [
 						{ type: "text", text: lastErrorResult?.error ?? "Oracle could not select an available model." },
 					],
@@ -1432,7 +1591,7 @@ export default function oracleExtension(pi: ExtensionAPI) {
 							durationMs: 0,
 							cwd: params.cwd ?? ctx.cwd,
 						},
-				};
+				});
 			} finally {
 				activeRuns.delete(toolCallId);
 				updateOracleUi(ctx, activeRuns);

package/extensions/oracle/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-oracle",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "An Amp-style oracle extension for pi that consults the strongest reasoning model on your current provider.",
   "keywords": [
     "pi-package",
@@ -34,5 +34,9 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
   }
 }

package/extensions/permission-gate/.pi-fleet-tested-version

@@ -1 +1 @@
-0.80.6
+0.81.1

package/extensions/permission-gate/README.md

@@ -2,7 +2,7 @@
 
 A small pi extension that prompts for confirmation before running potentially dangerous bash commands or writing to protected paths.
 
-This is adapted from the original `permission-gate.ts` example in [`earendil-works/pi-mono`](https://github.com/earendil-works/pi-mono/blob/main/packages/coding-agent/examples/extensions/permission-gate.ts) and kept basically the same.
+This is adapted from the original `permission-gate.ts` example in [`earendil-works/pi`](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/examples/extensions/permission-gate.ts) and kept basically the same.
 
 ## What it checks