@mariozechner/pi-coding-agent 0.37.4 → 0.37.5

package/examples/extensions/preset.ts

@@ -0,0 +1,398 @@
+/**
+ * Preset Extension
+ *
+ * Allows defining named presets that configure model, thinking level, tools,
+ * and system prompt instructions. Presets are defined in JSON config files
+ * and can be activated via CLI flag, /preset command, or Ctrl+Shift+U to cycle.
+ *
+ * Config files (merged, project takes precedence):
+ * - ~/.pi/agent/presets.json (global)
+ * - <cwd>/.pi/presets.json (project-local)
+ *
+ * Example presets.json:
+ * ```json
+ * {
+ *   "plan": {
+ *     "provider": "anthropic",
+ *     "model": "claude-sonnet-4-5",
+ *     "thinkingLevel": "high",
+ *     "tools": ["read", "grep", "find", "ls"],
+ *     "instructions": "You are in PLANNING MODE. Your job is to deeply understand the problem and create a detailed implementation plan.\n\nRules:\n- DO NOT make any changes. You cannot edit or write files.\n- Read files IN FULL (no offset/limit) to get complete context. Partial reads miss critical details.\n- Explore thoroughly: grep for related code, find similar patterns, understand the architecture.\n- Ask clarifying questions if requirements are ambiguous. Do not assume.\n- Identify risks, edge cases, and dependencies before proposing solutions.\n\nOutput:\n- Create a structured plan with numbered steps.\n- For each step: what to change, why, and potential risks.\n- List files that will be modified.\n- Note any tests that should be added or updated.\n\nWhen done, ask the user if they want you to:\n1. Write the plan to a markdown file (e.g., PLAN.md)\n2. Create a GitHub issue with the plan\n3. Proceed to implementation (they should switch to 'implement' preset)"
+ *   },
+ *   "implement": {
+ *     "provider": "anthropic",
+ *     "model": "claude-sonnet-4-5",
+ *     "thinkingLevel": "high",
+ *     "tools": ["read", "bash", "edit", "write"],
+ *     "instructions": "You are in IMPLEMENTATION MODE. Your job is to make focused, correct changes.\n\nRules:\n- Keep scope tight. Do exactly what was asked, no more.\n- Read files before editing to understand current state.\n- Make surgical edits. Prefer edit over write for existing files.\n- Explain your reasoning briefly before each change.\n- Run tests or type checks after changes if the project has them (npm test, npm run check, etc.).\n- If you encounter unexpected complexity, STOP and explain the issue rather than hacking around it.\n\nIf no plan exists:\n- Ask clarifying questions before starting.\n- Propose what you'll do and get confirmation for non-trivial changes.\n\nAfter completing changes:\n- Summarize what was done.\n- Note any follow-up work or tests that should be added."
+ *   }
+ * }
+ * ```
+ *
+ * Usage:
+ * - `pi --preset plan` - start with plan preset
+ * - `/preset` - show selector to switch presets mid-session
+ * - `/preset implement` - switch to implement preset directly
+ * - `Ctrl+Shift+U` - cycle through presets
+ *
+ * CLI flags always override preset values.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import { Container, Key, type SelectItem, SelectList, Text } from "@mariozechner/pi-tui";
+
+// Preset configuration
+interface Preset {
+	/** Provider name (e.g., "anthropic", "openai") */
+	provider?: string;
+	/** Model ID (e.g., "claude-sonnet-4-5") */
+	model?: string;
+	/** Thinking level */
+	thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+	/** Tools to enable (replaces default set) */
+	tools?: string[];
+	/** Instructions to append to system prompt */
+	instructions?: string;
+}
+
+interface PresetsConfig {
+	[name: string]: Preset;
+}
+
+/**
+ * Load presets from config files.
+ * Project-local presets override global presets with the same name.
+ */
+function loadPresets(cwd: string): PresetsConfig {
+	const globalPath = join(homedir(), ".pi", "agent", "presets.json");
+	const projectPath = join(cwd, ".pi", "presets.json");
+
+	let globalPresets: PresetsConfig = {};
+	let projectPresets: PresetsConfig = {};
+
+	// Load global presets
+	if (existsSync(globalPath)) {
+		try {
+			const content = readFileSync(globalPath, "utf-8");
+			globalPresets = JSON.parse(content);
+		} catch (err) {
+			console.error(`Failed to load global presets from ${globalPath}: ${err}`);
+		}
+	}
+
+	// Load project presets
+	if (existsSync(projectPath)) {
+		try {
+			const content = readFileSync(projectPath, "utf-8");
+			projectPresets = JSON.parse(content);
+		} catch (err) {
+			console.error(`Failed to load project presets from ${projectPath}: ${err}`);
+		}
+	}
+
+	// Merge (project overrides global)
+	return { ...globalPresets, ...projectPresets };
+}
+
+export default function presetExtension(pi: ExtensionAPI) {
+	let presets: PresetsConfig = {};
+	let activePresetName: string | undefined;
+	let activePreset: Preset | undefined;
+
+	// Register --preset CLI flag
+	pi.registerFlag("preset", {
+		description: "Preset configuration to use",
+		type: "string",
+	});
+
+	/**
+	 * Apply a preset configuration.
+	 */
+	async function applyPreset(name: string, preset: Preset, ctx: ExtensionContext): Promise<boolean> {
+		// Apply model if specified
+		if (preset.provider && preset.model) {
+			const model = ctx.modelRegistry.find(preset.provider, preset.model);
+			if (model) {
+				const success = await pi.setModel(model);
+				if (!success) {
+					ctx.ui.notify(`Preset "${name}": No API key for ${preset.provider}/${preset.model}`, "warning");
+				}
+			} else {
+				ctx.ui.notify(`Preset "${name}": Model ${preset.provider}/${preset.model} not found`, "warning");
+			}
+		}
+
+		// Apply thinking level if specified
+		if (preset.thinkingLevel) {
+			pi.setThinkingLevel(preset.thinkingLevel);
+		}
+
+		// Apply tools if specified
+		if (preset.tools && preset.tools.length > 0) {
+			const allTools = pi.getAllTools();
+			const validTools = preset.tools.filter((t) => allTools.includes(t));
+			const invalidTools = preset.tools.filter((t) => !allTools.includes(t));
+
+			if (invalidTools.length > 0) {
+				ctx.ui.notify(`Preset "${name}": Unknown tools: ${invalidTools.join(", ")}`, "warning");
+			}
+
+			if (validTools.length > 0) {
+				pi.setActiveTools(validTools);
+			}
+		}
+
+		// Store active preset for system prompt injection
+		activePresetName = name;
+		activePreset = preset;
+
+		return true;
+	}
+
+	/**
+	 * Build description string for a preset.
+	 */
+	function buildPresetDescription(preset: Preset): string {
+		const parts: string[] = [];
+
+		if (preset.provider && preset.model) {
+			parts.push(`${preset.provider}/${preset.model}`);
+		}
+		if (preset.thinkingLevel) {
+			parts.push(`thinking:${preset.thinkingLevel}`);
+		}
+		if (preset.tools) {
+			parts.push(`tools:${preset.tools.join(",")}`);
+		}
+		if (preset.instructions) {
+			const truncated =
+				preset.instructions.length > 30 ? `${preset.instructions.slice(0, 27)}...` : preset.instructions;
+			parts.push(`"${truncated}"`);
+		}
+
+		return parts.join(" | ");
+	}
+
+	/**
+	 * Show preset selector UI using custom SelectList component.
+	 */
+	async function showPresetSelector(ctx: ExtensionContext): Promise<void> {
+		const presetNames = Object.keys(presets);
+
+		if (presetNames.length === 0) {
+			ctx.ui.notify("No presets defined. Add presets to ~/.pi/agent/presets.json or .pi/presets.json", "warning");
+			return;
+		}
+
+		// Build select items with descriptions
+		const items: SelectItem[] = presetNames.map((name) => {
+			const preset = presets[name];
+			const isActive = name === activePresetName;
+			return {
+				value: name,
+				label: isActive ? `${name} (active)` : name,
+				description: buildPresetDescription(preset),
+			};
+		});
+
+		// Add "None" option to clear preset
+		items.push({
+			value: "(none)",
+			label: "(none)",
+			description: "Clear active preset, restore defaults",
+		});
+
+		const result = await ctx.ui.custom<string | null>((tui, theme, done) => {
+			const container = new Container();
+			container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
+
+			// Header
+			container.addChild(new Text(theme.fg("accent", theme.bold("Select Preset"))));
+
+			// SelectList with themed styling
+			const selectList = new SelectList(items, Math.min(items.length, 10), {
+				selectedPrefix: (text) => theme.fg("accent", text),
+				selectedText: (text) => theme.fg("accent", text),
+				description: (text) => theme.fg("muted", text),
+				scrollInfo: (text) => theme.fg("dim", text),
+				noMatch: (text) => theme.fg("warning", text),
+			});
+
+			selectList.onSelect = (item) => done(item.value);
+			selectList.onCancel = () => done(null);
+
+			container.addChild(selectList);
+
+			// Footer hint
+			container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc cancel")));
+
+			container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
+
+			return {
+				render(width: number) {
+					return container.render(width);
+				},
+				invalidate() {
+					container.invalidate();
+				},
+				handleInput(data: string) {
+					selectList.handleInput(data);
+					tui.requestRender();
+				},
+			};
+		});
+
+		if (!result) return;
+
+		if (result === "(none)") {
+			// Clear preset and restore defaults
+			activePresetName = undefined;
+			activePreset = undefined;
+			pi.setActiveTools(["read", "bash", "edit", "write"]);
+			ctx.ui.notify("Preset cleared, defaults restored", "info");
+			updateStatus(ctx);
+			return;
+		}
+
+		const preset = presets[result];
+		if (preset) {
+			await applyPreset(result, preset, ctx);
+			ctx.ui.notify(`Preset "${result}" activated`, "info");
+			updateStatus(ctx);
+		}
+	}
+
+	/**
+	 * Update status indicator.
+	 */
+	function updateStatus(ctx: ExtensionContext) {
+		if (activePresetName) {
+			ctx.ui.setStatus("preset", ctx.ui.theme.fg("accent", `preset:${activePresetName}`));
+		} else {
+			ctx.ui.setStatus("preset", undefined);
+		}
+	}
+
+	function getPresetOrder(): string[] {
+		return Object.keys(presets).sort();
+	}
+
+	async function cyclePreset(ctx: ExtensionContext): Promise<void> {
+		const presetNames = getPresetOrder();
+		if (presetNames.length === 0) {
+			ctx.ui.notify("No presets defined. Add presets to ~/.pi/agent/presets.json or .pi/presets.json", "warning");
+			return;
+		}
+
+		const cycleList = ["(none)", ...presetNames];
+		const currentName = activePresetName ?? "(none)";
+		const currentIndex = cycleList.indexOf(currentName);
+		const nextIndex = currentIndex === -1 ? 0 : (currentIndex + 1) % cycleList.length;
+		const nextName = cycleList[nextIndex];
+
+		if (nextName === "(none)") {
+			activePresetName = undefined;
+			activePreset = undefined;
+			pi.setActiveTools(["read", "bash", "edit", "write"]);
+			ctx.ui.notify("Preset cleared, defaults restored", "info");
+			updateStatus(ctx);
+			return;
+		}
+
+		const preset = presets[nextName];
+		if (!preset) return;
+
+		await applyPreset(nextName, preset, ctx);
+		ctx.ui.notify(`Preset "${nextName}" activated`, "info");
+		updateStatus(ctx);
+	}
+
+	pi.registerShortcut(Key.ctrlShift("u"), {
+		description: "Cycle presets",
+		handler: async (ctx) => {
+			await cyclePreset(ctx);
+		},
+	});
+
+	// Register /preset command
+	pi.registerCommand("preset", {
+		description: "Switch preset configuration",
+		handler: async (args, ctx) => {
+			// If preset name provided, apply directly
+			if (args?.trim()) {
+				const name = args.trim();
+				const preset = presets[name];
+
+				if (!preset) {
+					const available = Object.keys(presets).join(", ") || "(none defined)";
+					ctx.ui.notify(`Unknown preset "${name}". Available: ${available}`, "error");
+					return;
+				}
+
+				await applyPreset(name, preset, ctx);
+				ctx.ui.notify(`Preset "${name}" activated`, "info");
+				updateStatus(ctx);
+				return;
+			}
+
+			// Otherwise show selector
+			await showPresetSelector(ctx);
+		},
+	});
+
+	// Inject preset instructions into system prompt
+	pi.on("before_agent_start", async () => {
+		if (activePreset?.instructions) {
+			return {
+				systemPromptAppend: activePreset.instructions,
+			};
+		}
+	});
+
+	// Initialize on session start
+	pi.on("session_start", async (_event, ctx) => {
+		// Load presets from config files
+		presets = loadPresets(ctx.cwd);
+
+		// Check for --preset flag
+		const presetFlag = pi.getFlag("preset");
+		if (typeof presetFlag === "string" && presetFlag) {
+			const preset = presets[presetFlag];
+			if (preset) {
+				await applyPreset(presetFlag, preset, ctx);
+				ctx.ui.notify(`Preset "${presetFlag}" activated`, "info");
+			} else {
+				const available = Object.keys(presets).join(", ") || "(none defined)";
+				ctx.ui.notify(`Unknown preset "${presetFlag}". Available: ${available}`, "warning");
+			}
+		}
+
+		// Restore preset from session state
+		const entries = ctx.sessionManager.getEntries();
+		const presetEntry = entries
+			.filter((e: { type: string; customType?: string }) => e.type === "custom" && e.customType === "preset-state")
+			.pop() as { data?: { name: string } } | undefined;
+
+		if (presetEntry?.data?.name && !presetFlag) {
+			const preset = presets[presetEntry.data.name];
+			if (preset) {
+				activePresetName = presetEntry.data.name;
+				activePreset = preset;
+				// Don't re-apply model/tools on restore, just keep the name for instructions
+			}
+		}
+
+		updateStatus(ctx);
+	});
+
+	// Persist preset state
+	pi.on("turn_start", async () => {
+		if (activePresetName) {
+			pi.appendEntry("preset-state", { name: activePresetName });
+		}
+	});
+}

