indusagi-coding-agent 0.1.45 → 0.1.47

package/dist/interfaces/react-ink/adapters/command-router.js

@@ -0,0 +1,646 @@
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+import { getAuthPath, getDebugLogPath, getMCPConfigPath, getShareViewerUrl, } from "../../../config.js";
+import { resolveModelScope } from "../../../runtime/model-resolver.js";
+import { setTheme } from "../../theme/theme.js";
+import { flattenSessionTree, listSessions, listUserMessages } from "./session-history.js";
+import { buildLoginProviders, buildSavedAccounts, copyLastAssistantMessage, formatSessionStats, setSessionName, } from "../utils/session-actions.js";
+import { getFullChangelogMarkdown } from "../utils/changelog.js";
+import { formatSlashCommandList } from "../utils/slash-commands.js";
+function ensureLeadingSlash(name) {
+    return name.startsWith("/") ? name : `/${name}`;
+}
+function buildOAuthOverlay(provider) {
+    return {
+        kind: "oauth",
+        providerId: provider.id,
+        providerName: provider.label,
+        mode: "apiKey",
+        inputLabel: `API key for ${provider.id}`,
+        inputValue: "",
+        accountId: "default",
+        accountName: "Default",
+        progress: `Credentials will be saved to ${getAuthPath()}.`,
+    };
+}
+function formatHotkeys() {
+    return [
+        "Keyboard Shortcuts:",
+        "  Ctrl+C  Cancel active work or exit when idle",
+        "  Ctrl+P  Cycle models",
+        "  Shift+Tab  Cycle thinking level",
+        "  Ctrl+,  Open settings",
+        "  Ctrl+R  Open session resume",
+        "  Ctrl+G  Open session tree",
+        "  Ctrl+S  Queue a steering message",
+        "  Ctrl+J  Insert a new line",
+        "  Ctrl+U  Clear the prompt",
+        "  Enter   Submit prompt",
+        "  /       Slash commands",
+        "  !       Run a bash command",
+        "  !!      Run a bash command without adding it to context",
+    ].join("\n");
+}
+function ensureParentDirectory(filePath) {
+    const parent = dirname(filePath);
+    if (!existsSync(parent)) {
+        mkdirSync(parent, { recursive: true });
+    }
+}
+function writeDebugLog(session) {
+    const debugPath = getDebugLogPath();
+    const stats = session.getSessionStats();
+    const debugData = [
+        `Debug output at ${new Date().toISOString()}`,
+        `Session ID: ${stats.sessionId}`,
+        stats.sessionFile ? `Session file: ${stats.sessionFile}` : "Session file: (none)",
+        `Messages: ${stats.totalMessages}`,
+        `Tool calls: ${stats.toolCalls}`,
+        `Tokens: ${stats.tokens.total}`,
+        `Cost: ${stats.cost.toFixed(4)}`,
+        "",
+        "=== Messages (JSONL) ===",
+        ...session.messages.map((message) => JSON.stringify(message)),
+        "",
+    ].join("\n");
+    ensureParentDirectory(debugPath);
+    writeFileSync(debugPath, debugData, "utf-8");
+    return debugPath;
+}
+async function handleThemeCommand(searchTerm, ctx) {
+    if (!searchTerm) {
+        ctx.setOverlay({ kind: "theme" });
+        return;
+    }
+    const result = setTheme(searchTerm, true);
+    if (!result.success) {
+        ctx.setError(result.error ?? `Unable to load theme "${searchTerm}".`);
+        return;
+    }
+    ctx.session.settingsManager.setTheme(searchTerm);
+    ctx.setStatus(`Theme set to ${searchTerm}.`, "success");
+}
+async function handleModelCommand(searchTerm, ctx) {
+    if (!searchTerm) {
+        ctx.setOverlay({ kind: "model" });
+        return;
+    }
+    const normalized = searchTerm.toLowerCase();
+    const match = ctx.session.modelRegistry
+        .getAvailable()
+        .find((model) => `${model.provider}/${model.id}`.toLowerCase() === normalized || model.id.toLowerCase() === normalized);
+    if (!match) {
+        ctx.setError(`No model matched "${searchTerm}".`);
+        return;
+    }
+    await ctx.session.setModel(match);
+    ctx.setStatus(`Model set to ${match.provider}/${match.id}.`, "success");
+}
+async function handleScopedModelsCommand(ctx) {
+    ctx.session.modelRegistry.refresh();
+    const models = ctx.session.modelRegistry.getAvailable();
+    if (models.length === 0) {
+        ctx.setError("No authenticated models are available yet.");
+        return;
+    }
+    let selectedIds = ctx.session.scopedModels.map((entry) => `${entry.model.provider}/${entry.model.id}`);
+    if (selectedIds.length === 0) {
+        const patterns = ctx.session.settingsManager.getEnabledModels();
+        if (patterns && patterns.length > 0) {
+            const resolved = await resolveModelScope(patterns, ctx.session.modelRegistry);
+            selectedIds = resolved.map((entry) => `${entry.model.provider}/${entry.model.id}`);
+        }
+    }
+    ctx.setOverlay({
+        kind: "scopedModels",
+        models,
+        selectedIds,
+    });
+}
+async function handleResumeCommand(ctx) {
+    ctx.setOverlay({ kind: "session", sessions: [], loading: true });
+    try {
+        const sessions = await listSessions(ctx.session);
+        ctx.setOverlay({ kind: "session", sessions, loading: false });
+    }
+    catch (error) {
+        ctx.setOverlay({
+            kind: "session",
+            sessions: [],
+            loading: false,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function handleMCPCommand(subCommand, ctx) {
+    switch (subCommand) {
+        case "":
+        case "status": {
+            const servers = await ctx.session.getMCPStatus();
+            const toolNames = ctx.session.getMCPToolNames();
+            if (servers.length === 0) {
+                ctx.setStatus("MCP: no servers are configured or connected.");
+                return;
+            }
+            const lines = servers.map((server) => `${server.name}: ${server.connected ? "connected" : "disconnected"}${server.toolCount ? ` (${server.toolCount} tools)` : ""}`);
+            ctx.setStatus(`MCP Servers:\n${lines.join("\n")}\n\nTools: ${toolNames.length} available`);
+            return;
+        }
+        case "connect":
+        case "reconnect": {
+            const toolCount = await ctx.session.reconnectMCP(getMCPConfigPath());
+            ctx.setStatus(`Reconnected MCP servers. ${toolCount} tools available.`, "success");
+            return;
+        }
+        case "disconnect":
+            await ctx.session.disconnectMCP();
+            ctx.setStatus("Disconnected MCP servers.", "success");
+            return;
+        case "tools": {
+            const tools = ctx.session.getMCPToolNames();
+            ctx.setStatus(tools.length > 0 ? `MCP Tools:\n${tools.join("\n")}` : "MCP: no tools are loaded.");
+            return;
+        }
+        default:
+            ctx.setError("Usage: /mcp [status|connect|reconnect|disconnect|tools]");
+    }
+}
+async function handleMemoryCommand(subCommand, ctx) {
+    const trimmed = subCommand.trim();
+    const [command = "", ...rest] = trimmed.split(/\s+/).filter(Boolean);
+    const apiKey = rest.join(" ").trim();
+    switch (command) {
+        case "":
+        case "status": {
+            const savedOpenAIKey = await ctx.session.modelRegistry.getApiKeyForProvider("openai");
+            const memorySettings = ctx.session.settingsManager.getMemorySettings();
+            const enabledText = ctx.session.isMemoryEnabled() ? "Enabled for this session" : "Disabled for this session";
+            const defaultText = memorySettings.enabled && memorySettings.autoConnect ? "ON" : "OFF";
+            const toolCount = ctx.session.getMemoryToolNames().length;
+            ctx.setStatus(`Memory: ${enabledText}\n\nDefault startup: ${defaultText}\nSaved OpenAI key: ${savedOpenAIKey ? "Configured" : "Missing"}\nTools available: ${toolCount}`);
+            return;
+        }
+        case "on":
+            try {
+                await ctx.session.enableMemory({ persistSettings: true });
+                ctx.setStatus("Memory enabled. It will now auto-start for future sessions too.", "success");
+            }
+            catch (error) {
+                ctx.setError(`Could not enable memory: ${error instanceof Error ? error.message : "Unknown error"}\n\nTip: run /memory setup <OPENAI_API_KEY> first.`);
+            }
+            return;
+        case "off":
+            await ctx.session.disableMemory({ persistSettings: true });
+            ctx.setStatus("Memory disabled. Future sessions will start with memory off.", "success");
+            return;
+        case "setup":
+            if (!apiKey) {
+                const savedOpenAIKey = await ctx.session.modelRegistry.getApiKeyForProvider("openai");
+                if (!savedOpenAIKey) {
+                    ctx.setError("Usage: /memory setup <OPENAI_API_KEY>");
+                    return;
+                }
+                await ctx.session.enableMemory({ persistSettings: true });
+                ctx.setStatus("Memory enabled using your saved OpenAI API key.", "success");
+                return;
+            }
+            await ctx.session.enableMemory({ apiKey, persistSettings: true });
+            ctx.setStatus("OpenAI API key saved and memory enabled.", "success");
+            return;
+        case "clear":
+            if (!ctx.session.isMemoryEnabled()) {
+                ctx.setError("Memory is not enabled. Run /memory on first.");
+                return;
+            }
+            await ctx.session.clearMemory();
+            ctx.setStatus("Memory cleared for the current thread.", "success");
+            return;
+        case "working":
+            if (!ctx.session.isMemoryEnabled()) {
+                ctx.setError("Memory is not enabled. Run /memory on first.");
+                return;
+            }
+            {
+                const workingMemory = await ctx.session.getWorkingMemory();
+                ctx.setStatus(workingMemory
+                    ? `Working Memory:\n\n${workingMemory}`
+                    : "Working Memory: not set yet. The updateWorkingMemory tool can write to it once memory is enabled.");
+            }
+            return;
+        case "tools": {
+            const tools = ctx.session.getMemoryToolNames();
+            ctx.setStatus(tools.length > 0 ? `Memory Tools:\n${tools.join("\n")}` : "Memory tools are not enabled.");
+            return;
+        }
+        default:
+            ctx.setError("Usage: /memory [status|on|off|setup <OPENAI_API_KEY>|clear|working|tools]");
+    }
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function asNonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function collectUrls(value, seen = new WeakSet(), urls = []) {
+    if (value == null) {
+        return urls;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectUrls(item, seen, urls);
+        }
+        return urls;
+    }
+    const record = asRecord(value);
+    if (!record) {
+        return urls;
+    }
+    if (seen.has(record)) {
+        return urls;
+    }
+    seen.add(record);
+    for (const key of [
+        "authUri",
+        "auth_uri",
+        "authUrl",
+        "auth_url",
+        "authorizationUrl",
+        "authorization_url",
+        "redirectUrl",
+        "redirect_url",
+        "composio_link_redirect_url",
+        "account_url",
+        "accountUrl",
+        "borneo_dashboard_url",
+    ]) {
+        const candidate = asNonEmptyString(record[key]);
+        if (!candidate || urls.includes(candidate)) {
+            continue;
+        }
+        try {
+            const parsed = new URL(candidate);
+            if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+                urls.push(candidate);
+            }
+        }
+        catch {
+            // Ignore malformed URLs from provider payloads.
+        }
+    }
+    for (const nested of Object.values(record)) {
+        collectUrls(nested, seen, urls);
+    }
+    return urls;
+}
+function formatComposioAccount(account) {
+    const record = asRecord(account) ?? {};
+    const toolkit = asNonEmptyString(asRecord(record.toolkit)?.slug) ?? "unknown";
+    const status = asNonEmptyString(record.status) ?? "UNKNOWN";
+    const accountId = asNonEmptyString(record.id) ?? "unknown";
+    const authConfig = asNonEmptyString(asRecord(record.authConfig)?.id) ?? asNonEmptyString(asRecord(record.auth_config)?.id);
+    const reason = asNonEmptyString(record.statusReason) ?? asNonEmptyString(record.status_reason);
+    const urls = collectUrls(account).slice(0, 2);
+    const lines = [`  • ${toolkit} account ${accountId} [${status}]${authConfig ? ` authConfig=${authConfig}` : ""}`];
+    if (reason && status !== "ACTIVE") {
+        lines.push(`    reason: ${reason}`);
+    }
+    for (const url of urls) {
+        lines.push(`    open: ${url}`);
+    }
+    return lines.join("\n");
+}
+async function handleComposioCommand(subCommand, ctx) {
+    const trimmed = subCommand.trim();
+    const [command = "", ...rest] = trimmed.split(/\s+/).filter(Boolean);
+    const toolkitArg = rest.join(" ").trim();
+    const parsedToolkits = toolkitArg
+        .split(",")
+        .map((toolkit) => toolkit.trim())
+        .filter(Boolean);
+    const controlTools = [
+        "composio_toolkits",
+        "composio_tools",
+        "composio_execute",
+        "composio_enable",
+        "composio_connect",
+        "composio_accounts",
+    ];
+    switch (command) {
+        case "":
+        case "status": {
+            const settings = ctx.session.settingsManager.getComposioSettings();
+            const activeControlTools = controlTools.filter((tool) => ctx.session.getActiveToolNames().includes(tool));
+            const enabledTools = ctx.session.getComposioToolNames();
+            ctx.setStatus(`Composio: ${settings.enabled ? "enabled" : "disabled"}\n\nControl tools active: ${activeControlTools.length}/${controlTools.length}\nHydrated toolkit tools: ${enabledTools.length}\nDefault mode: ${settings.mode}\nDefault auto-connect: ${settings.autoConnect ? "ON" : "OFF"}\nDefault toolkits: ${settings.defaultToolkits.length > 0 ? settings.defaultToolkits.join(", ") : "(none)"}`);
+            return;
+        }
+        case "connect": {
+            if (!toolkitArg) {
+                ctx.setError("Usage: /composio connect <toolkit|connectedAccountId>");
+                return;
+            }
+            const isAccountId = toolkitArg.startsWith("ca_");
+            const result = await ctx.session.connectComposio({
+                toolkit: isAccountId ? undefined : toolkitArg,
+                connectedAccountId: isAccountId ? toolkitArg : undefined,
+            });
+            const lines = [`Composio Connect: ${result.toolkit ?? "account"} ${result.accountId} [${result.status}]`];
+            if (result.redirectUrl) {
+                lines.push("", "Open this URL to finish auth:", result.redirectUrl);
+            }
+            else if (result.action === "already_connected") {
+                lines.push("", "This account is already active and ready to use.");
+            }
+            else {
+                lines.push("", "No auth URL was returned. Run /composio accounts again in a few seconds.");
+            }
+            ctx.setStatus(lines.join("\n"), result.redirectUrl ? "warning" : "info");
+            return;
+        }
+        case "enable": {
+            if (parsedToolkits.length === 0) {
+                ctx.setError("Usage: /composio enable <toolkit[,toolkit]>");
+                return;
+            }
+            const tools = await ctx.session.enableComposio({
+                toolkits: parsedToolkits,
+                persistSettings: false,
+            });
+            ctx.setStatus(`Composio: enabled ${tools.length} toolkit tool${tools.length === 1 ? "" : "s"} from ${parsedToolkits.join(", ")}`, "success");
+            return;
+        }
+        case "tools": {
+            const tools = ctx.session.getComposioTools();
+            if (tools.length === 0) {
+                ctx.setStatus("Composio: no toolkit tools are hydrated in this session yet.");
+                return;
+            }
+            ctx.setStatus(`Composio Toolkit Tools:\n${tools
+                .map((tool) => `  • ${tool.name} (${tool.composio.slug}${tool.composio.toolkit ? ` / ${tool.composio.toolkit}` : ""})`)
+                .join("\n")}`);
+            return;
+        }
+        case "accounts": {
+            const result = await ctx.session.listComposioAccounts({
+                toolkits: parsedToolkits.length > 0 ? parsedToolkits : undefined,
+            });
+            const items = Array.isArray(result.items) ? result.items : [];
+            if (items.length === 0) {
+                ctx.setStatus("Composio: no connected accounts found for the current user.");
+                return;
+            }
+            ctx.setStatus(`Composio Accounts:\n${items.map((account) => formatComposioAccount(account)).join("\n")}`);
+            return;
+        }
+        case "clear":
+            await ctx.session.clearComposioTools({ persistSettings: true });
+            ctx.setStatus("Composio toolkit tools cleared from the current session.", "success");
+            return;
+        default:
+            ctx.setError("Usage: /composio [status|connect <toolkit|connectedAccountId>|enable <toolkit[,toolkit]>|tools|accounts [toolkit[,toolkit]]|clear]");
+    }
+}
+function handleLoginProvider(providerId, ctx) {
+    const normalized = providerId.trim().toLowerCase();
+    const provider = buildLoginProviders(ctx.session).find((entry) => entry.id.toLowerCase() === normalized);
+    if (!provider) {
+        ctx.setError(`Unknown auth provider "${providerId}".`);
+        return true;
+    }
+    if (provider.authKind === "oauth" && ctx.startOAuthLogin) {
+        void ctx.startOAuthLogin(provider);
+        return true;
+    }
+    ctx.setOverlay(buildOAuthOverlay(provider));
+    return true;
+}
+function handleShareCommand(ctx) {
+    let authResult;
+    try {
+        authResult = spawnSync("gh", ["auth", "status"], { encoding: "utf-8" });
+    }
+    catch {
+        ctx.setError("GitHub CLI (gh) is not installed. Install it and retry.");
+        return;
+    }
+    if (authResult.status !== 0) {
+        ctx.setError("GitHub CLI is not logged in. Run `gh auth login` first.");
+        return;
+    }
+    const tempFile = join(tmpdir(), `indusagi-session-${Date.now()}.html`);
+    void (async () => {
+        try {
+            await ctx.session.exportToHtml(tempFile);
+            const gistResult = spawnSync("gh", ["gist", "create", "--public=false", tempFile], {
+                encoding: "utf-8",
+            });
+            if (gistResult.status !== 0) {
+                ctx.setError(String(gistResult.stderr || "Failed to create gist.").trim());
+                return;
+            }
+            const gistUrl = String(gistResult.stdout).trim().split(/\s+/)[0];
+            const gistId = gistUrl.split("/").pop();
+            if (!gistId) {
+                ctx.setError("Failed to parse gist ID from GitHub CLI output.");
+                return;
+            }
+            ctx.setStatus(`Share URL: ${getShareViewerUrl(gistId)}\nGist: ${gistUrl}`, "success");
+        }
+        catch (error) {
+            ctx.setError(`Failed to share session: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            try {
+                unlinkSync(tempFile);
+            }
+            catch {
+                // Ignore cleanup errors.
+            }
+        }
+    })();
+}
+export async function runSlashCommand(input, ctx) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/")) {
+        return false;
+    }
+    if (trimmed === "/settings") {
+        ctx.setOverlay({ kind: "settings" });
+        return true;
+    }
+    if (trimmed === "/model" || trimmed.startsWith("/model ")) {
+        await handleModelCommand(trimmed === "/model" ? undefined : trimmed.slice(7).trim(), ctx);
+        return true;
+    }
+    if (trimmed === "/scoped-models") {
+        await handleScopedModelsCommand(ctx);
+        return true;
+    }
+    if (trimmed === "/theme" || trimmed.startsWith("/theme ")) {
+        await handleThemeCommand(trimmed === "/theme" ? undefined : trimmed.slice(7).trim(), ctx);
+        return true;
+    }
+    if (trimmed === "/session") {
+        ctx.setStatus(formatSessionStats(ctx.session));
+        return true;
+    }
+    if (trimmed === "/resume") {
+        await handleResumeCommand(ctx);
+        return true;
+    }
+    if (trimmed === "/tree") {
+        ctx.setOverlay({ kind: "tree", items: flattenSessionTree(ctx.session) });
+        return true;
+    }
+    if (trimmed === "/fork") {
+        ctx.setOverlay({ kind: "userMessage", items: listUserMessages(ctx.session) });
+        return true;
+    }
+    if (trimmed === "/login") {
+        ctx.setOverlay({ kind: "login", providers: buildLoginProviders(ctx.session) });
+        return true;
+    }
+    if (trimmed.startsWith("/login ")) {
+        return handleLoginProvider(trimmed.slice(7).trim(), ctx);
+    }
+    if (trimmed === "/logout") {
+        ctx.setOverlay({ kind: "logout", accounts: buildSavedAccounts(ctx.session) });
+        return true;
+    }
+    if (trimmed === "/new" || trimmed === "/clear") {
+        const started = await ctx.session.newSession();
+        if (!started) {
+            ctx.setStatus("Starting a new session was cancelled.", "warning");
+            return true;
+        }
+        ctx.resetSessionView?.();
+        ctx.setInput("");
+        ctx.setStatus("Started a new session.", "success");
+        return true;
+    }
+    if (trimmed === "/compact" || trimmed.startsWith("/compact ")) {
+        const customInstructions = trimmed === "/compact" ? undefined : trimmed.slice(9).trim();
+        await ctx.session.compact(customInstructions || undefined);
+        ctx.setStatus("Compaction completed.", "success");
+        return true;
+    }
+    if (trimmed === "/reload") {
+        await ctx.session.reload();
+        ctx.setStatus("Reloaded extensions, prompts, skills, and themes.", "success");
+        return true;
+    }
+    if (trimmed === "/copy") {
+        copyLastAssistantMessage(ctx.session);
+        ctx.setStatus("Copied the last assistant response to your clipboard.", "success");
+        return true;
+    }
+    if (trimmed === "/help") {
+        ctx.setStatus(formatSlashCommandList(ctx.session));
+        return true;
+    }
+    if (trimmed === "/hotkeys") {
+        ctx.setStatus(formatHotkeys());
+        return true;
+    }
+    if (trimmed === "/changelog") {
+        if (ctx.appendDisplayBlock) {
+            ctx.appendDisplayBlock({
+                kind: "changelog",
+                title: "What's New",
+                markdown: getFullChangelogMarkdown(),
+            });
+            ctx.clearStatus?.();
+        }
+        else {
+            ctx.setStatus(getFullChangelogMarkdown());
+        }
+        return true;
+    }
+    if (trimmed === "/debug") {
+        const debugPath = writeDebugLog(ctx.session);
+        ctx.setStatus(`Debug log written to ${debugPath}`, "success");
+        return true;
+    }
+    if (trimmed === "/share") {
+        handleShareCommand(ctx);
+        return true;
+    }
+    if (trimmed === "/mcp" || trimmed.startsWith("/mcp ")) {
+        await handleMCPCommand(trimmed.startsWith("/mcp ") ? trimmed.slice(5).trim() : "", ctx);
+        return true;
+    }
+    if (trimmed === "/memory" || trimmed.startsWith("/memory ")) {
+        await handleMemoryCommand(trimmed.startsWith("/memory ") ? trimmed.slice(8).trim() : "", ctx);
+        return true;
+    }
+    if (trimmed === "/composio" || trimmed.startsWith("/composio ")) {
+        await handleComposioCommand(trimmed.startsWith("/composio ") ? trimmed.slice(10).trim() : "", ctx);
+        return true;
+    }
+    if (trimmed === "/name") {
+        const currentName = ctx.session.sessionManager.getSessionName();
+        ctx.setStatus(currentName ? `Session name: ${currentName}` : "Session has no custom name yet.");
+        return true;
+    }
+    if (trimmed.startsWith("/name ")) {
+        const name = trimmed.slice(6).trim();
+        if (!name) {
+            ctx.setError("Usage: /name <name>");
+            return true;
+        }
+        const nextName = setSessionName(ctx.session, name);
+        ctx.setStatus(`Session name set to "${nextName}".`, "success");
+        return true;
+    }
+    if (trimmed === "/export" || trimmed.startsWith("/export ")) {
+        const outputPath = trimmed === "/export" ? undefined : trimmed.slice(8).trim() || undefined;
+        const exported = await ctx.session.exportToHtml(outputPath);
+        ctx.setStatus(`Exported session HTML to ${exported}.`, "success");
+        return true;
+    }
+    if ((trimmed === "/quit" || trimmed === "/exit") && ctx.onExit) {
+        ctx.onExit();
+        return true;
+    }
+    // Let prompt templates, extension commands, and /skill:* commands fall through to the runtime.
+    if (trimmed.startsWith("/")) {
+        const builtins = new Set([
+            "/settings",
+            "/model",
+            "/scoped-models",
+            "/theme",
+            "/session",
+            "/resume",
+            "/tree",
+            "/fork",
+            "/login",
+            "/logout",
+            "/new",
+            "/clear",
+            "/compact",
+            "/reload",
+            "/copy",
+            "/help",
+            "/hotkeys",
+            "/changelog",
+            "/debug",
+            "/share",
+            "/mcp",
+            "/memory",
+            "/composio",
+            "/name",
+            "/export",
+            "/quit",
+            "/exit",
+        ]);
+        const baseCommand = ensureLeadingSlash(trimmed.split(/\s+/, 1)[0]);
+        if (!builtins.has(baseCommand)) {
+            return false;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=command-router.js.map