gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/packages/pi-coding-agent/dist/modes/interactive/slash-command-handlers.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Slash command dispatch and handler implementations extracted from InteractiveMode.
+ *
+ * The `dispatchSlashCommand` function contains the dispatch logic (routing text
+ * to handlers), and individual handler functions implement each command.
+ *
+ * Handlers that are also invoked from keybindings or other subsystems remain on
+ * InteractiveMode and are called through the `SlashCommandContext` interface.
+ */
+import type { EditorComponent, MarkdownTheme } from "@gsd/pi-tui";
+import { type Component, Container } from "@gsd/pi-tui";
+import type { AgentSession } from "../../core/agent-session.js";
+import type { AppAction, KeybindingsManager } from "../../core/keybindings.js";
+import type { SessionManager } from "../../core/session-manager.js";
+import type { SettingsManager } from "../../core/settings-manager.js";
+import type { TUI } from "@gsd/pi-tui";
+/**
+ * Provides slash command handlers with access to the parts of InteractiveMode
+ * they need without coupling them to the entire class.
+ */
+export interface SlashCommandContext {
+    readonly session: AgentSession;
+    readonly ui: TUI;
+    readonly keybindings: KeybindingsManager;
+    readonly chatContainer: Container;
+    readonly statusContainer: Container;
+    readonly editorContainer: Container;
+    readonly headerContainer: Container;
+    readonly pendingMessagesContainer: Container;
+    readonly editor: EditorComponent;
+    readonly defaultEditor: EditorComponent & {
+        onEscape?: () => void;
+    };
+    readonly sessionManager: SessionManager;
+    readonly settingsManager: SettingsManager;
+    invalidateFooter(): void;
+    showStatus(message: string): void;
+    showError(message: string): void;
+    showWarning(message: string): void;
+    showSelector(create: (done: () => void) => {
+        component: Component;
+        focus: Component;
+    }): void;
+    updateEditorBorderColor(): void;
+    getMarkdownThemeWithSettings(): MarkdownTheme;
+    requestRender(): void;
+    updateTerminalTitle(): void;
+    showSettingsSelector(): void;
+    showModelsSelector(): Promise<void>;
+    handleModelCommand(searchTerm?: string): Promise<void>;
+    showUserMessageSelector(): void;
+    showTreeSelector(): void;
+    showProviderManager(): void;
+    showOAuthSelector(mode: "login" | "logout"): Promise<void>;
+    showSessionSelector(): void;
+    handleClearCommand(): Promise<void>;
+    handleReloadCommand(): Promise<void>;
+    handleDebugCommand(): void;
+    shutdown(): Promise<void>;
+    executeCompaction(customInstructions?: string, isAuto?: boolean): Promise<unknown>;
+}
+/**
+ * Routes a slash command string to the appropriate handler.
+ *
+ * @returns `true` if the text was handled as a slash command (caller should
+ *          not process it further), `false` otherwise.
+ */
+export declare function dispatchSlashCommand(text: string, ctx: SlashCommandContext): Promise<boolean>;
+export declare function capitalizeKey(key: string): string;
+export declare function getAppKeyDisplay(keybindings: KeybindingsManager, action: AppAction): string;
+//# sourceMappingURL=slash-command-handlers.d.ts.map

package/packages/pi-coding-agent/dist/modes/interactive/slash-command-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash-command-handlers.d.ts","sourceRoot":"","sources":["../../../src/modes/interactive/slash-command-handlers.ts"],"names":[],"mappings":"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"}

package/packages/pi-coding-agent/dist/modes/interactive/slash-command-handlers.js

