mono-pilot 0.2.10 → 0.2.13

package/dist/src/extensions/lifecycle.js

@@ -0,0 +1,337 @@
+import { LSP } from "../lsp/index.js";
+import { deriveAgentId } from "../agents-paths.js";
+import { loadResolvedMemorySearchConfig } from "../memory/config/loader.js";
+import { initCluster, closeCluster } from "../cluster/init.js";
+import { getActiveClusterV2Service, initClusterV2, closeClusterV2, onClusterV2DiscordChannelBatch, onClusterV2LeaderOffline, onClusterV2LeaderRecovered, onClusterV2TwitterCollectorStartupFailed, onClusterV2TwitterPullBatch, onClusterV2TwitterPullFailed, } from "../cluster_v2/index.js";
+import { setMemoryWorkersEmbeddingProvider, closeMemorySearchManagers } from "../memory/runtime/index.js";
+import { warmMemorySearch } from "../memory/warm.js";
+import { setMailBoxHandle } from "./game/mailbox.js";
+import { publishSystemEvent } from "./system-events.js";
+let activeClusterVersion = null;
+/**
+ * Initialize all subsystems. Fire-and-forget from session_start.
+ */
+export async function initSubsystems(pi, ctx, options) {
+    const agentId = deriveAgentId(ctx.cwd);
+    const sessionManager = ctx.sessionManager;
+    const getSessionId = () => sessionManager?.getSessionId?.() ?? "unknown";
+    const disposers = [];
+    // 1. LSP
+    LSP.init(ctx.cwd);
+    // 2. Cluster + 3. Memory (cluster provides embedding for memory)
+    const settings = await loadResolvedMemorySearchConfig();
+    let cluster = null;
+    const useClusterV2 = process.env.MONO_PILOT_CLUSTER_VERSION === "2" || process.env.MONO_PILOT_CLUSTER_V2 === "1";
+    if (useClusterV2) {
+        disposers.push(onClusterV2DiscordChannelBatch((event) => {
+            publishDiscordChannelBatchSystemEvent(ctx, event);
+        }));
+        disposers.push(onClusterV2TwitterPullBatch((event) => {
+            publishTwitterPullBatchSystemEvent(ctx, event);
+        }));
+        disposers.push(onClusterV2TwitterPullFailed((event) => {
+            publishTwitterPullFailedSystemEvent(ctx, event);
+        }));
+        disposers.push(onClusterV2TwitterCollectorStartupFailed((event) => {
+            publishTwitterCollectorStartupFailedSystemEvent(ctx, event);
+        }));
+        disposers.push(onClusterV2LeaderOffline(() => {
+            publishSystemEvent({
+                source: "cluster",
+                level: "warning",
+                message: "Leader offline. Re-election in progress.",
+                dedupeKey: "cluster|leader_offline",
+                toast: false,
+                ctx,
+            });
+        }));
+        disposers.push(onClusterV2LeaderRecovered(() => {
+            refreshMemoryEmbeddingProviderFromActiveClusterV2();
+            void publishClusterV2LeaderRecoveredEvent(ctx);
+        }));
+    }
+    try {
+        if (settings.enabled && settings.provider === "local") {
+            if (useClusterV2) {
+                cluster = await initClusterV2({
+                    ...settings.local,
+                    agentId,
+                    displayName: options?.displayName,
+                    getSessionId,
+                });
+                activeClusterVersion = "v2";
+            }
+            else {
+                cluster = await initCluster({
+                    ...settings.local,
+                    agentId,
+                    displayName: options?.displayName,
+                    getSessionId,
+                });
+                activeClusterVersion = "v1";
+            }
+            setMemoryWorkersEmbeddingProvider(cluster.embedding);
+        }
+    }
+    catch (error) {
+        for (const dispose of [...disposers].reverse()) {
+            dispose();
+        }
+        throw error;
+    }
+    if (settings.enabled && settings.sync.onSessionStart) {
+        startMemoryWarmupInBackground(ctx, { workspaceDir: ctx.cwd, agentId });
+    }
+    // 4. Bus (message injection into agent conversation)
+    const bus = cluster?.bus ?? null;
+    if (bus) {
+        if (options?.busChannels && options.busChannels.length > 0) {
+            await bus.subscribe(options.busChannels);
+        }
+        const filter = options?.busMessageFilter;
+        const injector = options?.busMessageInjector ?? createDefaultBusMessageInjector(pi);
+        bus.onMessage((msg) => {
+            if (filter && !filter(msg))
+                return;
+            injector(msg);
+        });
+    }
+    setMailBoxHandle(bus ?? null);
+    const dispose = disposers.length > 0
+        ? () => {
+            for (const fn of [...disposers].reverse()) {
+                fn();
+            }
+        }
+        : undefined;
+    return { bus, dispose };
+}
+/**
+ * Shutdown all subsystems in reverse dependency order.
+ */
+export async function shutdownSubsystems(handles) {
+    try {
+        handles?.dispose?.();
+        // Bus
+        if (handles?.bus)
+            handles.bus.close();
+        setMailBoxHandle(null);
+        // Memory
+        await closeMemorySearchManagers();
+        // Cluster
+        if (activeClusterVersion === "v2") {
+            await closeClusterV2();
+        }
+        else {
+            await closeCluster();
+        }
+        activeClusterVersion = null;
+    }
+    catch (err) {
+        console.warn(`[subsystems] shutdown failed: ${String(err)}`);
+    }
+}
+function formatLeaderLabel(leader) {
+    const name = leader.displayName?.trim();
+    return name ? `${name} (${leader.agentId})` : leader.agentId;
+}
+function buildLeaderKey(leaders) {
+    return leaders
+        .map((leader) => leader.agentId)
+        .sort()
+        .join(",");
+}
+function buildLeaderLabel(leaders) {
+    return leaders.map((leader) => formatLeaderLabel(leader)).join(", ");
+}
+async function publishClusterV2LeaderRecoveredEvent(ctx) {
+    const active = getActiveClusterV2Service();
+    const bus = active?.bus ?? null;
+    if (!bus) {
+        publishSystemEvent({
+            source: "cluster",
+            level: "info",
+            message: "Re-election complete.",
+            dedupeKey: "cluster|leader_elected",
+            toast: true,
+            ctx,
+        });
+        return;
+    }
+    try {
+        const roster = await bus.roster();
+        const leaders = roster.agents.filter((agent) => agent.role === "leader");
+        if (leaders.length === 0) {
+            publishSystemEvent({
+                source: "cluster",
+                level: "info",
+                message: "Re-election complete.",
+                dedupeKey: "cluster|leader_elected",
+                toast: true,
+                ctx,
+            });
+            return;
+        }
+        const leaderKey = buildLeaderKey(leaders);
+        const leaderLabel = buildLeaderLabel(leaders);
+        publishSystemEvent({
+            source: "cluster",
+            level: "info",
+            message: `Re-election complete. Leader: ${leaderLabel}.`,
+            dedupeKey: `cluster|leader_elected|${leaderKey}`,
+            toast: true,
+            ctx,
+        });
+    }
+    catch {
+        publishSystemEvent({
+            source: "cluster",
+            level: "info",
+            message: "Re-election complete.",
+            dedupeKey: "cluster|leader_elected",
+            toast: true,
+            ctx,
+        });
+    }
+}
+function refreshMemoryEmbeddingProviderFromActiveClusterV2() {
+    const active = getActiveClusterV2Service();
+    if (!active) {
+        return;
+    }
+    setMemoryWorkersEmbeddingProvider(active.embedding);
+}
+function publishDiscordChannelBatchSystemEvent(ctx, event) {
+    const channelLabel = event.channelAlias?.trim() ||
+        (event.guildName?.trim() && event.channelName?.trim()
+            ? `${event.guildName.trim()} / ${event.channelName.trim()}`
+            : event.channelName?.trim()) ||
+        event.channelId;
+    publishSystemEvent({
+        source: "discord",
+        level: "info",
+        message: `Channel ${channelLabel} collected ${event.count} messages.`,
+        dedupeKey: `discord|channel_batch|${event.scope}|${event.channelId}|${event.sequence}`,
+        toast: false,
+        ctx,
+    });
+}
+function publishTwitterPullBatchSystemEvent(ctx, event) {
+    publishSystemEvent({
+        source: "twitter",
+        level: "info",
+        message: `For You pull complete: ${event.count}/${event.requestedCount} tweets.`,
+        dedupeKey: `twitter|pull_batch|${event.scope}|${event.sequence}`,
+        toast: false,
+        ctx,
+    });
+}
+function publishTwitterPullFailedSystemEvent(ctx, event) {
+    const triggerLabel = event.trigger === "startup" ? "startup" : "interval";
+    publishSystemEvent({
+        source: "twitter",
+        level: "warning",
+        message: `For You pull failed (${triggerLabel}): ${event.error}`,
+        dedupeKey: `twitter|pull_failed|${event.scope}|${event.trigger}`,
+        toast: false,
+        ctx,
+    });
+}
+function publishTwitterCollectorStartupFailedSystemEvent(ctx, event) {
+    publishSystemEvent({
+        source: "twitter",
+        level: "warning",
+        message: `Collector startup failed: ${event.error}`,
+        dedupeKey: `twitter|collector_start_failed|${event.scope}`,
+        toast: false,
+        ctx,
+    });
+}
+function startMemoryWarmupInBackground(ctx, params) {
+    let startNotified = false;
+    const notifyWarmupStartIfNeeded = () => {
+        if (startNotified) {
+            return;
+        }
+        startNotified = true;
+        publishSystemEvent({
+            source: "memory",
+            level: "info",
+            message: "Memory warmup in progress.",
+            dedupeKey: `memory|warmup|start|${params.agentId}`,
+            toast: false,
+            ctx,
+        });
+    };
+    void warmMemorySearch({
+        ...params,
+        onWorkDetected: notifyWarmupStartIfNeeded,
+    })
+        .then((result) => {
+        if (!result.attempted || !startNotified) {
+            return;
+        }
+        if (result.succeeded) {
+            publishSystemEvent({
+                source: "memory",
+                level: "info",
+                message: "Memory warmup complete.",
+                dedupeKey: `memory|warmup|done|${params.agentId}`,
+                toast: false,
+                ctx,
+            });
+            return;
+        }
+        publishSystemEvent({
+            source: "memory",
+            level: "warning",
+            message: `Memory warmup failed: ${result.error ?? "unknown error"}`,
+            dedupeKey: `memory|warmup|failed|${params.agentId}`,
+            toast: false,
+            ctx,
+        });
+    })
+        .catch((error) => {
+        if (!startNotified) {
+            return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        publishSystemEvent({
+            source: "memory",
+            level: "warning",
+            message: `Memory warmup failed: ${message}`,
+            dedupeKey: `memory|warmup|failed|${params.agentId}`,
+            toast: false,
+            ctx,
+        });
+    });
+}
+// --- Bus message injection (debounced) ---
+function createDefaultBusMessageInjector(pi) {
+    let pending = [];
+    let timer = null;
+    function flush() {
+        if (pending.length === 0)
+            return;
+        const msgs = pending;
+        pending = [];
+        timer = null;
+        const lines = msgs.map((m) => {
+            const text = typeof m.payload === "object" && m.payload !== null && "text" in m.payload
+                ? m.payload.text
+                : JSON.stringify(m.payload);
+            const ch = m.channel && m.channel !== "public" ? ` [${m.channel}]` : "";
+            return `[from ${m.from}${ch}] ${text}`;
+        });
+        const envelope = "<bus_messages>\n" + lines.join("\n") + "\n</bus_messages>\n\n" +
+            "You received the above messages from other agents via the message bus. " +
+            "Respond in character. Use the bus_send tool to reply.";
+        pi.sendUserMessage(envelope, { deliverAs: "followUp" });
+    }
+    return (msg) => {
+        pending.push(msg);
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(flush, 300);
+    };
+}

package/dist/src/extensions/mode-runtime.js

@@ -1,4 +1,11 @@
 export const MODE_STATE_ENTRY_TYPE = "switch-mode-state";
+function normalizeOptionalString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
 export const PLAN_MODE_STILL_ACTIVE_REMINDER = `<system_reminder>
 Plan mode is still active. Continue with the task in the current mode.
 </system_reminder>`;
@@ -24,6 +31,7 @@ export function parseModeStateEntry(entry) {
         return undefined;
     const state = data;
     if (state.activeMode === "plan" || state.activeMode === "agent" || state.activeMode === "ask") {
+        const planFilePath = normalizeOptionalString(state.planFilePath);
         return {
             activeMode: state.activeMode,
             pendingReminder: state.pendingReminder === "plan-entry" ||
@@ -31,12 +39,15 @@ export function parseModeStateEntry(entry) {
                 state.pendingReminder === "ask-entry"
                 ? state.pendingReminder
                 : undefined,
+            planFilePath,
         };
     }
     if (typeof state.planModeActive === "boolean") {
+        const planFilePath = normalizeOptionalString(state.planFilePath);
         return {
             activeMode: state.planModeActive ? "plan" : "agent",
             pendingReminder: undefined,
+            planFilePath,
         };
     }
     return undefined;
@@ -51,6 +62,7 @@ export function createModeStateData(snapshot) {
     return {
         activeMode: snapshot.activeMode,
         pendingReminder: snapshot.pendingReminder,
+        planFilePath: snapshot.planFilePath,
         planModeActive: snapshot.activeMode === "plan",
     };
 }
@@ -64,7 +76,7 @@ export function hasMessageEntries(entries) {
     }
     return false;
 }
-export function buildRuntimeEnvelope(userQuery, reminder, mcpInstructions, rulesEnvelope) {
+export function buildRuntimeEnvelope(userQuery, reminder, mcpInstructions, rulesEnvelope, briefReminder) {
     const sections = [];
     if (rulesEnvelope) {
         sections.push(rulesEnvelope.trim());
@@ -75,6 +87,9 @@ export function buildRuntimeEnvelope(userQuery, reminder, mcpInstructions, rules
     if (reminder) {
         sections.push(reminder.trim());
     }
+    if (briefReminder) {
+        sections.push(briefReminder.trim());
+    }
     sections.push(`<user_query>\n${userQuery}\n</user_query>`);
     return sections.join("\n\n");
 }
@@ -86,13 +101,22 @@ class ModeRuntimeStore {
     getSnapshot() {
         return { ...this.state };
     }
-    setMode(nextMode) {
+    setMode(nextMode, options) {
+        const nextPlanFilePath = normalizeOptionalString(options?.planFilePath);
         if (this.state.activeMode === nextMode) {
+            if (nextMode === "plan" && nextPlanFilePath !== undefined && nextPlanFilePath !== this.state.planFilePath) {
+                this.state.planFilePath = nextPlanFilePath;
+                this.state.pendingReminder = "plan-entry";
+                return { changed: true, snapshot: this.getSnapshot() };
+            }
             return { changed: false, snapshot: this.getSnapshot() };
         }
         this.state.activeMode = nextMode;
         switch (nextMode) {
             case "plan":
+                if (nextPlanFilePath !== undefined) {
+                    this.state.planFilePath = nextPlanFilePath;
+                }
                 this.state.pendingReminder = "plan-entry";
                 break;
             case "ask":

package/dist/src/extensions/mono-game.js

@@ -0,0 +1,66 @@
+import { setBusSendDefaultChannel, setBusSendHandle } from "../tools/bus-send.js";
+import registerGameSystemPromptExtension from "./game/system-prompt.js";
+import { initSubsystems, shutdownSubsystems } from "./lifecycle.js";
+import { getGameChannel, getGameGmChannel, loadGameIdentity } from "./game/identity.js";
+import { createGameBusMessageInjector } from "./game/bus-injection.js";
+import { setMailBoxHandle } from "./game/mailbox.js";
+import { resolveGameToolExtensions } from "./game/tools.js";
+import { registerClusterCommands, setClusterCommandDefaultChannel, setClusterHandle, } from "./cluster.js";
+export default function monoGameExtension(pi) {
+    pi.registerFlag("game-channel", {
+        description: "Override the game channel name",
+        type: "string",
+    });
+    registerGameSystemPromptExtension(pi);
+    registerClusterCommands(pi);
+    let handles = null;
+    pi.on("session_start", async (_event, ctx) => {
+        if (handles) {
+            setClusterHandle(null);
+            setClusterCommandDefaultChannel(undefined);
+            setBusSendHandle(null);
+            setBusSendDefaultChannel(undefined);
+            setMailBoxHandle(null);
+            await shutdownSubsystems(handles);
+            handles = null;
+        }
+        const identity = loadGameIdentity(ctx.cwd);
+        const channelOverride = pi.getFlag("game-channel");
+        const gameChannel = getGameChannel(ctx.cwd, typeof channelOverride === "string" ? channelOverride : undefined);
+        const gmChannel = getGameGmChannel(gameChannel);
+        const roleTools = resolveGameToolExtensions(identity.tools);
+        for (const register of roleTools) {
+            register(pi);
+        }
+        setBusSendDefaultChannel(gameChannel);
+        try {
+            const h = await initSubsystems(pi, ctx, {
+                displayName: identity.displayName,
+                busChannels: [gameChannel, gmChannel],
+                busMessageFilter: (msg) => {
+                    if (!msg.channel)
+                        return false;
+                    return msg.channel === gmChannel;
+                },
+                busMessageInjector: createGameBusMessageInjector(pi, { gmChannel }),
+            });
+            handles = h;
+            setClusterHandle(h.bus);
+            setClusterCommandDefaultChannel(gameChannel);
+            setBusSendHandle(h.bus);
+            setMailBoxHandle(h.bus, { gmChannel });
+        }
+        catch (err) {
+            console.warn(`[subsystems] init failed: ${String(err)}`);
+        }
+    });
+    pi.on("session_shutdown", async () => {
+        setClusterHandle(null);
+        setClusterCommandDefaultChannel(undefined);
+        setBusSendHandle(null);
+        setBusSendDefaultChannel(undefined);
+        setMailBoxHandle(null);
+        await shutdownSubsystems(handles);
+        handles = null;
+    });
+}

package/dist/src/extensions/mono-pilot.js

@@ -1,45 +1,127 @@
-import shellExtension from "../../tools/shell.js";
-import globExtension from "../../tools/glob.js";
-import rgExtension from "../../tools/rg.js";
-import readFileExtension from "../../tools/read-file.js";
-import deleteExtension from "../../tools/delete.js";
-import semanticSearchExtension from "../../tools/semantic-search.js";
-import webSearchExtension from "../../tools/web-search.js";
-import webFetchExtension from "../../tools/web-fetch.js";
-import askQuestionExtension from "../../tools/ask-question.js";
-import subagentExtension from "../../tools/subagent.js";
-import listMcpResourcesExtension from "../../tools/list-mcp-resources.js";
-import fetchMcpResourceExtension from "../../tools/fetch-mcp-resource.js";
-import listMcpToolsExtension from "../../tools/list-mcp-tools.js";
-import callMcpToolExtension from "../../tools/call-mcp-tool.js";
-import switchModeExtension from "../../tools/switch-mode.js";
-import applyPatchExtension from "../../tools/apply-patch.js";
+import { onCompaction } from "../brief/reflection.js";
+import lsExtension from "../tools/ls.js";
+import shellExtension from "../tools/shell.js";
+import globExtension from "../tools/glob.js";
+import rgExtension from "../tools/rg.js";
+import astGrepExtension from "../tools/ast-grep.js";
+import readFileExtension from "../tools/read-file.js";
+import deleteExtension from "../tools/delete.js";
+import semanticSearchExtension from "../tools/semantic-search.js";
+import webSearchExtension from "../tools/web-search.js";
+import webFetchExtension from "../tools/web-fetch.js";
+import generateImageExtension from "../tools/generate-image.js";
+import askUserQuestionExtension from "../tools/ask-user-question.js";
+import subagentExtension from "../tools/subagent.js";
+import listMcpResourcesExtension from "../tools/list-mcp-resources.js";
+import fetchMcpResourceExtension from "../tools/fetch-mcp-resource.js";
+import listMcpToolsExtension from "../tools/list-mcp-tools.js";
+import callMcpToolExtension from "../tools/call-mcp-tool.js";
+import switchModeExtension from "../tools/switch-mode.js";
+import exitPlanModeExtension from "../tools/exit-plan-mode.js";
+// import applyPatchExtension from "../tools/apply-patch.js";
+import codexApplyPatchExtension from "../tools/codex-apply-patch.js";
 import userMessageExtension from "./user-message.js";
 import systemPromptExtension from "./system-prompt.js";
 import sessionHintsExtension from "./session-hints.js";
+import nvimExtension from "./nvim.js";
+import lspDiagnosticsExtension from "../tools/lsp-diagnostics.js";
+import lspSymbolsExtension from "../tools/lsp-symbols.js";
+import briefWriteExtension from "../tools/brief-write.js";
+import memorySearchExtension from "../tools/memory-search.js";
+import memoryGetExtension from "../tools/memory-get.js";
+import busSendExtension, { setBusSendHandle } from "../tools/bus-send.js";
+import mailboxExtension from "../tools/mailbox.js";
+import { registerSessionMemoryHook } from "../memory/session/hook.js";
+import { registerBuildMemoryCommand } from "./commands/build-memory.js";
+import { registerDigestCommand } from "./commands/digest/index.js";
+import { registerClusterCommands, setClusterHandle } from "./cluster.js";
+import { registerStatusCommand } from "./status.js";
+import { registerImageModelCommands } from "./commands/image-model.js";
+import { registerSftpCommands } from "./sftp.js";
+import { registerSystemEvents } from "./system-events.js";
+import { initSubsystems, shutdownSubsystems } from "./lifecycle.js";
 const toolExtensions = [
     shellExtension,
     globExtension,
     rgExtension,
+    astGrepExtension,
     readFileExtension,
     deleteExtension,
+    lsExtension,
     semanticSearchExtension,
     webSearchExtension,
     webFetchExtension,
-    askQuestionExtension,
+    generateImageExtension,
+    askUserQuestionExtension,
     subagentExtension,
     listMcpResourcesExtension,
     fetchMcpResourceExtension,
     listMcpToolsExtension,
     callMcpToolExtension,
     switchModeExtension,
-    applyPatchExtension,
+    exitPlanModeExtension,
+    // applyPatchExtension,
+    codexApplyPatchExtension,
     userMessageExtension,
     systemPromptExtension,
     sessionHintsExtension,
+    nvimExtension,
+    lspDiagnosticsExtension,
+    lspSymbolsExtension,
+    briefWriteExtension,
+    memorySearchExtension,
+    memoryGetExtension,
+    busSendExtension,
+    mailboxExtension,
 ];
 export default function monoPilotExtension(pi) {
     for (const register of toolExtensions) {
         register(pi);
     }
+    registerSessionMemoryHook(pi);
+    registerSystemEvents(pi);
+    registerBuildMemoryCommand(pi);
+    registerDigestCommand(pi);
+    registerClusterCommands(pi);
+    registerStatusCommand(pi);
+    registerImageModelCommands(pi);
+    registerSftpCommands(pi);
+    let handles = null;
+    pi.on("session_start", async (_event, ctx) => {
+        if (handles) {
+            setClusterHandle(null);
+            setBusSendHandle(null);
+            await shutdownSubsystems(handles);
+            handles = null;
+        }
+        try {
+            const h = await initSubsystems(pi, ctx, {
+                busMessageInjector: (msg) => {
+                    const text = typeof msg.payload === "object" && msg.payload !== null && "text" in msg.payload
+                        ? msg.payload.text
+                        : JSON.stringify(msg.payload);
+                    const sender = msg.fromName ? `${msg.fromName} (${msg.from})` : msg.from;
+                    const ch = msg.channel && msg.channel !== "public" ? ` [${msg.channel}]` : "";
+                    const envelope = `<bus_messages>\n[from ${sender}${ch}] ${text}\n</bus_messages>\n\n` +
+                        "You received the above messages from other agents via the message bus.";
+                    pi.sendUserMessage(envelope, { deliverAs: "followUp" });
+                },
+            });
+            handles = h;
+            setClusterHandle(h.bus);
+            setBusSendHandle(h.bus);
+        }
+        catch (err) {
+            console.warn(`[subsystems] init failed: ${String(err)}`);
+        }
+    });
+    pi.on("session_compact", async () => {
+        onCompaction();
+    });
+    pi.on("session_shutdown", async () => {
+        setClusterHandle(null);
+        setBusSendHandle(null);
+        await shutdownSubsystems(handles);
+        handles = null;
+    });
 }

package/dist/src/extensions/nvim.js

@@ -0,0 +1,47 @@
+import { spawnSync } from "node:child_process";
+const NVIM_SHORTCUT = "alt+o";
+function commandExists(command) {
+    const probe = process.platform === "win32" ? "where" : "which";
+    const result = spawnSync(probe, [command], { stdio: "ignore", shell: process.platform === "win32" });
+    return result.status === 0;
+}
+function resolveEditor() {
+    if (commandExists("nvim"))
+        return "nvim";
+    if (commandExists("vim"))
+        return "vim";
+    return undefined;
+}
+function openWorkspaceInEditor(ctx, editor) {
+    const result = spawnSync(editor, [ctx.cwd], {
+        stdio: "inherit",
+        shell: process.platform === "win32",
+        cwd: ctx.cwd,
+    });
+    if (result.error) {
+        return { ok: false, reason: result.error.message };
+    }
+    if (result.status !== 0) {
+        return { ok: false, reason: `${editor} exited with code ${result.status ?? 1}` };
+    }
+    return { ok: true };
+}
+export default function nvimExtension(pi) {
+    pi.registerShortcut(NVIM_SHORTCUT, {
+        description: "Open workspace in nvim file explorer (fallback: vim)",
+        handler: async (ctx) => {
+            if (!ctx.hasUI) {
+                return;
+            }
+            const editor = resolveEditor();
+            if (!editor) {
+                ctx.ui.notify("nvim/vim not found in PATH.", "warning");
+                return;
+            }
+            const result = openWorkspaceInEditor(ctx, editor);
+            if (!result.ok) {
+                ctx.ui.notify(`Failed to open ${editor}: ${result.reason}`, "warning");
+            }
+        },
+    });
+}