gsd-pi 2.5.1 → 2.7.0

package/packages/pi-coding-agent/src/core/extensions/wrapper.ts

@@ -0,0 +1,118 @@
+/**
+ * Tool wrappers for extensions.
+ */
+
+import type { AgentTool, AgentToolUpdateCallback } from "@gsd/pi-agent-core";
+import type { ExtensionRunner } from "./runner.js";
+import type { RegisteredTool, ToolCallEventResult } from "./types.js";
+
+/**
+ * Wrap a RegisteredTool into an AgentTool.
+ * Uses the runner's createContext() for consistent context across tools and event handlers.
+ */
+export function wrapRegisteredTool(registeredTool: RegisteredTool, runner: ExtensionRunner): AgentTool {
+	const { definition } = registeredTool;
+	return {
+		name: definition.name,
+		label: definition.label,
+		description: definition.description,
+		parameters: definition.parameters,
+		execute: (toolCallId, params, signal, onUpdate) =>
+			definition.execute(toolCallId, params, signal, onUpdate, runner.createContext()),
+	};
+}
+
+/**
+ * Wrap all registered tools into AgentTools.
+ * Uses the runner's createContext() for consistent context across tools and event handlers.
+ */
+export function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: ExtensionRunner): AgentTool[] {
+	return registeredTools.map((rt) => wrapRegisteredTool(rt, runner));
+}
+
+/**
+ * Wrap a tool with extension callbacks for interception.
+ * - Emits tool_call event before execution (can block)
+ * - Emits tool_result event after execution (can modify result)
+ */
+export function wrapToolWithExtensions<T>(tool: AgentTool<any, T>, runner: ExtensionRunner): AgentTool<any, T> {
+	return {
+		...tool,
+		execute: async (
+			toolCallId: string,
+			params: Record<string, unknown>,
+			signal?: AbortSignal,
+			onUpdate?: AgentToolUpdateCallback<T>,
+		) => {
+			// Emit tool_call event - extensions can block execution
+			if (runner.hasHandlers("tool_call")) {
+				try {
+					const callResult = (await runner.emitToolCall({
+						type: "tool_call",
+						toolName: tool.name,
+						toolCallId,
+						input: params,
+					})) as ToolCallEventResult | undefined;
+
+					if (callResult?.block) {
+						const reason = callResult.reason || "Tool execution was blocked by an extension";
+						throw new Error(reason);
+					}
+				} catch (err) {
+					if (err instanceof Error) {
+						throw err;
+					}
+					throw new Error(`Extension failed, blocking execution: ${String(err)}`);
+				}
+			}
+
+			// Execute the actual tool
+			try {
+				const result = await tool.execute(toolCallId, params, signal, onUpdate);
+
+				// Emit tool_result event - extensions can modify the result
+				if (runner.hasHandlers("tool_result")) {
+					const resultResult = await runner.emitToolResult({
+						type: "tool_result",
+						toolName: tool.name,
+						toolCallId,
+						input: params,
+						content: result.content,
+						details: result.details,
+						isError: false,
+					});
+
+					if (resultResult) {
+						return {
+							content: resultResult.content ?? result.content,
+							details: (resultResult.details ?? result.details) as T,
+						};
+					}
+				}
+
+				return result;
+			} catch (err) {
+				// Emit tool_result event for errors
+				if (runner.hasHandlers("tool_result")) {
+					await runner.emitToolResult({
+						type: "tool_result",
+						toolName: tool.name,
+						toolCallId,
+						input: params,
+						content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+						details: undefined,
+						isError: true,
+					});
+				}
+				throw err;
+			}
+		},
+	};
+}
+
+/**
+ * Wrap all tools with extension callbacks.
+ */
+export function wrapToolsWithExtensions<T>(tools: AgentTool<any, T>[], runner: ExtensionRunner): AgentTool<any, T>[] {
+	return tools.map((tool) => wrapToolWithExtensions(tool, runner));
+}

package/packages/pi-coding-agent/src/core/footer-data-provider.ts

