@greppleai/grip 0.0.0-stage → 0.0.1

package/dist/core/extensions/loader.js

@@ -0,0 +1,613 @@
+/**
+ * Extension loader - loads TypeScript extension modules using jiti.
+ *
+ */
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as _bundledGripAgentCore from "@greppleai/grip-agent-core";
+import * as _bundledGripAi from "@greppleai/grip-ai";
+import * as _bundledGripAiOauth from "@greppleai/grip-ai/oauth";
+import * as _bundledGripTui from "@greppleai/grip-tui";
+import { createJiti } from "jiti/static";
+// Static imports of packages that extensions may use.
+// These MUST be static so Bun bundles them into the compiled binary.
+// The virtualModules option then makes them available to extensions.
+import * as _bundledTypebox from "typebox";
+import * as _bundledTypeboxCompile from "typebox/compile";
+import * as _bundledTypeboxValue from "typebox/value";
+import { CONFIG_DIR_NAME, getAgentDir, isBunBinary } from "../../config.js";
+// NOTE: This import works because loader.ts exports are NOT re-exported from index.ts,
+// avoiding a circular dependency. Extensions can import from @greppleai/grip.
+import * as _bundledGripCodingAgent from "../../index.js";
+import { parseFrontmatter } from "../../utils/frontmatter.js";
+import { resolvePath } from "../../utils/paths.js";
+import { createEventBus } from "../event-bus.js";
+import { execCommand } from "../exec.js";
+import { readGripManifest } from "../grip-manifest.js";
+import { createSyntheticSourceInfo } from "../source-info.js";
+import { time } from "../timings.js";
+/** Modules available to extensions via virtualModules (for compiled Bun binary) */
+const VIRTUAL_MODULES = {
+    typebox: _bundledTypebox,
+    "typebox/compile": _bundledTypeboxCompile,
+    "typebox/value": _bundledTypeboxValue,
+    "@sinclair/typebox": _bundledTypebox,
+    "@sinclair/typebox/compile": _bundledTypeboxCompile,
+    "@sinclair/typebox/value": _bundledTypeboxValue,
+    "@greppleai/grip-agent-core": _bundledGripAgentCore,
+    "@greppleai/grip-tui": _bundledGripTui,
+    "@greppleai/grip-ai": _bundledGripAi,
+    "@greppleai/grip-ai/oauth": _bundledGripAiOauth,
+    "@greppleai/grip": _bundledGripCodingAgent,
+    "@greppleai/grip-coding-agent": _bundledGripCodingAgent, // Pre-release extension compatibility.
+};
+const require = createRequire(import.meta.url);
+/**
+ * Get aliases for jiti (used in Node.js/development mode).
+ * In Bun binary mode, virtualModules is used instead.
+ */
+let _aliases = null;
+function getAliases() {
+    if (_aliases)
+        return _aliases;
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(__dirname, "../..");
+    const packageIndexTs = path.join(packageRoot, "index.ts");
+    const packageIndexJs = path.join(packageRoot, "index.js");
+    const packageIndex = fs.existsSync(packageIndexTs) ? packageIndexTs : packageIndexJs;
+    const typeboxEntry = require.resolve("typebox");
+    const typeboxCompileEntry = require.resolve("typebox/compile");
+    const typeboxValueEntry = require.resolve("typebox/value");
+    const packagesRoot = path.resolve(__dirname, "../../../../");
+    const resolveWorkspaceOrImport = (workspaceRelativePath, specifier) => {
+        const workspacePath = path.join(packagesRoot, workspaceRelativePath);
+        if (fs.existsSync(workspacePath)) {
+            return workspacePath;
+        }
+        return fileURLToPath(import.meta.resolve(specifier));
+    };
+    const gripCodingAgentEntry = packageIndex;
+    const gripAgentCoreEntry = resolveWorkspaceOrImport("agent/dist/index.js", "@greppleai/grip-agent-core");
+    const gripTuiEntry = resolveWorkspaceOrImport("tui/dist/index.js", "@greppleai/grip-tui");
+    const gripAiEntry = resolveWorkspaceOrImport("ai/dist/index.js", "@greppleai/grip-ai");
+    const gripAiOauthEntry = resolveWorkspaceOrImport("ai/dist/oauth.js", "@greppleai/grip-ai/oauth");
+    _aliases = {
+        "@greppleai/grip": gripCodingAgentEntry,
+        "@greppleai/grip-coding-agent": gripCodingAgentEntry, // Pre-release extension compatibility.
+        "@greppleai/grip-agent-core": gripAgentCoreEntry,
+        "@greppleai/grip-tui": gripTuiEntry,
+        "@greppleai/grip-ai": gripAiEntry,
+        "@greppleai/grip-ai/oauth": gripAiOauthEntry,
+        typebox: typeboxEntry,
+        "typebox/compile": typeboxCompileEntry,
+        "typebox/value": typeboxValueEntry,
+        "@sinclair/typebox": typeboxEntry,
+        "@sinclair/typebox/compile": typeboxCompileEntry,
+        "@sinclair/typebox/value": typeboxValueEntry,
+    };
+    return _aliases;
+}
+/**
+ * Create a runtime with throwing stubs for action methods.
+ * Runner.bindCore() replaces these with real implementations.
+ */
+export function createExtensionRuntime() {
+    const notInitialized = () => {
+        throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+    };
+    const state = {};
+    const eventBusUnsubscribers = new Set();
+    const assertActive = () => {
+        if (state.staleMessage) {
+            throw new Error(state.staleMessage);
+        }
+    };
+    const runtime = {
+        sendMessage: notInitialized,
+        sendUserMessage: notInitialized,
+        appendEntry: notInitialized,
+        setSessionName: notInitialized,
+        getSessionName: notInitialized,
+        setLabel: notInitialized,
+        getActiveTools: notInitialized,
+        getAllTools: notInitialized,
+        getAvailableTools: notInitialized,
+        setActiveTools: notInitialized,
+        unregisterTool: notInitialized,
+        loadTool: notInitialized,
+        unloadTool: notInitialized,
+        // registerTool() is valid during extension load; refresh is only needed post-bind.
+        refreshTools: () => { },
+        getCommands: notInitialized,
+        setModel: () => Promise.reject(new Error("Extension runtime not initialized")),
+        getThinkingLevel: notInitialized,
+        setThinkingLevel: notInitialized,
+        flagValues: new Map(),
+        pendingProviderRegistrations: [],
+        assertActive,
+        invalidate: (message) => {
+            if (state.staleMessage)
+                return;
+            state.staleMessage =
+                message ??
+                    "This extension ctx is stale after session replacement or reload. Do not use a captured extension API or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
+            for (const unsubscribe of eventBusUnsubscribers)
+                unsubscribe();
+            eventBusUnsubscribers.clear();
+        },
+        trackEventBusSubscription: (unsubscribe) => {
+            let active = true;
+            const trackedUnsubscribe = () => {
+                if (!active)
+                    return;
+                active = false;
+                eventBusUnsubscribers.delete(trackedUnsubscribe);
+                unsubscribe();
+            };
+            eventBusUnsubscribers.add(trackedUnsubscribe);
+            return trackedUnsubscribe;
+        },
+        // Pre-bind: queue registrations so bindCore() can flush them once the
+        // model registry is available. bindCore() replaces both with direct calls.
+        registerProvider: (name, config, extensionPath = "<unknown>") => {
+            runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
+        },
+        unregisterProvider: (name) => {
+            runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter((r) => r.name !== name);
+        },
+    };
+    return runtime;
+}
+/**
+ * Create the ExtensionAPI for an extension.
+ * Registration methods write to the extension object.
+ * Action methods delegate to the shared runtime.
+ */
+function createExtensionAPI(extension, runtime, cwd, eventBus) {
+    const extensionDir = path.dirname(extension.resolvedPath);
+    const resolveLocalPath = (filePath) => path.isAbsolute(filePath) ? filePath : path.resolve(extensionDir, filePath);
+    const resolveInstructionPath = (instruction, kind) => {
+        if (instruction.filePath) {
+            return resolveLocalPath(instruction.filePath);
+        }
+        return `<extension:${extension.path}:${kind}:${instruction.name}>`;
+    };
+    const getPromptBodyDescription = (body) => {
+        const firstLine = body.split("\n").find((line) => line.trim());
+        if (!firstLine)
+            return "";
+        return firstLine.length > 60 ? `${firstLine.slice(0, 60)}...` : firstLine;
+    };
+    const resolvePromptRegistration = (prompt) => {
+        if (!prompt.filePath && prompt.content === undefined) {
+            throw new Error(`registerPrompt("${prompt.name}") requires filePath or content`);
+        }
+        const filePath = prompt.filePath
+            ? resolveLocalPath(prompt.filePath)
+            : `<extension:${extension.path}:prompt:${prompt.name}>`;
+        let content = prompt.content;
+        let description = prompt.description;
+        let argumentHint = prompt.argumentHint;
+        if (content === undefined) {
+            const rawContent = fs.readFileSync(filePath, "utf-8");
+            const parsed = parseFrontmatter(rawContent);
+            content = parsed.body;
+            description = description ?? parsed.frontmatter.description ?? getPromptBodyDescription(parsed.body);
+            argumentHint = argumentHint ?? parsed.frontmatter["argument-hint"];
+        }
+        return {
+            name: prompt.name,
+            description: description ?? "",
+            ...(argumentHint && { argumentHint }),
+            content,
+            sourceInfo: extension.sourceInfo,
+            filePath,
+        };
+    };
+    const api = {
+        // Registration methods - write to extension
+        on(event, handler) {
+            runtime.assertActive();
+            const list = extension.handlers.get(event) ?? [];
+            list.push(handler);
+            extension.handlers.set(event, list);
+        },
+        registerTool(tool, options) {
+            runtime.assertActive();
+            extension.tools.set(tool.name, {
+                definition: tool,
+                sourceInfo: extension.sourceInfo,
+                lazy: options?.lazy === true,
+                loaded: options?.lazy === true ? false : undefined,
+            });
+            runtime.refreshTools();
+        },
+        unregisterTool(name) {
+            runtime.assertActive();
+            const deleted = extension.tools.delete(name);
+            if (deleted) {
+                runtime.refreshTools();
+            }
+            return deleted;
+        },
+        loadTool(name) {
+            runtime.assertActive();
+            return runtime.loadTool(name);
+        },
+        unloadTool(name) {
+            runtime.assertActive();
+            return runtime.unloadTool(name);
+        },
+        getAvailableTools() {
+            runtime.assertActive();
+            return runtime.getAvailableTools();
+        },
+        registerCommand(name, options) {
+            runtime.assertActive();
+            extension.commands.set(name, {
+                name,
+                sourceInfo: extension.sourceInfo,
+                ...options,
+            });
+        },
+        registerSkill(skill) {
+            runtime.assertActive();
+            if (!skill.filePath && !skill.content) {
+                throw new Error(`registerSkill("${skill.name}") requires filePath or content`);
+            }
+            const filePath = resolveInstructionPath(skill, "skill");
+            extension.skills.set(skill.name, {
+                name: skill.name,
+                description: skill.description,
+                filePath,
+                baseDir: skill.baseDir ?? (skill.filePath ? path.dirname(filePath) : extensionDir),
+                sourceInfo: extension.sourceInfo,
+                disableModelInvocation: skill.disableModelInvocation ?? false,
+                tools: skill.tools ?? [],
+                ...(skill.content !== undefined && { content: skill.content }),
+            });
+        },
+        registerRule(rule) {
+            runtime.assertActive();
+            if (!rule.filePath && !rule.content) {
+                throw new Error(`registerRule("${rule.name}") requires filePath or content`);
+            }
+            const filePath = resolveInstructionPath(rule, "rule");
+            extension.rules.set(rule.name, {
+                name: rule.name,
+                description: rule.description,
+                filePath,
+                baseDir: rule.baseDir ?? (rule.filePath ? path.dirname(filePath) : extensionDir),
+                sourceInfo: extension.sourceInfo,
+                disableModelInvocation: rule.disableModelInvocation ?? false,
+                tools: rule.tools ?? [],
+                ...(rule.content !== undefined && { content: rule.content }),
+            });
+        },
+        registerPrompt(prompt) {
+            runtime.assertActive();
+            extension.prompts.set(prompt.name, resolvePromptRegistration(prompt));
+        },
+        registerPrompts(prompts) {
+            runtime.assertActive();
+            for (const prompt of prompts) {
+                extension.prompts.set(prompt.name, resolvePromptRegistration(prompt));
+            }
+        },
+        registerShortcut(shortcut, options) {
+            runtime.assertActive();
+            extension.shortcuts.set(shortcut, { shortcut, extensionPath: extension.path, ...options });
+        },
+        registerFlag(name, options) {
+            runtime.assertActive();
+            extension.flags.set(name, { name, extensionPath: extension.path, ...options });
+            if (options.default !== undefined && !runtime.flagValues.has(name)) {
+                runtime.flagValues.set(name, options.default);
+            }
+        },
+        registerMessageRenderer(customType, renderer) {
+            runtime.assertActive();
+            extension.messageRenderers.set(customType, renderer);
+        },
+        registerMarkdownTransformer(transformer) {
+            runtime.assertActive();
+            extension.markdownTransformer = transformer;
+        },
+        // Flag access - checks extension registered it, reads from runtime
+        getFlag(name) {
+            runtime.assertActive();
+            if (!extension.flags.has(name))
+                return undefined;
+            return runtime.flagValues.get(name);
+        },
+        // Action methods - delegate to shared runtime
+        sendMessage(message, options) {
+            runtime.assertActive();
+            runtime.sendMessage(message, options);
+        },
+        sendUserMessage(content, options) {
+            runtime.assertActive();
+            runtime.sendUserMessage(content, options);
+        },
+        appendEntry(customType, data) {
+            runtime.assertActive();
+            runtime.appendEntry(customType, data);
+        },
+        setSessionName(name) {
+            runtime.assertActive();
+            runtime.setSessionName(name);
+        },
+        getSessionName() {
+            runtime.assertActive();
+            return runtime.getSessionName();
+        },
+        setLabel(entryId, label) {
+            runtime.assertActive();
+            runtime.setLabel(entryId, label);
+        },
+        exec(command, args, options) {
+            runtime.assertActive();
+            return execCommand(command, args, options?.cwd ?? cwd, options);
+        },
+        getActiveTools() {
+            runtime.assertActive();
+            return runtime.getActiveTools();
+        },
+        getAllTools() {
+            runtime.assertActive();
+            return runtime.getAllTools();
+        },
+        setActiveTools(toolNames) {
+            runtime.assertActive();
+            runtime.setActiveTools(toolNames);
+        },
+        getCommands() {
+            runtime.assertActive();
+            return runtime.getCommands();
+        },
+        setModel(model) {
+            runtime.assertActive();
+            return runtime.setModel(model);
+        },
+        getThinkingLevel() {
+            runtime.assertActive();
+            return runtime.getThinkingLevel();
+        },
+        setThinkingLevel(level) {
+            runtime.assertActive();
+            runtime.setThinkingLevel(level);
+        },
+        registerProvider(name, config) {
+            runtime.assertActive();
+            runtime.registerProvider(name, config, extension.path);
+        },
+        unregisterProvider(name) {
+            runtime.assertActive();
+            runtime.unregisterProvider(name, extension.path);
+        },
+        events: {
+            emit(channel, data) {
+                runtime.assertActive();
+                eventBus.emit(channel, data);
+            },
+            on(channel, handler) {
+                runtime.assertActive();
+                return runtime.trackEventBusSubscription(eventBus.on(channel, handler));
+            },
+        },
+    };
+    return api;
+}
+async function loadExtensionModule(extensionPath) {
+    const jiti = createJiti(import.meta.url, {
+        moduleCache: false,
+        // In Bun binary: use virtualModules for bundled packages (no filesystem resolution)
+        // Also disable tryNative so jiti handles ALL imports (not just the entry point)
+        // In Node.js/dev: use aliases to resolve to node_modules paths
+        ...(isBunBinary ? { virtualModules: VIRTUAL_MODULES, tryNative: false } : { alias: getAliases() }),
+    });
+    const module = await jiti.import(extensionPath, { default: true });
+    const factory = module;
+    return typeof factory !== "function" ? undefined : factory;
+}
+/**
+ * Create an Extension object with empty collections.
+ */
+function createExtension(extensionPath, resolvedPath) {
+    const source = extensionPath.startsWith("<") && extensionPath.endsWith(">")
+        ? extensionPath.slice(1, -1).split(":")[0] || "temporary"
+        : "local";
+    const baseDir = extensionPath.startsWith("<") ? undefined : path.dirname(resolvedPath);
+    return {
+        path: extensionPath,
+        resolvedPath,
+        sourceInfo: createSyntheticSourceInfo(extensionPath, { source, baseDir }),
+        handlers: new Map(),
+        tools: new Map(),
+        messageRenderers: new Map(),
+        commands: new Map(),
+        skills: new Map(),
+        rules: new Map(),
+        prompts: new Map(),
+        flags: new Map(),
+        shortcuts: new Map(),
+    };
+}
+async function loadExtension(extensionPath, cwd, eventBus, runtime) {
+    const resolvedPath = resolvePath(extensionPath, cwd, { normalizeUnicodeSpaces: true });
+    try {
+        const factory = await loadExtensionModule(resolvedPath);
+        time(`${extensionPath} module import`, "extensions");
+        if (!factory) {
+            return { extension: null, error: `Extension does not export a valid factory function: ${extensionPath}` };
+        }
+        const extension = createExtension(extensionPath, resolvedPath);
+        const api = createExtensionAPI(extension, runtime, cwd, eventBus);
+        await factory(api);
+        time(`${extensionPath} factory`, "extensions");
+        return { extension, error: null };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { extension: null, error: `Failed to load extension: ${message}` };
+    }
+}
+/**
+ * Create an Extension from an inline factory function.
+ */
+export async function loadExtensionFromFactory(factory, cwd, eventBus, runtime, extensionPath = "<inline>") {
+    const extension = createExtension(extensionPath, extensionPath);
+    const resolvedCwd = resolvePath(cwd);
+    const api = createExtensionAPI(extension, runtime, resolvedCwd, eventBus);
+    await factory(api);
+    time(`${extensionPath} factory`, "extensions");
+    return extension;
+}
+/**
+ * Load extensions from paths.
+ */
+export async function loadExtensions(paths, cwd, eventBus) {
+    const extensions = [];
+    const errors = [];
+    const resolvedCwd = resolvePath(cwd);
+    const resolvedEventBus = eventBus ?? createEventBus();
+    const runtime = createExtensionRuntime();
+    for (const extPath of paths) {
+        const { extension, error } = await loadExtension(extPath, resolvedCwd, resolvedEventBus, runtime);
+        if (error) {
+            errors.push({ path: extPath, error });
+            continue;
+        }
+        if (extension) {
+            extensions.push(extension);
+        }
+    }
+    return {
+        extensions,
+        errors,
+        runtime,
+    };
+}
+function isExtensionFile(name) {
+    return name.endsWith(".ts") || name.endsWith(".js");
+}
+/**
+ * Resolve extension entry points from a directory.
+ *
+ * Checks for:
+ * 1. package.json with "grip.extensions" field -> returns declared paths
+ * 2. index.ts or index.js -> returns the index file
+ *
+ * Returns resolved paths or null if no entry points found.
+ */
+function resolveExtensionEntries(dir) {
+    // Check for package.json with "grip" field first
+    const packageJsonPath = path.join(dir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+        const manifest = readGripManifest(packageJsonPath);
+        if (manifest?.extensions?.length) {
+            const entries = [];
+            for (const extPath of manifest.extensions) {
+                const resolvedExtPath = path.resolve(dir, extPath);
+                if (fs.existsSync(resolvedExtPath)) {
+                    entries.push(resolvedExtPath);
+                }
+            }
+            if (entries.length > 0) {
+                return entries;
+            }
+        }
+    }
+    // Check for index.ts or index.js
+    const indexTs = path.join(dir, "index.ts");
+    const indexJs = path.join(dir, "index.ts");
+    if (fs.existsSync(indexTs)) {
+        return [indexTs];
+    }
+    if (fs.existsSync(indexJs)) {
+        return [indexJs];
+    }
+    return null;
+}
+/**
+ * Discover extensions in a directory.
+ *
+ * Discovery rules:
+ * 1. Direct files: `extensions/*.ts` or `*.js` → load
+ * 2. Subdirectory with index: `extensions/* /index.ts` or `index.js` → load
+ * 3. Subdirectory with package.json: `extensions/* /package.json` with "grip" field → load what it declares
+ *
+ * No recursion beyond one level. Complex packages must use package.json manifest.
+ */
+function discoverExtensionsInDir(dir) {
+    if (!fs.existsSync(dir)) {
+        return [];
+    }
+    const discovered = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path.join(dir, entry.name);
+            // 1. Direct files: *.ts or *.js
+            if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
+                discovered.push(entryPath);
+                continue;
+            }
+            // 2 & 3. Subdirectories
+            if (entry.isDirectory() || entry.isSymbolicLink()) {
+                const entries = resolveExtensionEntries(entryPath);
+                if (entries) {
+                    discovered.push(...entries);
+                }
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return discovered;
+}
+/**
+ * Discover and load extensions from standard locations.
+ */
+export async function discoverAndLoadExtensions(configuredPaths, cwd, agentDir = getAgentDir(), eventBus) {
+    const resolvedCwd = resolvePath(cwd);
+    const resolvedAgentDir = resolvePath(agentDir);
+    const allPaths = [];
+    const seen = new Set();
+    const addPaths = (paths) => {
+        for (const p of paths) {
+            const resolved = path.resolve(p);
+            if (!seen.has(resolved)) {
+                seen.add(resolved);
+                allPaths.push(p);
+            }
+        }
+    };
+    // 1. Project-local extensions: cwd/${CONFIG_DIR_NAME}/extensions/
+    const localExtDir = path.join(resolvedCwd, CONFIG_DIR_NAME, "extensions");
+    addPaths(discoverExtensionsInDir(localExtDir));
+    // 2. Global extensions: agentDir/extensions/
+    const globalExtDir = path.join(resolvedAgentDir, "extensions");
+    addPaths(discoverExtensionsInDir(globalExtDir));
+    // 3. Explicitly configured paths
+    for (const p of configuredPaths) {
+        const resolved = resolvePath(p, resolvedCwd, { normalizeUnicodeSpaces: true });
+        if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+            // Check for package.json with grip manifest or index.ts
+            const entries = resolveExtensionEntries(resolved);
+            if (entries) {
+                addPaths(entries);
+                continue;
+            }
+            // No explicit entries - discover individual files in directory
+            addPaths(discoverExtensionsInDir(resolved));
+            continue;
+        }
+        addPaths([resolved]);
+    }
+    return loadExtensions(allPaths, resolvedCwd, eventBus);
+}
+//# sourceMappingURL=loader.js.map