@@ -0,0 +1,514 @@
+/**
+ * Slash command dispatch and handler implementations extracted from InteractiveMode.
+ *
+ * The `dispatchSlashCommand` function contains the dispatch logic (routing text
+ * to handlers), and individual handler functions implement each command.
+ *
+ * Handlers that are also invoked from keybindings or other subsystems remain on
+ * InteractiveMode and are called through the `SlashCommandContext` interface.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Markdown, Spacer, Text, } from "@gsd/pi-tui";
+import { spawn, spawnSync } from "child_process";
+import { getShareViewerUrl, } from "../../config.js";
+import { copyToClipboard } from "../../utils/clipboard.js";
+import { getChangelogPath, parseChangelog } from "../../utils/changelog.js";
+import { ArminComponent } from "./components/armin.js";
+import { BorderedLoader } from "./components/bordered-loader.js";
+import { DynamicBorder } from "./components/dynamic-border.js";
+import { appKey, editorKey, formatKeyForDisplay } from "./components/keybinding-hints.js";
+import { SelectSubmenu, THINKING_DESCRIPTIONS } from "./components/settings-selector.js";
+import { theme } from "./theme/theme.js";
+// ---------------------------------------------------------------------------
+// Dispatch
+// ---------------------------------------------------------------------------
+/**
+ * Routes a slash command string to the appropriate handler.
+ *
+ * @returns `true` if the text was handled as a slash command (caller should
+ *          not process it further), `false` otherwise.
+ */
+export async function dispatchSlashCommand(text, ctx) {
+    if (text === "/settings") {
+        ctx.showSettingsSelector();
+        return true;
+    }
+    if (text === "/scoped-models") {
+        await ctx.showModelsSelector();
+        return true;
+    }
+    if (text === "/model" || text.startsWith("/model ")) {
+        const searchTerm = text.startsWith("/model ") ? text.slice(7).trim() : undefined;
+        await ctx.handleModelCommand(searchTerm);
+        return true;
+    }
+    if (text.startsWith("/export")) {
+        await handleExportCommand(text, ctx);
+        return true;
+    }
+    if (text === "/share") {
+        await handleShareCommand(ctx);
+        return true;
+    }
+    if (text === "/copy") {
+        handleCopyCommand(ctx);
+        return true;
+    }
+    if (text === "/name" || text.startsWith("/name ")) {
+        handleNameCommand(text, ctx);
+        return true;
+    }
+    if (text === "/session") {
+        handleSessionCommand(ctx);
+        return true;
+    }
+    if (text === "/changelog") {
+        handleChangelogCommand(ctx);
+        return true;
+    }
+    if (text === "/hotkeys") {
+        handleHotkeysCommand(ctx);
+        return true;
+    }
+    if (text === "/fork") {
+        ctx.showUserMessageSelector();
+        return true;
+    }
+    if (text === "/tree") {
+        ctx.showTreeSelector();
+        return true;
+    }
+    if (text === "/provider") {
+        ctx.showProviderManager();
+        return true;
+    }
+    if (text === "/login") {
+        await ctx.showOAuthSelector("login");
+        return true;
+    }
+    if (text === "/logout") {
+        await ctx.showOAuthSelector("logout");
+        return true;
+    }
+    if (text === "/new") {
+        await ctx.handleClearCommand();
+        return true;
+    }
+    if (text === "/compact" || text.startsWith("/compact ")) {
+        const customInstructions = text.startsWith("/compact ") ? text.slice(9).trim() : undefined;
+        await handleCompactCommand(customInstructions, ctx);
+        return true;
+    }
+    if (text === "/reload") {
+        await ctx.handleReloadCommand();
+        return true;
+    }
+    if (text === "/thinking" || text.startsWith("/thinking ")) {
+        const arg = text.startsWith("/thinking ") ? text.slice(10).trim() : undefined;
+        handleThinkingCommand(arg, ctx);
+        return true;
+    }
+    if (text === "/edit-mode" || text.startsWith("/edit-mode ")) {
+        const arg = text.startsWith("/edit-mode ") ? text.slice(11).trim() : undefined;
+        handleEditModeCommand(arg, ctx);
+        return true;
+    }
+    if (text === "/debug") {
+        ctx.handleDebugCommand();
+        return true;
+    }
+    if (text === "/arminsayshi") {
+        handleArminSaysHi(ctx);
+        return true;
+    }
+    if (text === "/resume") {
+        ctx.showSessionSelector();
+        return true;
+    }
+    if (text === "/quit") {
+        await ctx.shutdown();
+        return true;
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Individual command handlers
+// ---------------------------------------------------------------------------
+async function handleExportCommand(text, ctx) {
+    const parts = text.split(/\s+/);
+    const outputPath = parts.length > 1 ? parts[1] : undefined;
+    try {
+        const filePath = await ctx.session.exportToHtml(outputPath);
+        ctx.showStatus(`Session exported to: ${filePath}`);
+    }
+    catch (error) {
+        ctx.showError(`Failed to export session: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+}
+async function handleShareCommand(ctx) {
+    // Check if gh is available and logged in
+    try {
+        const authResult = spawnSync("gh", ["auth", "status"], { encoding: "utf-8" });
+        if (authResult.status !== 0) {
+            ctx.showError("GitHub CLI is not logged in. Run 'gh auth login' first.");
+            return;
+        }
+    }
+    catch {
+        ctx.showError("GitHub CLI (gh) is not installed. Install it from https://cli.github.com/");
+        return;
+    }
+    // Export to a temp file
+    const tmpFile = path.join(os.tmpdir(), "session.html");
+    try {
+        await ctx.session.exportToHtml(tmpFile);
+    }
+    catch (error) {
+        ctx.showError(`Failed to export session: ${error instanceof Error ? error.message : "Unknown error"}`);
+        return;
+    }
+    // Show cancellable loader, replacing the editor
+    const loader = new BorderedLoader(ctx.ui, theme, "Creating gist...");
+    ctx.editorContainer.clear();
+    ctx.editorContainer.addChild(loader);
+    ctx.ui.setFocus(loader);
+    ctx.requestRender();
+    const restoreEditor = () => {
+        loader.dispose();
+        ctx.editorContainer.clear();
+        ctx.editorContainer.addChild(ctx.editor);
+        ctx.ui.setFocus(ctx.editor);
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    };
+    // Create a secret gist asynchronously
+    let proc = null;
+    loader.onAbort = () => {
+        proc?.kill();
+        restoreEditor();
+        ctx.showStatus("Share cancelled");
+    };
+    try {
+        const result = await new Promise((resolve) => {
+            proc = spawn("gh", ["gist", "create", "--public=false", tmpFile]);
+            let stdout = "";
+            let stderr = "";
+            proc.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+            proc.on("close", (code) => resolve({ stdout, stderr, code }));
+        });
+        if (loader.signal.aborted)
+            return;
+        restoreEditor();
+        if (result.code !== 0) {
+            const errorMsg = result.stderr?.trim() || "Unknown error";
+            ctx.showError(`Failed to create gist: ${errorMsg}`);
+            return;
+        }
+        // Extract gist ID from the URL returned by gh
+        // gh returns something like: https://gist.github.com/username/GIST_ID
+        const gistUrl = result.stdout?.trim();
+        const gistId = gistUrl?.split("/").pop();
+        if (!gistId) {
+            ctx.showError("Failed to parse gist ID from gh output");
+            return;
+        }
+        // Create the preview URL
+        const previewUrl = getShareViewerUrl(gistId);
+        ctx.showStatus(`Share URL: ${previewUrl}\nGist: ${gistUrl}`);
+    }
+    catch (error) {
+        if (!loader.signal.aborted) {
+            restoreEditor();
+            ctx.showError(`Failed to create gist: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+}
+function handleCopyCommand(ctx) {
+    const text = ctx.session.getLastAssistantText();
+    if (!text) {
+        ctx.showError("No agent messages to copy yet.");
+        return;
+    }
+    try {
+        copyToClipboard(text);
+        ctx.showStatus("Copied last agent message to clipboard");
+    }
+    catch (error) {
+        ctx.showError(error instanceof Error ? error.message : String(error));
+    }
+}
+function handleNameCommand(text, ctx) {
+    const name = text.replace(/^\/name\s*/, "").trim();
+    if (!name) {
+        const currentName = ctx.sessionManager.getSessionName();
+        if (currentName) {
+            ctx.chatContainer.addChild(new Spacer(1));
+            ctx.chatContainer.addChild(new Text(theme.fg("dim", `Session name: ${currentName}`), 1, 0));
+        }
+        else {
+            ctx.showWarning("Usage: /name <name>");
+        }
+        ctx.requestRender();
+        return;
+    }
+    ctx.sessionManager.appendSessionInfo(name);
+    ctx.updateTerminalTitle();
+    ctx.chatContainer.addChild(new Spacer(1));
+    ctx.chatContainer.addChild(new Text(theme.fg("dim", `Session name set: ${name}`), 1, 0));
+    ctx.requestRender();
+}
+function handleSessionCommand(ctx) {
+    const stats = ctx.session.getSessionStats();
+    const sessionName = ctx.sessionManager.getSessionName();
+    let info = `${theme.bold("Session Info")}\n\n`;
+    if (sessionName) {
+        info += `${theme.fg("dim", "Name:")} ${sessionName}\n`;
+    }
+    info += `${theme.fg("dim", "File:")} ${stats.sessionFile ?? "In-memory"}\n`;
+    info += `${theme.fg("dim", "ID:")} ${stats.sessionId}\n\n`;
+    info += `${theme.bold("Messages")}\n`;
+    info += `${theme.fg("dim", "User:")} ${stats.userMessages}\n`;
+    info += `${theme.fg("dim", "Assistant:")} ${stats.assistantMessages}\n`;
+    info += `${theme.fg("dim", "Tool Calls:")} ${stats.toolCalls}\n`;
+    info += `${theme.fg("dim", "Tool Results:")} ${stats.toolResults}\n`;
+    info += `${theme.fg("dim", "Total:")} ${stats.totalMessages}\n\n`;
+    info += `${theme.bold("Tokens")}\n`;
+    info += `${theme.fg("dim", "Input:")} ${stats.tokens.input.toLocaleString()}\n`;
+    info += `${theme.fg("dim", "Output:")} ${stats.tokens.output.toLocaleString()}\n`;
+    if (stats.tokens.cacheRead > 0) {
+        info += `${theme.fg("dim", "Cache Read:")} ${stats.tokens.cacheRead.toLocaleString()}\n`;
+    }
+    if (stats.tokens.cacheWrite > 0) {
+        info += `${theme.fg("dim", "Cache Write:")} ${stats.tokens.cacheWrite.toLocaleString()}\n`;
+    }
+    info += `${theme.fg("dim", "Total:")} ${stats.tokens.total.toLocaleString()}\n`;
+    if (stats.cost > 0) {
+        info += `\n${theme.bold("Cost")}\n`;
+        info += `${theme.fg("dim", "Total:")} ${stats.cost.toFixed(4)}`;
+    }
+    ctx.chatContainer.addChild(new Spacer(1));
+    ctx.chatContainer.addChild(new Text(info, 1, 0));
+    ctx.requestRender();
+}
+function handleChangelogCommand(ctx) {
+    const changelogPath = getChangelogPath();
+    const allEntries = parseChangelog(changelogPath);
+    const changelogMarkdown = allEntries.length > 0
+        ? allEntries
+            .reverse()
+            .map((e) => e.content)
+            .join("\n\n")
+        : "No changelog entries found.";
+    ctx.chatContainer.addChild(new Spacer(1));
+    ctx.chatContainer.addChild(new DynamicBorder());
+    ctx.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0));
+    ctx.chatContainer.addChild(new Spacer(1));
+    ctx.chatContainer.addChild(new Markdown(changelogMarkdown, 1, 1, ctx.getMarkdownThemeWithSettings()));
+    ctx.chatContainer.addChild(new DynamicBorder());
+    ctx.requestRender();
+}
+// ---------------------------------------------------------------------------
+// /hotkeys helpers
+// ---------------------------------------------------------------------------
+export function capitalizeKey(key) {
+    return key
+        .split("/")
+        .map((k) => k
+        .split("+")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("+"))
+        .join("/");
+}
+export function getAppKeyDisplay(keybindings, action) {
+    return capitalizeKey(appKey(keybindings, action));
+}
+function getEditorKeyDisplay(action) {
+    return capitalizeKey(editorKey(action));
+}
+function handleHotkeysCommand(ctx) {
+    // Navigation keybindings
+    const cursorWordLeft = getEditorKeyDisplay("cursorWordLeft");
+    const cursorWordRight = getEditorKeyDisplay("cursorWordRight");
+    const cursorLineStart = getEditorKeyDisplay("cursorLineStart");
+    const cursorLineEnd = getEditorKeyDisplay("cursorLineEnd");
+    const jumpForward = getEditorKeyDisplay("jumpForward");
+    const jumpBackward = getEditorKeyDisplay("jumpBackward");
+    const pageUp = getEditorKeyDisplay("pageUp");
+    const pageDown = getEditorKeyDisplay("pageDown");
+    // Editing keybindings
+    const submit = getEditorKeyDisplay("submit");
+    const newLine = getEditorKeyDisplay("newLine");
+    const deleteWordBackward = getEditorKeyDisplay("deleteWordBackward");
+    const deleteWordForward = getEditorKeyDisplay("deleteWordForward");
+    const deleteToLineStart = getEditorKeyDisplay("deleteToLineStart");
+    const deleteToLineEnd = getEditorKeyDisplay("deleteToLineEnd");
+    const yank = getEditorKeyDisplay("yank");
+    const yankPop = getEditorKeyDisplay("yankPop");
+    const undo = getEditorKeyDisplay("undo");
+    const tab = getEditorKeyDisplay("tab");
+    // App keybindings
+    const interrupt = getAppKeyDisplay(ctx.keybindings, "interrupt");
+    const clear = getAppKeyDisplay(ctx.keybindings, "clear");
+    const exit = getAppKeyDisplay(ctx.keybindings, "exit");
+    const suspend = getAppKeyDisplay(ctx.keybindings, "suspend");
+    const cycleThinkingLevel = getAppKeyDisplay(ctx.keybindings, "cycleThinkingLevel");
+    const cycleModelForward = getAppKeyDisplay(ctx.keybindings, "cycleModelForward");
+    const selectModel = getAppKeyDisplay(ctx.keybindings, "selectModel");
+    const expandTools = getAppKeyDisplay(ctx.keybindings, "expandTools");
+    const toggleThinking = getAppKeyDisplay(ctx.keybindings, "toggleThinking");
+    const externalEditor = getAppKeyDisplay(ctx.keybindings, "externalEditor");
+    const followUp = getAppKeyDisplay(ctx.keybindings, "followUp");
+    const dequeue = getAppKeyDisplay(ctx.keybindings, "dequeue");
+    let hotkeys = `
+**Navigation**
+| Key | Action |
+|-----|--------|
+| \`Arrow keys\` | Move cursor / browse history (Up when empty) |
+| \`${cursorWordLeft}\` / \`${cursorWordRight}\` | Move by word |
+| \`${cursorLineStart}\` | Start of line |
+| \`${cursorLineEnd}\` | End of line |
+| \`${jumpForward}\` | Jump forward to character |
+| \`${jumpBackward}\` | Jump backward to character |
+| \`${pageUp}\` / \`${pageDown}\` | Scroll by page |
+
+**Editing**
+| Key | Action |
+|-----|--------|
+| \`${submit}\` | Send message |
+| \`${newLine}\` | New line${process.platform === "win32" ? " (Ctrl+Enter on Windows Terminal)" : ""} |
+| \`${deleteWordBackward}\` | Delete word backwards |
+| \`${deleteWordForward}\` | Delete word forwards |
+| \`${deleteToLineStart}\` | Delete to start of line |
+| \`${deleteToLineEnd}\` | Delete to end of line |
+| \`${yank}\` | Paste the most-recently-deleted text |
+| \`${yankPop}\` | Cycle through the deleted text after pasting |
+| \`${undo}\` | Undo |
+
+**Other**
+| Key | Action |
+|-----|--------|
+| \`${tab}\` | Path completion / accept autocomplete |
+| \`${interrupt}\` | Cancel autocomplete / abort streaming |
+| \`${clear}\` | Clear editor (first) / exit (second) |
+| \`${exit}\` | Exit (when editor is empty) |
+| \`${suspend}\` | Suspend to background |
+| \`${cycleThinkingLevel}\` | Cycle thinking level |
+| \`${cycleModelForward}\` | Cycle models |
+| \`${selectModel}\` | Open model selector |
+| \`${expandTools}\` | Toggle tool output expansion |
+| \`${toggleThinking}\` | Toggle thinking block visibility |
+| \`${externalEditor}\` | Edit message in external editor |
+| \`${followUp}\` | Queue follow-up message |
+| \`${dequeue}\` | Restore queued messages |
+| \`Ctrl+V\` | Paste image from clipboard |
+| \`/\` | Slash commands |
+| \`!\` | Run bash command |
+| \`!!\` | Run bash command (excluded from context) |
+`;
+    // Add extension-registered shortcuts
+    const extensionRunner = ctx.session.extensionRunner;
+    if (extensionRunner) {
+        const shortcuts = extensionRunner.getShortcuts(ctx.keybindings.getEffectiveConfig());
+        if (shortcuts.size > 0) {
+            hotkeys += `
+**Extensions**
+| Key | Action |
+|-----|--------|
+`;
+            for (const [key, shortcut] of shortcuts) {
+                const description = shortcut.description ?? shortcut.extensionPath;
+                const keyDisplay = formatKeyForDisplay(key).replace(/\b\w/g, (c) => c.toUpperCase());
+                hotkeys += `| \`${keyDisplay}\` | ${description} |\n`;
+            }
+        }
+    }
+    ctx.chatContainer.addChild(new Spacer(1));
+    ctx.chatContainer.addChild(new DynamicBorder());
+    ctx.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "Keyboard Shortcuts")), 1, 0));
+    ctx.chatContainer.addChild(new Spacer(1));
+    ctx.chatContainer.addChild(new Markdown(hotkeys.trim(), 1, 1, ctx.getMarkdownThemeWithSettings()));
+    ctx.chatContainer.addChild(new DynamicBorder());
+    ctx.requestRender();
+}
+async function handleCompactCommand(customInstructions, ctx) {
+    const entries = ctx.sessionManager.getEntries();
+    const messageCount = entries.filter((e) => e.type === "message").length;
+    if (messageCount < 2) {
+        ctx.showWarning("Nothing to compact (no messages yet)");
+        return;
+    }
+    await ctx.executeCompaction(customInstructions, false);
+}
+function handleThinkingCommand(arg, ctx) {
+    if (!ctx.session.supportsThinking()) {
+        ctx.showStatus("Current model does not support thinking");
+        return;
+    }
+    const availableLevels = ctx.session.getAvailableThinkingLevels();
+    if (arg) {
+        const level = arg.toLowerCase();
+        if (!availableLevels.includes(level)) {
+            ctx.showStatus(`Invalid thinking level "${arg}". Available: ${availableLevels.join(", ")}`);
+            return;
+        }
+        ctx.session.setThinkingLevel(level);
+        ctx.invalidateFooter();
+        ctx.updateEditorBorderColor();
+        ctx.showStatus(`Thinking level: ${level}`);
+        return;
+    }
+    showThinkingSelector(ctx, availableLevels);
+}
+function showThinkingSelector(ctx, availableLevels) {
+    ctx.showSelector((done) => {
+        const selector = new SelectSubmenu("Thinking Level", "Select reasoning depth for thinking-capable models", availableLevels.map((level) => ({
+            value: level,
+            label: level,
+            description: THINKING_DESCRIPTIONS[level],
+        })), ctx.session.thinkingLevel, (value) => {
+            ctx.session.setThinkingLevel(value);
+            ctx.invalidateFooter();
+            ctx.updateEditorBorderColor();
+            done();
+            ctx.showStatus(`Thinking level: ${value}`);
+        }, () => {
+            done();
+        });
+        return { component: selector, focus: selector };
+    });
+}
+function handleEditModeCommand(arg, ctx) {
+    const modes = ["standard", "hashline"];
+    if (arg) {
+        const mode = arg.toLowerCase();
+        if (!modes.includes(mode)) {
+            ctx.showStatus(`Invalid edit mode "${arg}". Available: standard, hashline`);
+            return;
+        }
+        ctx.session.setEditMode(mode);
+        ctx.showStatus(`Edit mode: ${mode}${mode === "hashline" ? " (LINE#ID anchored edits)" : " (text-match edits)"}`);
+        return;
+    }
+    // Toggle
+    const current = ctx.session.editMode;
+    const next = current === "standard" ? "hashline" : "standard";
+    ctx.session.setEditMode(next);
+    ctx.showStatus(`Edit mode: ${next}${next === "hashline" ? " (LINE#ID anchored edits)" : " (text-match edits)"}`);
+}
+function handleArminSaysHi(ctx) {
+    ctx.chatContainer.addChild(new Spacer(1));
+    ctx.chatContainer.addChild(new ArminComponent(ctx.ui));
+    ctx.requestRender();
+}
+//# sourceMappingURL=slash-command-handlers.js.map