@@ -0,0 +1,144 @@
+import { existsSync, type FSWatcher, readFileSync, statSync, watch } from "fs";
+import { dirname, join, resolve } from "path";
+
+/**
+ * Find the git HEAD path by walking up from cwd.
+ * Handles both regular git repos (.git is a directory) and worktrees (.git is a file).
+ */
+function findGitHeadPath(): string | null {
+	let dir = process.cwd();
+	while (true) {
+		const gitPath = join(dir, ".git");
+		if (existsSync(gitPath)) {
+			try {
+				const stat = statSync(gitPath);
+				if (stat.isFile()) {
+					const content = readFileSync(gitPath, "utf8").trim();
+					if (content.startsWith("gitdir: ")) {
+						const gitDir = content.slice(8);
+						const headPath = resolve(dir, gitDir, "HEAD");
+						if (existsSync(headPath)) return headPath;
+					}
+				} else if (stat.isDirectory()) {
+					const headPath = join(gitPath, "HEAD");
+					if (existsSync(headPath)) return headPath;
+				}
+			} catch {
+				return null;
+			}
+		}
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+
+/**
+ * Provides git branch and extension statuses - data not otherwise accessible to extensions.
+ * Token stats, model info available via ctx.sessionManager and ctx.model.
+ */
+export class FooterDataProvider {
+	private extensionStatuses = new Map<string, string>();
+	private cachedBranch: string | null | undefined = undefined;
+	private gitWatcher: FSWatcher | null = null;
+	private branchChangeCallbacks = new Set<() => void>();
+	private availableProviderCount = 0;
+
+	constructor() {
+		this.setupGitWatcher();
+	}
+
+	/** Current git branch, null if not in repo, "detached" if detached HEAD */
+	getGitBranch(): string | null {
+		if (this.cachedBranch !== undefined) return this.cachedBranch;
+
+		try {
+			const gitHeadPath = findGitHeadPath();
+			if (!gitHeadPath) {
+				this.cachedBranch = null;
+				return null;
+			}
+			const content = readFileSync(gitHeadPath, "utf8").trim();
+			this.cachedBranch = content.startsWith("ref: refs/heads/") ? content.slice(16) : "detached";
+		} catch {
+			this.cachedBranch = null;
+		}
+		return this.cachedBranch;
+	}
+
+	/** Extension status texts set via ctx.ui.setStatus() */
+	getExtensionStatuses(): ReadonlyMap<string, string> {
+		return this.extensionStatuses;
+	}
+
+	/** Subscribe to git branch changes. Returns unsubscribe function. */
+	onBranchChange(callback: () => void): () => void {
+		this.branchChangeCallbacks.add(callback);
+		return () => this.branchChangeCallbacks.delete(callback);
+	}
+
+	/** Internal: set extension status */
+	setExtensionStatus(key: string, text: string | undefined): void {
+		if (text === undefined) {
+			this.extensionStatuses.delete(key);
+		} else {
+			this.extensionStatuses.set(key, text);
+		}
+	}
+
+	/** Internal: clear extension statuses */
+	clearExtensionStatuses(): void {
+		this.extensionStatuses.clear();
+	}
+
+	/** Number of unique providers with available models (for footer display) */
+	getAvailableProviderCount(): number {
+		return this.availableProviderCount;
+	}
+
+	/** Internal: update available provider count */
+	setAvailableProviderCount(count: number): void {
+		this.availableProviderCount = count;
+	}
+
+	/** Internal: cleanup */
+	dispose(): void {
+		if (this.gitWatcher) {
+			this.gitWatcher.close();
+			this.gitWatcher = null;
+		}
+		this.branchChangeCallbacks.clear();
+	}
+
+	private setupGitWatcher(): void {
+		if (this.gitWatcher) {
+			this.gitWatcher.close();
+			this.gitWatcher = null;
+		}
+
+		const gitHeadPath = findGitHeadPath();
+		if (!gitHeadPath) return;
+
+		// Watch the directory containing HEAD, not HEAD itself.
+		// Git uses atomic writes (write temp, rename over HEAD), which changes the inode.
+		// fs.watch on a file stops working after the inode changes.
+		const gitDir = dirname(gitHeadPath);
+
+		try {
+			this.gitWatcher = watch(gitDir, (_eventType, filename) => {
+				if (filename === "HEAD") {
+					this.cachedBranch = undefined;
+					for (const cb of this.branchChangeCallbacks) cb();
+				}
+			});
+		} catch {
+			// Silently fail if we can't watch
+		}
+	}
+}
+
+/** Read-only view for extensions - excludes setExtensionStatus, setAvailableProviderCount and dispose */
+export type ReadonlyFooterDataProvider = Pick<
+	FooterDataProvider,
+	"getGitBranch" | "getExtensionStatuses" | "getAvailableProviderCount" | "onBranchChange"
+>;

package/packages/pi-coding-agent/src/core/index.ts

@@ -0,0 +1,61 @@
+/**
+ * Core modules shared between all run modes.
+ */
+
+export {
+	AgentSession,
+	type AgentSessionConfig,
+	type AgentSessionEvent,
+	type AgentSessionEventListener,
+	type ModelCycleResult,
+	type PromptOptions,
+	type SessionStats,
+} from "./agent-session.js";
+export { type BashExecutorOptions, type BashResult, executeBash, executeBashWithOperations } from "./bash-executor.js";
+export type { CompactionResult } from "./compaction/index.js";
+export { createEventBus, type EventBus, type EventBusController } from "./event-bus.js";
+
+// Extensions system
+export {
+	type AgentEndEvent,
+	type AgentStartEvent,
+	type AgentToolResult,
+	type AgentToolUpdateCallback,
+	type BeforeAgentStartEvent,
+	type ContextEvent,
+	discoverAndLoadExtensions,
+	type ExecOptions,
+	type ExecResult,
+	type Extension,
+	type ExtensionAPI,
+	type ExtensionCommandContext,
+	type ExtensionContext,
+	type ExtensionError,
+	type ExtensionEvent,
+	type ExtensionFactory,
+	type ExtensionFlag,
+	type ExtensionHandler,
+	ExtensionRunner,
+	type ExtensionShortcut,
+	type ExtensionUIContext,
+	type LoadExtensionsResult,
+	type MessageRenderer,
+	type RegisteredCommand,
+	type SessionBeforeCompactEvent,
+	type SessionBeforeForkEvent,
+	type SessionBeforeSwitchEvent,
+	type SessionBeforeTreeEvent,
+	type SessionCompactEvent,
+	type SessionForkEvent,
+	type SessionShutdownEvent,
+	type SessionStartEvent,
+	type SessionSwitchEvent,
+	type SessionTreeEvent,
+	type ToolCallEvent,
+	type ToolDefinition,
+	type ToolRenderResultOptions,
+	type ToolResultEvent,
+	type TurnEndEvent,
+	type TurnStartEvent,
+	wrapToolsWithExtensions,
+} from "./extensions/index.js";

package/packages/pi-coding-agent/src/core/keybindings.ts

@@ -0,0 +1,211 @@
+import {
+	DEFAULT_EDITOR_KEYBINDINGS,
+	type EditorAction,
+	type EditorKeybindingsConfig,
+	EditorKeybindingsManager,
+	type KeyId,
+	matchesKey,
+	setEditorKeybindings,
+} from "@gsd/pi-tui";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { getAgentDir } from "../config.js";
+
+/**
+ * Application-level actions (coding agent specific).
+ */
+export type AppAction =
+	| "interrupt"
+	| "clear"
+	| "exit"
+	| "suspend"
+	| "cycleThinkingLevel"
+	| "cycleModelForward"
+	| "cycleModelBackward"
+	| "selectModel"
+	| "expandTools"
+	| "toggleThinking"
+	| "toggleSessionNamedFilter"
+	| "externalEditor"
+	| "followUp"
+	| "dequeue"
+	| "pasteImage"
+	| "newSession"
+	| "tree"
+	| "fork"
+	| "resume";
+
+/**
+ * All configurable actions.
+ */
+export type KeyAction = AppAction | EditorAction;
+
+/**
+ * Full keybindings configuration (app + editor actions).
+ */
+export type KeybindingsConfig = {
+	[K in KeyAction]?: KeyId | KeyId[];
+};
+
+/**
+ * Default application keybindings.
+ */
+export const DEFAULT_APP_KEYBINDINGS: Record<AppAction, KeyId | KeyId[]> = {
+	interrupt: "escape",
+	clear: "ctrl+c",
+	exit: "ctrl+d",
+	suspend: "ctrl+z",
+	cycleThinkingLevel: "shift+tab",
+	cycleModelForward: "ctrl+p",
+	cycleModelBackward: "shift+ctrl+p",
+	selectModel: "ctrl+l",
+	expandTools: "ctrl+o",
+	toggleThinking: "ctrl+t",
+	toggleSessionNamedFilter: "ctrl+n",
+	externalEditor: "ctrl+g",
+	followUp: "alt+enter",
+	dequeue: "alt+up",
+	pasteImage: process.platform === "win32" ? "alt+v" : "ctrl+v",
+	newSession: [],
+	tree: [],
+	fork: [],
+	resume: [],
+};
+
+/**
+ * All default keybindings (app + editor).
+ */
+export const DEFAULT_KEYBINDINGS: Required<KeybindingsConfig> = {
+	...DEFAULT_EDITOR_KEYBINDINGS,
+	...DEFAULT_APP_KEYBINDINGS,
+};
+
+// App actions list for type checking
+const APP_ACTIONS: AppAction[] = [
+	"interrupt",
+	"clear",
+	"exit",
+	"suspend",
+	"cycleThinkingLevel",
+	"cycleModelForward",
+	"cycleModelBackward",
+	"selectModel",
+	"expandTools",
+	"toggleThinking",
+	"toggleSessionNamedFilter",
+	"externalEditor",
+	"followUp",
+	"dequeue",
+	"pasteImage",
+	"newSession",
+	"tree",
+	"fork",
+	"resume",
+];
+
+function isAppAction(action: string): action is AppAction {
+	return APP_ACTIONS.includes(action as AppAction);
+}
+
+/**
+ * Manages all keybindings (app + editor).
+ */
+export class KeybindingsManager {
+	private config: KeybindingsConfig;
+	private appActionToKeys: Map<AppAction, KeyId[]>;
+
+	private constructor(config: KeybindingsConfig) {
+		this.config = config;
+		this.appActionToKeys = new Map();
+		this.buildMaps();
+	}
+
+	/**
+	 * Create from config file and set up editor keybindings.
+	 */
+	static create(agentDir: string = getAgentDir()): KeybindingsManager {
+		const configPath = join(agentDir, "keybindings.json");
+		const config = KeybindingsManager.loadFromFile(configPath);
+		const manager = new KeybindingsManager(config);
+
+		// Set up editor keybindings globally
+		// Include both editor actions and expandTools (shared between app and editor)
+		const editorConfig: EditorKeybindingsConfig = {};
+		for (const [action, keys] of Object.entries(config)) {
+			if (!isAppAction(action) || action === "expandTools") {
+				editorConfig[action as EditorAction] = keys;
+			}
+		}
+		setEditorKeybindings(new EditorKeybindingsManager(editorConfig));
+
+		return manager;
+	}
+
+	/**
+	 * Create in-memory.
+	 */
+	static inMemory(config: KeybindingsConfig = {}): KeybindingsManager {
+		return new KeybindingsManager(config);
+	}
+
+	private static loadFromFile(path: string): KeybindingsConfig {
+		if (!existsSync(path)) return {};
+		try {
+			return JSON.parse(readFileSync(path, "utf-8"));
+		} catch {
+			return {};
+		}
+	}
+
+	private buildMaps(): void {
+		this.appActionToKeys.clear();
+
+		// Set defaults for app actions
+		for (const [action, keys] of Object.entries(DEFAULT_APP_KEYBINDINGS)) {
+			const keyArray = Array.isArray(keys) ? keys : [keys];
+			this.appActionToKeys.set(action as AppAction, [...keyArray]);
+		}
+
+		// Override with user config (app actions only)
+		for (const [action, keys] of Object.entries(this.config)) {
+			if (keys === undefined || !isAppAction(action)) continue;
+			const keyArray = Array.isArray(keys) ? keys : [keys];
+			this.appActionToKeys.set(action, keyArray);
+		}
+	}
+
+	/**
+	 * Check if input matches an app action.
+	 */
+	matches(data: string, action: AppAction): boolean {
+		const keys = this.appActionToKeys.get(action);
+		if (!keys) return false;
+		for (const key of keys) {
+			if (matchesKey(data, key)) return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Get keys bound to an app action.
+	 */
+	getKeys(action: AppAction): KeyId[] {
+		return this.appActionToKeys.get(action) ?? [];
+	}
+
+	/**
+	 * Get the full effective config.
+	 */
+	getEffectiveConfig(): Required<KeybindingsConfig> {
+		const result = { ...DEFAULT_KEYBINDINGS };
+		for (const [action, keys] of Object.entries(this.config)) {
+			if (keys !== undefined) {
+				(result as KeybindingsConfig)[action as KeyAction] = keys;
+			}
+		}
+		return result;
+	}
+}
+
+// Re-export for convenience
+export type { EditorAction, KeyId };