package/examples/extensions/truncated-tool.ts

@@ -0,0 +1,192 @@
+/**
+ * Truncated Tool Example - Demonstrates proper output truncation for custom tools
+ *
+ * Custom tools MUST truncate their output to avoid overwhelming the LLM context.
+ * The built-in limit is 50KB (~10k tokens) and 2000 lines, whichever is hit first.
+ *
+ * This example shows how to:
+ * 1. Use the built-in truncation utilities
+ * 2. Write full output to a temp file when truncated
+ * 3. Inform the LLM where to find the complete output
+ * 4. Custom rendering of tool calls and results
+ *
+ * The `rg` tool here wraps ripgrep with proper truncation. Compare this to the
+ * built-in `grep` tool in src/core/tools/grep.ts for a more complete implementation.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+	type TruncationResult,
+	truncateHead,
+} from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { execSync } from "child_process";
+import { mkdtempSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+const RgParams = Type.Object({
+	pattern: Type.String({ description: "Search pattern (regex)" }),
+	path: Type.Optional(Type.String({ description: "Directory to search (default: current directory)" })),
+	glob: Type.Optional(Type.String({ description: "File glob pattern, e.g. '*.ts'" })),
+});
+
+interface RgDetails {
+	pattern: string;
+	path?: string;
+	glob?: string;
+	matchCount: number;
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "rg",
+		label: "ripgrep",
+		// Document the truncation limits in the tool description so the LLM knows
+		description: `Search file contents using ripgrep. Output is truncated to ${DEFAULT_MAX_LINES} lines or ${formatSize(DEFAULT_MAX_BYTES)} (whichever is hit first). If truncated, full output is saved to a temp file.`,
+		parameters: RgParams,
+
+		async execute(_toolCallId, params, _onUpdate, ctx) {
+			const { pattern, path: searchPath, glob } = params;
+
+			// Build the ripgrep command
+			const args = ["rg", "--line-number", "--color=never"];
+			if (glob) args.push("--glob", glob);
+			args.push(pattern);
+			args.push(searchPath || ".");
+
+			let output: string;
+			try {
+				output = execSync(args.join(" "), {
+					cwd: ctx.cwd,
+					encoding: "utf-8",
+					maxBuffer: 100 * 1024 * 1024, // 100MB buffer to capture full output
+				});
+			} catch (err: any) {
+				// ripgrep exits with 1 when no matches found
+				if (err.status === 1) {
+					return {
+						content: [{ type: "text", text: "No matches found" }],
+						details: { pattern, path: searchPath, glob, matchCount: 0 } as RgDetails,
+					};
+				}
+				throw new Error(`ripgrep failed: ${err.message}`);
+			}
+
+			if (!output.trim()) {
+				return {
+					content: [{ type: "text", text: "No matches found" }],
+					details: { pattern, path: searchPath, glob, matchCount: 0 } as RgDetails,
+				};
+			}
+
+			// Apply truncation using built-in utilities
+			// truncateHead keeps the first N lines/bytes (good for search results)
+			// truncateTail keeps the last N lines/bytes (good for logs/command output)
+			const truncation = truncateHead(output, {
+				maxLines: DEFAULT_MAX_LINES,
+				maxBytes: DEFAULT_MAX_BYTES,
+			});
+
+			// Count matches (each non-empty line with a match)
+			const matchCount = output.split("\n").filter((line) => line.trim()).length;
+
+			const details: RgDetails = {
+				pattern,
+				path: searchPath,
+				glob,
+				matchCount,
+			};
+
+			let resultText = truncation.content;
+
+			if (truncation.truncated) {
+				// Save full output to a temp file so LLM can access it if needed
+				const tempDir = mkdtempSync(join(tmpdir(), "pi-rg-"));
+				const tempFile = join(tempDir, "output.txt");
+				writeFileSync(tempFile, output);
+
+				details.truncation = truncation;
+				details.fullOutputPath = tempFile;
+
+				// Add truncation notice - this helps the LLM understand the output is incomplete
+				const truncatedLines = truncation.totalLines - truncation.outputLines;
+				const truncatedBytes = truncation.totalBytes - truncation.outputBytes;
+
+				resultText += `\n\n[Output truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`;
+				resultText += ` (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}).`;
+				resultText += ` ${truncatedLines} lines (${formatSize(truncatedBytes)}) omitted.`;
+				resultText += ` Full output saved to: ${tempFile}]`;
+			}
+
+			return {
+				content: [{ type: "text", text: resultText }],
+				details,
+			};
+		},
+
+		// Custom rendering of the tool call (shown before/during execution)
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("rg "));
+			text += theme.fg("accent", `"${args.pattern}"`);
+			if (args.path) {
+				text += theme.fg("muted", ` in ${args.path}`);
+			}
+			if (args.glob) {
+				text += theme.fg("dim", ` --glob ${args.glob}`);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		// Custom rendering of the tool result
+		renderResult(result, { expanded, isPartial }, theme) {
+			const details = result.details as RgDetails | undefined;
+
+			// Handle streaming/partial results
+			if (isPartial) {
+				return new Text(theme.fg("warning", "Searching..."), 0, 0);
+			}
+
+			// No matches
+			if (!details || details.matchCount === 0) {
+				return new Text(theme.fg("dim", "No matches found"), 0, 0);
+			}
+
+			// Build result display
+			let text = theme.fg("success", `${details.matchCount} matches`);
+
+			// Show truncation warning if applicable
+			if (details.truncation?.truncated) {
+				text += theme.fg("warning", " (truncated)");
+			}
+
+			// In expanded view, show the actual matches
+			if (expanded) {
+				const content = result.content[0];
+				if (content?.type === "text") {
+					// Show first 20 lines in expanded view, or all if fewer
+					const lines = content.text.split("\n").slice(0, 20);
+					for (const line of lines) {
+						text += `\n${theme.fg("dim", line)}`;
+					}
+					if (content.text.split("\n").length > 20) {
+						text += `\n${theme.fg("muted", "... (use read tool to see full output)")}`;
+					}
+				}
+
+				// Show temp file path if truncated
+				if (details.fullOutputPath) {
+					text += `\n${theme.fg("dim", `Full output: ${details.fullOutputPath}`)}`;
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+}

package/examples/extensions/with-deps/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pi-extension-with-deps",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pi-extension-with-deps",
-      "version": "1.1.4",
+      "version": "1.1.5",
       "dependencies": {
         "ms": "^2.1.3"
       },

package/examples/extensions/with-deps/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-extension-with-deps",
   "private": true,
-  "version": "1.1.4",
+  "version": "1.1.5",
   "type": "module",
   "scripts": {
     "clean": "echo 'nothing to clean'",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mariozechner/pi-coding-agent",
-	"version": "0.37.4",
+	"version": "0.37.5",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -39,9 +39,9 @@
 	},
 	"dependencies": {
 		"@crosscopy/clipboard": "^0.2.8",
-		"@mariozechner/pi-agent-core": "^0.37.4",
-		"@mariozechner/pi-ai": "^0.37.4",
-		"@mariozechner/pi-tui": "^0.37.4",
+		"@mariozechner/pi-agent-core": "^0.37.5",
+		"@mariozechner/pi-ai": "^0.37.5",
+		"@mariozechner/pi-tui": "^0.37.5",
 		"chalk": "^5.5.0",
 		"cli-highlight": "^2.1.11",
 		"diff": "^8.0.2",