@mariozechner/pi-coding-agent 0.34.1 → 0.35.0

package/dist/core/sdk.js

@@ -9,20 +9,11 @@
  * // Minimal - everything auto-discovered
  * const session = await createAgentSession();
  *
- * // With custom hooks
- * const session = await createAgentSession({
- *   hooks: [
- *     ...await discoverHooks(),
- *     { factory: myHookFactory },
- *   ],
- * });
- *
  * // Full control
  * const session = await createAgentSession({
  *   model: myModel,
  *   getApiKey: async () => process.env.MY_KEY,
  *   tools: [readTool, bashTool],
- *   hooks: [],
  *   skills: [],
  *   sessionFile: false,
  * });
@@ -33,14 +24,14 @@ import { join } from "path";
 import { getAgentDir } from "../config.js";
 import { AgentSession } from "./agent-session.js";
 import { AuthStorage } from "./auth-storage.js";
-import { discoverAndLoadCustomTools, wrapCustomTools, } from "./custom-tools/index.js";
-import { discoverAndLoadHooks, HookRunner, wrapToolsWithHooks } from "./hooks/index.js";
+import { createEventBus } from "./event-bus.js";
+import { discoverAndLoadExtensions, ExtensionRunner, loadExtensionFromFactory, wrapRegisteredTools, wrapToolsWithExtensions, } from "./extensions/index.js";
 import { convertToLlm } from "./messages.js";
 import { ModelRegistry } from "./model-registry.js";
+import { loadPromptTemplates as loadPromptTemplatesInternal } from "./prompt-templates.js";
 import { SessionManager } from "./session-manager.js";
 import { SettingsManager } from "./settings-manager.js";
 import { loadSkills as loadSkillsInternal } from "./skills.js";
-import { loadSlashCommands as loadSlashCommandsInternal } from "./slash-commands.js";
 import { buildSystemPrompt as buildSystemPromptInternal, loadProjectContextFiles as loadContextFilesInternal, } from "./system-prompt.js";
 import { time } from "./timings.js";
 import { allTools, bashTool, codingTools, createAllTools, createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, editTool, findTool, grepTool, lsTool, readOnlyTools, readTool, writeTool, } from "./tools/index.js";
@@ -67,36 +58,20 @@ export function discoverModels(authStorage, agentDir = getDefaultAgentDir()) {
     return new ModelRegistry(authStorage, join(agentDir, "models.json"));
 }
 /**
- * Discover hooks from cwd and agentDir.
+ * Discover extensions from cwd and agentDir.
+ * @param eventBus - Shared event bus for extension communication. Pass to createAgentSession too.
+ * @param cwd - Current working directory
+ * @param agentDir - Agent configuration directory
  */
-export async function discoverHooks(cwd, agentDir) {
+export async function discoverExtensions(eventBus, cwd, agentDir) {
     const resolvedCwd = cwd ?? process.cwd();
     const resolvedAgentDir = agentDir ?? getDefaultAgentDir();
-    const { hooks, errors } = await discoverAndLoadHooks([], resolvedCwd, resolvedAgentDir);
+    const result = await discoverAndLoadExtensions([], resolvedCwd, resolvedAgentDir, eventBus);
     // Log errors but don't fail
-    for (const { path, error } of errors) {
-        console.error(`Failed to load hook "${path}": ${error}`);
+    for (const { path, error } of result.errors) {
+        console.error(`Failed to load extension "${path}": ${error}`);
     }
-    return hooks.map((h) => ({
-        path: h.path,
-        factory: createFactoryFromLoadedHook(h),
-    }));
-}
-/**
- * Discover custom tools from cwd and agentDir.
- */
-export async function discoverCustomTools(cwd, agentDir) {
-    const resolvedCwd = cwd ?? process.cwd();
-    const resolvedAgentDir = agentDir ?? getDefaultAgentDir();
-    const { tools, errors } = await discoverAndLoadCustomTools([], resolvedCwd, Object.keys(allTools), resolvedAgentDir);
-    // Log errors but don't fail
-    for (const { path, error } of errors) {
-        console.error(`Failed to load custom tool "${path}": ${error}`);
-    }
-    return tools.map((t) => ({
-        path: t.path,
-        tool: t.tool,
-    }));
+    return result;
 }
 /**
  * Discover skills from cwd and agentDir.
@@ -119,10 +94,10 @@ export function discoverContextFiles(cwd, agentDir) {
     });
 }
 /**
- * Discover slash commands from cwd and agentDir.
+ * Discover prompt templates from cwd and agentDir.
  */
-export function discoverSlashCommands(cwd, agentDir) {
-    return loadSlashCommandsInternal({
+export function discoverPromptTemplates(cwd, agentDir) {
+    return loadPromptTemplatesInternal({
         cwd: cwd ?? process.cwd(),
         agentDir: agentDir ?? getDefaultAgentDir(),
     });
@@ -156,123 +131,11 @@ export function loadSettings(cwd, agentDir) {
         hideThinkingBlock: manager.getHideThinkingBlock(),
         shellPath: manager.getShellPath(),
         collapseChangelog: manager.getCollapseChangelog(),
-        hooks: manager.getHookPaths(),
-        customTools: manager.getCustomToolPaths(),
+        extensions: manager.getExtensionPaths(),
         skills: manager.getSkillsSettings(),
         terminal: { showImages: manager.getShowImages() },
     };
 }
-// Internal Helpers
-/**
- * Create a HookFactory from a LoadedHook.
- * This allows mixing discovered hooks with inline hooks.
- */
-function createFactoryFromLoadedHook(loaded) {
-    return (api) => {
-        for (const [eventType, handlers] of loaded.handlers) {
-            for (const handler of handlers) {
-                api.on(eventType, handler);
-            }
-        }
-    };
-}
-/**
- * Convert hook definitions to LoadedHooks for the HookRunner.
- */
-function createLoadedHooksFromDefinitions(definitions) {
-    return definitions.map((def) => {
-        const hookPath = def.path ?? "<inline>";
-        const handlers = new Map();
-        const messageRenderers = new Map();
-        const commands = new Map();
-        const flags = new Map();
-        const flagValues = new Map();
-        const shortcuts = new Map();
-        let sendMessageHandler = () => { };
-        let appendEntryHandler = () => { };
-        let getActiveToolsHandler = () => [];
-        let getAllToolsHandler = () => [];
-        let setActiveToolsHandler = () => { };
-        let newSessionHandler = async () => ({ cancelled: false });
-        let branchHandler = async () => ({ cancelled: false });
-        let navigateTreeHandler = async () => ({
-            cancelled: false,
-        });
-        const api = {
-            on: (event, handler) => {
-                const list = handlers.get(event) ?? [];
-                list.push(handler);
-                handlers.set(event, list);
-            },
-            sendMessage: (message, options) => {
-                sendMessageHandler(message, options);
-            },
-            appendEntry: (customType, data) => {
-                appendEntryHandler(customType, data);
-            },
-            registerMessageRenderer: (customType, renderer) => {
-                messageRenderers.set(customType, renderer);
-            },
-            registerCommand: (name, options) => {
-                commands.set(name, { name, ...options });
-            },
-            registerFlag: (name, options) => {
-                flags.set(name, { name, hookPath, ...options });
-                if (options.default !== undefined) {
-                    flagValues.set(name, options.default);
-                }
-            },
-            getFlag: (name) => flagValues.get(name),
-            registerShortcut: (shortcut, options) => {
-                shortcuts.set(shortcut, { shortcut, hookPath, ...options });
-            },
-            newSession: (options) => newSessionHandler(options),
-            branch: (entryId) => branchHandler(entryId),
-            navigateTree: (targetId, options) => navigateTreeHandler(targetId, options),
-            getActiveTools: () => getActiveToolsHandler(),
-            getAllTools: () => getAllToolsHandler(),
-            setActiveTools: (toolNames) => setActiveToolsHandler(toolNames),
-        };
-        def.factory(api);
-        return {
-            path: hookPath,
-            resolvedPath: hookPath,
-            handlers,
-            messageRenderers,
-            commands,
-            flags,
-            flagValues,
-            shortcuts,
-            setSendMessageHandler: (handler) => {
-                sendMessageHandler = handler;
-            },
-            setAppendEntryHandler: (handler) => {
-                appendEntryHandler = handler;
-            },
-            setNewSessionHandler: (handler) => {
-                newSessionHandler = handler;
-            },
-            setBranchHandler: (handler) => {
-                branchHandler = handler;
-            },
-            setNavigateTreeHandler: (handler) => {
-                navigateTreeHandler = handler;
-            },
-            setGetActiveToolsHandler: (handler) => {
-                getActiveToolsHandler = handler;
-            },
-            setGetAllToolsHandler: (handler) => {
-                getAllToolsHandler = handler;
-            },
-            setSetActiveToolsHandler: (handler) => {
-                setActiveToolsHandler = handler;
-            },
-            setFlagValue: (name, value) => {
-                flagValues.set(name, value);
-            },
-        };
-    });
-}
 // Factory
 /**
  * Create an AgentSession with the specified options.
@@ -300,7 +163,6 @@ function createLoadedHooksFromDefinitions(definitions) {
  *   getApiKey: async () => process.env.MY_KEY,
  *   systemPrompt: 'You are helpful.',
  *   tools: [readTool, bashTool],
- *   hooks: [],
  *   skills: [],
  *   sessionManager: SessionManager.inMemory(),
  * });
@@ -309,6 +171,7 @@ function createLoadedHooksFromDefinitions(definitions) {
 export async function createAgentSession(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const agentDir = options.agentDir ?? getDefaultAgentDir();
+    const eventBus = options.eventBus ?? createEventBus();
     // Use provided or create AuthStorage and ModelRegistry
     const authStorage = options.authStorage ?? discoverAuthStorage(agentDir);
     const modelRegistry = options.modelRegistry ?? discoverModels(authStorage, agentDir);
@@ -381,7 +244,7 @@ export async function createAgentSession(options = {}) {
     const contextFiles = options.contextFiles ?? discoverContextFiles(cwd, agentDir);
     time("discoverContextFiles");
     const autoResizeImages = settingsManager.getImageAutoResize();
-    // Create ALL built-in tools for the registry (hooks can enable any of them)
+    // Create ALL built-in tools for the registry (extensions can enable any of them)
     const allBuiltInToolsMap = createAllTools(cwd, { read: { autoResizeImages } });
     // Determine initially active built-in tools (default: read, bash, edit, write)
     const defaultActiveToolNames = ["read", "bash", "edit", "write"];
@@ -390,56 +253,94 @@ export async function createAgentSession(options = {}) {
         : defaultActiveToolNames;
     const initialActiveBuiltInTools = initialActiveToolNames.map((name) => allBuiltInToolsMap[name]);
     time("createAllTools");
-    let customToolsResult;
-    if (options.customTools !== undefined) {
-        // Use provided custom tools
-        const loadedTools = options.customTools.map((ct) => ({
-            path: ct.path ?? "<inline>",
-            resolvedPath: ct.path ?? "<inline>",
-            tool: ct.tool,
-        }));
-        customToolsResult = {
-            tools: loadedTools,
+    // Load extensions (discovers from standard locations + configured paths)
+    let extensionsResult;
+    if (options.preloadedExtensions !== undefined && options.preloadedExtensions.length > 0) {
+        // Use pre-loaded extensions (from early CLI flag discovery)
+        extensionsResult = {
+            extensions: options.preloadedExtensions,
             errors: [],
             setUIContext: () => { },
         };
     }
     else {
-        // Discover custom tools, merging with additional paths
-        const configuredPaths = [...settingsManager.getCustomToolPaths(), ...(options.additionalCustomToolPaths ?? [])];
-        customToolsResult = await discoverAndLoadCustomTools(configuredPaths, cwd, Object.keys(allTools), agentDir);
-        time("discoverAndLoadCustomTools");
-        for (const { path, error } of customToolsResult.errors) {
-            console.error(`Failed to load custom tool "${path}": ${error}`);
+        // Discover extensions, merging with additional paths
+        const configuredPaths = [...settingsManager.getExtensionPaths(), ...(options.additionalExtensionPaths ?? [])];
+        extensionsResult = await discoverAndLoadExtensions(configuredPaths, cwd, agentDir, eventBus);
+        time("discoverAndLoadExtensions");
+        for (const { path, error } of extensionsResult.errors) {
+            console.error(`Failed to load extension "${path}": ${error}`);
         }
     }
-    let hookRunner;
-    if (options.preloadedHooks !== undefined && options.preloadedHooks.length > 0) {
-        // Use pre-loaded hooks (from early CLI flag discovery)
-        hookRunner = new HookRunner(options.preloadedHooks, cwd, sessionManager, modelRegistry);
-    }
-    else if (options.hooks !== undefined) {
-        if (options.hooks.length > 0) {
-            const loadedHooks = createLoadedHooksFromDefinitions(options.hooks);
-            hookRunner = new HookRunner(loadedHooks, cwd, sessionManager, modelRegistry);
+    // Load inline extensions from factories
+    if (options.extensions && options.extensions.length > 0) {
+        // Create shared UI context holder that will be set later
+        const uiHolder = {
+            ui: {
+                select: async () => undefined,
+                confirm: async () => false,
+                input: async () => undefined,
+                notify: () => { },
+                setStatus: () => { },
+                setWidget: () => { },
+                setTitle: () => { },
+                custom: async () => undefined,
+                setEditorText: () => { },
+                getEditorText: () => "",
+                editor: async () => undefined,
+                get theme() {
+                    return {};
+                },
+            },
+            hasUI: false,
+        };
+        for (let i = 0; i < options.extensions.length; i++) {
+            const factory = options.extensions[i];
+            const loaded = loadExtensionFromFactory(factory, cwd, eventBus, uiHolder, `<inline-${i}>`);
+            extensionsResult.extensions.push(loaded);
         }
+        // Extend setUIContext to update inline extensions too
+        const originalSetUIContext = extensionsResult.setUIContext;
+        extensionsResult.setUIContext = (uiContext, hasUI) => {
+            originalSetUIContext(uiContext, hasUI);
+            uiHolder.ui = uiContext;
+            uiHolder.hasUI = hasUI;
+        };
     }
-    else {
-        // Discover hooks, merging with additional paths
-        const configuredPaths = [...settingsManager.getHookPaths(), ...(options.additionalHookPaths ?? [])];
-        const { hooks, errors } = await discoverAndLoadHooks(configuredPaths, cwd, agentDir);
-        time("discoverAndLoadHooks");
-        for (const { path, error } of errors) {
-            console.error(`Failed to load hook "${path}": ${error}`);
-        }
-        if (hooks.length > 0) {
-            hookRunner = new HookRunner(hooks, cwd, sessionManager, modelRegistry);
-        }
+    // Create extension runner if we have extensions
+    let extensionRunner;
+    if (extensionsResult.extensions.length > 0) {
+        extensionRunner = new ExtensionRunner(extensionsResult.extensions, cwd, sessionManager, modelRegistry);
     }
-    // Wrap custom tools with context getter (agent/session assigned below, accessed at execute time)
+    // Wrap extension-registered tools and SDK-provided custom tools with context getter
+    // (agent/session assigned below, accessed at execute time)
     let agent;
     let session;
-    const wrappedCustomTools = wrapCustomTools(customToolsResult.tools, () => ({
+    const registeredTools = extensionRunner?.getAllRegisteredTools() ?? [];
+    // Combine extension-registered tools with SDK-provided custom tools
+    const allCustomTools = [
+        ...registeredTools,
+        ...(options.customTools?.map((def) => ({ definition: def, extensionPath: "<sdk>" })) ?? []),
+    ];
+    const wrappedExtensionTools = wrapRegisteredTools(allCustomTools, () => ({
+        ui: extensionRunner?.getUIContext() ?? {
+            select: async () => undefined,
+            confirm: async () => false,
+            input: async () => undefined,
+            notify: () => { },
+            setStatus: () => { },
+            setWidget: () => { },
+            setTitle: () => { },
+            custom: async () => undefined,
+            setEditorText: () => { },
+            getEditorText: () => "",
+            editor: async () => undefined,
+            get theme() {
+                return {};
+            },
+        },
+        hasUI: extensionRunner?.getHasUI() ?? false,
+        cwd,
         sessionManager,
         modelRegistry,
         model: agent.state.model,
@@ -449,25 +350,25 @@ export async function createAgentSession(options = {}) {
             session.abort();
         },
     }));
-    // Create tool registry mapping name -> tool (for hook getTools/setTools)
-    // Registry contains ALL built-in tools so hooks can enable any of them
+    // Create tool registry mapping name -> tool (for extension getTools/setTools)
+    // Registry contains ALL built-in tools so extensions can enable any of them
     const toolRegistry = new Map();
     for (const [name, tool] of Object.entries(allBuiltInToolsMap)) {
         toolRegistry.set(name, tool);
     }
-    for (const tool of wrappedCustomTools) {
+    for (const tool of wrappedExtensionTools) {
         toolRegistry.set(tool.name, tool);
     }
-    // Initially active tools = active built-in + custom
-    let activeToolsArray = [...initialActiveBuiltInTools, ...wrappedCustomTools];
+    // Initially active tools = active built-in + extension tools
+    let activeToolsArray = [...initialActiveBuiltInTools, ...wrappedExtensionTools];
     time("combineTools");
-    // Wrap tools with hooks if available
+    // Wrap tools with extensions if available
     let wrappedToolRegistry;
-    if (hookRunner) {
-        activeToolsArray = wrapToolsWithHooks(activeToolsArray, hookRunner);
-        // Wrap ALL registry tools (not just active) so hooks can enable any
+    if (extensionRunner) {
+        activeToolsArray = wrapToolsWithExtensions(activeToolsArray, extensionRunner);
+        // Wrap ALL registry tools (not just active) so extensions can enable any
         const allRegistryTools = Array.from(toolRegistry.values());
-        const wrappedAllTools = wrapToolsWithHooks(allRegistryTools, hookRunner);
+        const wrappedAllTools = wrapToolsWithExtensions(allRegistryTools, extensionRunner);
         wrappedToolRegistry = new Map();
         for (const tool of wrappedAllTools) {
             wrappedToolRegistry.set(tool.name, tool);
@@ -504,8 +405,8 @@ export async function createAgentSession(options = {}) {
     };
     const systemPrompt = rebuildSystemPrompt(initialActiveToolNames);
     time("buildSystemPrompt");
-    const slashCommands = options.slashCommands ?? discoverSlashCommands(cwd, agentDir);
-    time("discoverSlashCommands");
+    const promptTemplates = options.promptTemplates ?? discoverPromptTemplates(cwd, agentDir);
+    time("discoverPromptTemplates");
     agent = new Agent({
         initialState: {
             systemPrompt,
@@ -514,9 +415,9 @@ export async function createAgentSession(options = {}) {
             tools: activeToolsArray,
         },
         convertToLlm,
-        transformContext: hookRunner
+        transformContext: extensionRunner
             ? async (messages) => {
-                return hookRunner.emitContext(messages);
+                return extensionRunner.emitContext(messages);
             }
             : undefined,
         steeringMode: settingsManager.getSteeringMode(),
@@ -550,9 +451,8 @@ export async function createAgentSession(options = {}) {
         sessionManager,
         settingsManager,
         scopedModels: options.scopedModels,
-        fileCommands: slashCommands,
-        hookRunner,
-        customTools: customToolsResult.tools,
+        promptTemplates: promptTemplates,
+        extensionRunner,
         skillsSettings: settingsManager.getSkillsSettings(),
         modelRegistry,
         toolRegistry: wrappedToolRegistry ?? toolRegistry,
@@ -561,7 +461,7 @@ export async function createAgentSession(options = {}) {
     time("createAgentSession");
     return {
         session,
-        customToolsResult,
+        extensionsResult,
         modelFallbackMessage,
     };
 }