@travisennis/acai 0.0.6 → 0.0.8

package/dist/commands/model/index.js

@@ -0,0 +1,182 @@
+import { isValidModel, modelRegistry, models, } from "../../models/providers.js";
+import { getTerminalSize, isArrowDown, isArrowUp, isEnter, isEscape, } from "../../terminal/control.js";
+import style from "../../terminal/style.js";
+import { Container, Input, Spacer, Text, } from "../../tui/index.js";
+import { hideModelSelector } from "./utils.js";
+export function modelCommand(options) {
+    const { modelManager } = options;
+    return {
+        command: "/model",
+        description: "List available models or switch to a different model. Usage: /model [provider:model-name|provider]",
+        getSubCommands: () => Promise.resolve(models),
+        async handle(args, { tui, container, inputContainer, editor, }) {
+            const arg = args.join(" ").trim();
+            const modelConfig = modelManager.getModelMetadata("repl");
+            if (!arg) {
+                const modelSelector = new ModelSelectorComponent(modelConfig.id, (model) => {
+                    modelManager.setModel("repl", model);
+                    hideModelSelector(inputContainer, editor, tui);
+                    tui.requestRender();
+                }, () => {
+                    hideModelSelector(inputContainer, editor, tui);
+                    tui.requestRender();
+                });
+                inputContainer.clear();
+                inputContainer.addChild(modelSelector);
+                tui.setFocus(modelSelector);
+                tui.requestRender();
+                return "continue";
+            }
+            if (isValidModel(arg)) {
+                try {
+                    const currentModelConfig = modelManager.getModelMetadata("repl");
+                    const newModelConfig = modelRegistry[arg];
+                    if (newModelConfig === undefined) {
+                        container.addChild(new Text(style.red(`Model configuration not found for: ${arg}`), 1, 0));
+                        tui.requestRender();
+                        editor.setText("");
+                        return "continue";
+                    }
+                    if (currentModelConfig.supportsToolCalling &&
+                        !newModelConfig.supportsToolCalling) {
+                        container.addChild(new Text(style.yellow("The new model doesn't support tool calling, which may limit functionality."), 1, 0));
+                    }
+                    if (currentModelConfig.supportsReasoning &&
+                        !newModelConfig.supportsReasoning) {
+                        container.addChild(new Text(style.yellow("The new model doesn't support reasoning, which may change response quality."), 2, 0));
+                    }
+                    modelManager.setModel("repl", arg);
+                    tui.requestRender();
+                    editor.setText("");
+                    return "continue";
+                }
+                catch (error) {
+                    container.addChild(new Text(style.red(`Failed to switch model: ${error.message}`), 0, 0));
+                    tui.requestRender();
+                    editor.setText("");
+                    return "continue";
+                }
+            }
+            tui.requestRender();
+            editor.setText("");
+            return "continue";
+        },
+    };
+}
+class ModelSelectorComponent extends Container {
+    searchInput;
+    listContainer;
+    allModels = [];
+    filteredModels = [];
+    selectedIndex = 0;
+    currentModel;
+    onSelectCallback;
+    onCancelCallback;
+    constructor(currentModel, onSelect, onCancel) {
+        super();
+        this.currentModel = currentModel;
+        this.onSelectCallback = onSelect;
+        this.onCancelCallback = onCancel;
+        this.loadModels();
+        const { columns } = getTerminalSize();
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        this.addChild(new Spacer(1));
+        this.searchInput = new Input();
+        this.searchInput.onSubmit = () => {
+            const model = this.filteredModels[this.selectedIndex];
+            if (model !== undefined) {
+                this.handleSelect(model);
+            }
+        };
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        this.listContainer = new Container();
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        this.updateList();
+    }
+    loadModels() {
+        this.allModels = models;
+        this.filteredModels = models;
+    }
+    filterModels(query) {
+        if (!query.trim()) {
+            this.filteredModels = this.allModels;
+        }
+        else {
+            const searchTokens = query
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((t) => t);
+            this.filteredModels = this.allModels.filter((model) => {
+                const searchText = `${model}`.toLowerCase();
+                return searchTokens.every((token) => searchText.includes(token));
+            });
+        }
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredModels.length - 1));
+        this.updateList();
+    }
+    updateList() {
+        this.listContainer.clear();
+        const maxVisible = 10;
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), this.filteredModels.length - maxVisible));
+        const endIndex = Math.min(startIndex + maxVisible, this.filteredModels.length);
+        for (let i = startIndex; i < endIndex; i++) {
+            const item = this.filteredModels[i];
+            if (item === undefined)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            const isCurrent = this.currentModel === item;
+            let line = "";
+            if (isSelected) {
+                const prefix = style.blue("→ ");
+                const modelText = `${item}`;
+                const checkmark = isCurrent ? style.green(" ✓") : "";
+                line = `${prefix + style.blue(modelText)} ${checkmark}`;
+            }
+            else {
+                const modelText = `  ${item}`;
+                const checkmark = isCurrent ? style.green(" ✓") : "";
+                line = `${modelText} ${checkmark}`;
+            }
+            this.listContainer.addChild(new Text(line, 0, 0));
+        }
+        if (startIndex > 0 || endIndex < this.filteredModels.length) {
+            const scrollInfo = style.gray(`  (${this.selectedIndex + 1}/${this.filteredModels.length})`);
+            this.listContainer.addChild(new Text(scrollInfo, 0, 0));
+        }
+        if (this.filteredModels.length === 0) {
+            this.listContainer.addChild(new Text(style.gray("  No matching models"), 0, 0));
+        }
+    }
+    handleInput(keyData) {
+        if (isArrowUp(keyData)) {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.updateList();
+        }
+        else if (isArrowDown(keyData)) {
+            this.selectedIndex = Math.min(this.filteredModels.length - 1, this.selectedIndex + 1);
+            this.updateList();
+        }
+        else if (isEnter(keyData)) {
+            const selectedModel = this.filteredModels[this.selectedIndex];
+            if (selectedModel !== undefined) {
+                this.handleSelect(selectedModel);
+            }
+        }
+        else if (isEscape(keyData)) {
+            this.onCancelCallback();
+        }
+        else {
+            this.searchInput.handleInput(keyData);
+            this.filterModels(this.searchInput.getValue());
+        }
+    }
+    handleSelect(model) {
+        this.onSelectCallback(model);
+    }
+    getSearchInput() {
+        return this.searchInput;
+    }
+}

package/dist/commands/model/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Container, Editor, TUI } from "../../tui/index.ts";
+export declare function hideModelSelector(editorContainer: Container, editor: Editor, tui: TUI): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/commands/model/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/commands/model/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAEjE,wBAAgB,iBAAiB,CAC/B,eAAe,EAAE,SAAS,EAC1B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,GAAG,GACP,IAAI,CAIN"}

package/dist/commands/model/utils.js

@@ -0,0 +1,5 @@
+export function hideModelSelector(editorContainer, editor, tui) {
+    editorContainer.clear();
+    editorContainer.addChild(editor);
+    tui.setFocus(editor);
+}

package/dist/commands/paste/index.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "../types.ts";
+export declare const pasteCommand: ({ modelManager, promptManager, tokenCounter, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/paste/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/paste/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAO/D,eAAO,MAAM,YAAY,GAAI,gDAI1B,cAAc,KAAG,WAiKnB,CAAC"}

package/dist/commands/paste/index.js

@@ -0,0 +1,94 @@
+import Clipboard from "@crosscopy/clipboard";
+import { formatBlock } from "../../formatting.js";
+import { logger } from "../../logger.js";
+import style from "../../terminal/style.js";
+import { Text } from "../../tui/index.js";
+import { detectImageFormatFromBase64, extractMimeTypeFromDataUrl, isValidBase64, } from "./utils.js";
+export const pasteCommand = ({ modelManager, promptManager, tokenCounter, }) => {
+    return {
+        command: "/paste",
+        description: "Pastes image or text content from the clipboard into the next prompt.",
+        getSubCommands: () => Promise.resolve([]),
+        async handle(_args, { tui, container, editor, }) {
+            try {
+                if (Clipboard.hasImage()) {
+                    const base64DataUrl = await Clipboard.getImageBase64();
+                    if (!isValidBase64(base64DataUrl)) {
+                        container.addChild(new Text(style.red("Invalid base64 data in clipboard. The image data may be corrupted."), 1, 0));
+                        tui.requestRender();
+                        editor.setText("");
+                        return "continue";
+                    }
+                    let mimeType;
+                    try {
+                        const dataUrlMimeType = extractMimeTypeFromDataUrl(base64DataUrl);
+                        const base64Content = base64DataUrl.replace(/^data:.*?;base64,/, "");
+                        const detectedFormat = detectImageFormatFromBase64(base64Content);
+                        if (detectedFormat !== "unknown") {
+                            mimeType = detectedFormat;
+                            if (dataUrlMimeType !== detectedFormat) {
+                                logger.warn(`Clipboard library reported ${dataUrlMimeType} but actual image format is ${detectedFormat}. Using detected format.`);
+                            }
+                        }
+                        else {
+                            mimeType = dataUrlMimeType;
+                            logger.warn(`Could not detect image format, using data URL MIME type: ${mimeType}`);
+                        }
+                    }
+                    catch (error) {
+                        logger.warn(`Failed to extract MIME type from clipboard image: ${error}`);
+                        mimeType = "image/png";
+                    }
+                    if (!base64DataUrl.startsWith(`data:${mimeType};base64,`)) {
+                        const base64Content = base64DataUrl.replace(/^data:.*?;base64,/, "");
+                        const correctedDataUrl = `data:${mimeType};base64,${base64Content}`;
+                        if (!isValidBase64(correctedDataUrl)) {
+                            container.addChild(new Text(style.red("Failed to correct base64 data format. The image data may be corrupted."), 1, 0));
+                            tui.requestRender();
+                            editor.setText("");
+                            return "continue";
+                        }
+                        promptManager.addContext({
+                            type: "image",
+                            image: correctedDataUrl,
+                            mediaType: mimeType,
+                        });
+                    }
+                    else {
+                        promptManager.addContext({
+                            type: "image",
+                            image: base64DataUrl,
+                            mediaType: mimeType,
+                        });
+                    }
+                    container.addChild(new Text(style.green("Image from clipboard will be added to your next prompt."), 1, 0));
+                    tui.requestRender();
+                    editor.setText("");
+                    return "continue";
+                }
+                const clipboardContent = await Clipboard.getText();
+                if (!clipboardContent || clipboardContent.trim() === "") {
+                    container.addChild(new Text(style.yellow("Clipboard is empty."), 0, 1));
+                    tui.requestRender();
+                    editor.setText("");
+                    return "continue";
+                }
+                const content = formatBlock(clipboardContent, "clipboard", modelManager.getModelMetadata("repl").promptFormat);
+                promptManager.addContext(content);
+                const tokenCount = tokenCounter.count(content);
+                container.addChild(new Text(style.green(`Clipboard content will be added to your next prompt. (${tokenCount} tokens)`), 1, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                container.addChild(new Text(style.red(`Error processing clipboard content: ${message}`), 1, 0));
+                logger.error(error, "Paste command error:");
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+        },
+    };
+};

package/dist/commands/paste/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function extractBase64Content(dataUrl: string): string;
+export declare function isValidBase64(str: string): boolean;
+export declare function detectImageFormatFromBase64(base64Content: string): string;
+export declare function extractMimeTypeFromDataUrl(dataUrl: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/commands/paste/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/commands/paste/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAWlD;AAED,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAiFzE;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGlE"}

package/dist/commands/paste/utils.js

@@ -0,0 +1,86 @@
+export function extractBase64Content(dataUrl) {
+    return dataUrl.replace(/^data:.*?;base64,/, "");
+}
+export function isValidBase64(str) {
+    try {
+        const base64Content = extractBase64Content(str);
+        const decoded = Buffer.from(base64Content, "base64");
+        const reEncoded = decoded.toString("base64");
+        const normalizedOriginal = base64Content.replace(/=/g, "");
+        const normalizedReEncoded = reEncoded.replace(/=/g, "");
+        return normalizedOriginal === normalizedReEncoded;
+    }
+    catch {
+        return false;
+    }
+}
+export function detectImageFormatFromBase64(base64Content) {
+    try {
+        const buffer = Buffer.from(base64Content, "base64");
+        if (buffer.length >= 3 &&
+            buffer[0] === 0xff &&
+            buffer[1] === 0xd8 &&
+            buffer[2] === 0xff) {
+            return "image/jpeg";
+        }
+        if (buffer.length >= 8 &&
+            buffer[0] === 0x89 &&
+            buffer[1] === 0x50 &&
+            buffer[2] === 0x4e &&
+            buffer[3] === 0x47 &&
+            buffer[4] === 0x0d &&
+            buffer[5] === 0x0a &&
+            buffer[6] === 0x1a &&
+            buffer[7] === 0x0a) {
+            return "image/png";
+        }
+        if (buffer.length >= 6 &&
+            ((buffer[0] === 0x47 &&
+                buffer[1] === 0x49 &&
+                buffer[2] === 0x46 &&
+                buffer[3] === 0x38 &&
+                buffer[4] === 0x37 &&
+                buffer[5] === 0x61) ||
+                (buffer[0] === 0x47 &&
+                    buffer[1] === 0x49 &&
+                    buffer[2] === 0x46 &&
+                    buffer[3] === 0x38 &&
+                    buffer[4] === 0x39 &&
+                    buffer[5] === 0x61))) {
+            return "image/gif";
+        }
+        if (buffer.length >= 12 &&
+            buffer[0] === 0x52 &&
+            buffer[1] === 0x49 &&
+            buffer[2] === 0x46 &&
+            buffer[3] === 0x46 &&
+            buffer[8] === 0x57 &&
+            buffer[9] === 0x45 &&
+            buffer[10] === 0x42 &&
+            buffer[11] === 0x50) {
+            return "image/webp";
+        }
+        if (buffer.length >= 2 && buffer[0] === 0x42 && buffer[1] === 0x4d) {
+            return "image/bmp";
+        }
+        if (buffer.length >= 4 &&
+            ((buffer[0] === 0x49 &&
+                buffer[1] === 0x49 &&
+                buffer[2] === 0x2a &&
+                buffer[3] === 0x00) ||
+                (buffer[0] === 0x4d &&
+                    buffer[1] === 0x4d &&
+                    buffer[2] === 0x00 &&
+                    buffer[3] === 0x2a))) {
+            return "image/tiff";
+        }
+        return "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export function extractMimeTypeFromDataUrl(dataUrl) {
+    const match = dataUrl.match(/^data:([^;]+);base64,/);
+    return match?.[1] ?? "image/png";
+}

package/dist/commands/pickup/index.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "../types.ts";
+export declare const pickupCommand: (options: CommandOptions) => ReplCommand;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/pickup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/pickup/index.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAQ/D,eAAO,MAAM,aAAa,GAAI,SAAS,cAAc,KAAG,WA0DvD,CAAC"}

package/dist/commands/pickup/index.js

@@ -0,0 +1,138 @@
+import { getTerminalSize, isArrowDown, isArrowUp, isEnter, isEscape, } from "../../terminal/control.js";
+import style from "../../terminal/style.js";
+import { Input, Spacer, Text, Container as TuiContainer, } from "../../tui/index.js";
+import { getAvailableHandoffFiles, hidePickupSelector, loadHandoff, } from "./utils.js";
+export const pickupCommand = (options) => {
+    return {
+        command: "/pickup",
+        description: "Loads a handoff file into a new session to continue previous work. Usage: /pickup",
+        getSubCommands: () => Promise.resolve([]),
+        async handle(_args, { tui, container, inputContainer, editor, }) {
+            const handoffs = await getAvailableHandoffFiles();
+            if (handoffs.length === 0) {
+                container.addChild(new Text(style.yellow("No handoff files found."), 0, 1));
+                container.addChild(new Text("Create a handoff file first using /handoff <purpose>", 1, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            const handoffSelector = new HandoffSelectorComponent(handoffs, async (handoff) => {
+                await loadHandoff(handoff, options, container, tui, editor);
+                hidePickupSelector(inputContainer, editor, tui);
+            }, () => {
+                hidePickupSelector(inputContainer, editor, tui);
+            });
+            inputContainer.clear();
+            inputContainer.addChild(handoffSelector);
+            tui.setFocus(handoffSelector);
+            tui.requestRender();
+            return "continue";
+        },
+    };
+};
+class HandoffSelectorComponent extends TuiContainer {
+    searchInput;
+    listContainer;
+    allHandoffs = [];
+    filteredHandoffs = [];
+    selectedIndex = 0;
+    onSelectCallback;
+    onCancelCallback;
+    constructor(handoffs, onSelect, onCancel) {
+        super();
+        this.onSelectCallback = onSelect;
+        this.onCancelCallback = onCancel;
+        this.allHandoffs = handoffs;
+        this.filteredHandoffs = handoffs;
+        const { columns } = getTerminalSize();
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        this.addChild(new Spacer(1));
+        this.searchInput = new Input();
+        this.searchInput.onSubmit = () => {
+            const handoff = this.filteredHandoffs[this.selectedIndex];
+            if (handoff !== undefined) {
+                this.handleSelect(handoff);
+            }
+        };
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        this.listContainer = new TuiContainer();
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        this.updateList();
+    }
+    filterHandoffs(query) {
+        if (!query.trim()) {
+            this.filteredHandoffs = this.allHandoffs;
+        }
+        else {
+            const searchTokens = query
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((t) => t);
+            this.filteredHandoffs = this.allHandoffs.filter((handoff) => {
+                const searchText = handoff.name.toLowerCase();
+                return searchTokens.every((token) => searchText.includes(token));
+            });
+        }
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredHandoffs.length - 1));
+        this.updateList();
+    }
+    updateList() {
+        this.listContainer.clear();
+        const maxVisible = 10;
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), this.filteredHandoffs.length - maxVisible));
+        const endIndex = Math.min(startIndex + maxVisible, this.filteredHandoffs.length);
+        for (let i = startIndex; i < endIndex; i++) {
+            const handoff = this.filteredHandoffs[i];
+            if (handoff === undefined)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            let line = "";
+            if (isSelected) {
+                const prefix = style.blue("→ ");
+                const date = handoff.createdAt.toLocaleString();
+                line = `${prefix + style.blue(handoff.name)} ${style.gray(`(${date})`)}`;
+            }
+            else {
+                const date = handoff.createdAt.toLocaleString();
+                line = `  ${handoff.name} ${style.gray(`(${date})`)}`;
+            }
+            this.listContainer.addChild(new Text(line, 0, 0));
+        }
+        if (startIndex > 0 || endIndex < this.filteredHandoffs.length) {
+            const scrollInfo = style.gray(`  (${this.selectedIndex + 1}/${this.filteredHandoffs.length})`);
+            this.listContainer.addChild(new Text(scrollInfo, 0, 0));
+        }
+        if (this.filteredHandoffs.length === 0) {
+            this.listContainer.addChild(new Text(style.gray("  No matching handoffs"), 0, 0));
+        }
+    }
+    handleInput(keyData) {
+        if (isArrowUp(keyData)) {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.updateList();
+        }
+        else if (isArrowDown(keyData)) {
+            this.selectedIndex = Math.min(this.filteredHandoffs.length - 1, this.selectedIndex + 1);
+            this.updateList();
+        }
+        else if (isEnter(keyData)) {
+            const selectedHandoff = this.filteredHandoffs[this.selectedIndex];
+            if (selectedHandoff !== undefined) {
+                this.handleSelect(selectedHandoff);
+            }
+        }
+        else if (isEscape(keyData)) {
+            this.onCancelCallback();
+        }
+        else {
+            this.searchInput.handleInput(keyData);
+            this.filterHandoffs(this.searchInput.getValue());
+        }
+    }
+    handleSelect(handoff) {
+        this.onSelectCallback(handoff);
+    }
+}

package/dist/commands/pickup/types.d.ts

@@ -0,0 +1,6 @@
+export interface HandoffFile {
+    name: string;
+    filename: string;
+    createdAt: Date;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/pickup/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../source/commands/pickup/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;CACjB"}

package/dist/commands/pickup/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/pickup/utils.d.ts

@@ -0,0 +1,7 @@
+import type { Container, Editor, TUI } from "../../tui/index.ts";
+import type { CommandOptions } from "../types.ts";
+import type { HandoffFile } from "./types.ts";
+export declare function hidePickupSelector(editorContainer: Container, editor: Editor, tui: TUI): void;
+export declare function getAvailableHandoffFiles(): Promise<HandoffFile[]>;
+export declare function loadHandoff(handoff: HandoffFile, options: CommandOptions, container: Container, tui: TUI, editor: Editor): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/commands/pickup/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/commands/pickup/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,wBAAgB,kBAAkB,CAChC,eAAe,EAAE,SAAS,EAC1B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,GAAG,GACP,IAAI,CAIN;AAED,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CA4BvE;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CA8Cf"}

package/dist/commands/pickup/utils.js

@@ -0,0 +1,56 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { createUserMessage } from "../../sessions/manager.js";
+export function hidePickupSelector(editorContainer, editor, tui) {
+    editorContainer.clear();
+    editorContainer.addChild(editor);
+    tui.setFocus(editor);
+}
+export async function getAvailableHandoffFiles() {
+    const handoffsDir = ".acai/handoffs";
+    try {
+        const { readdir, stat } = await import("node:fs/promises");
+        const dirents = await readdir(handoffsDir, {
+            withFileTypes: true,
+        });
+        const files = [];
+        for (const dirent of dirents) {
+            if (dirent.isFile() && dirent.name.match(/^handoff-.*\.md$/)) {
+                const filepath = `${handoffsDir}/${dirent.name}`;
+                const stats = await stat(filepath);
+                files.push({
+                    name: basename(dirent.name, ".md"),
+                    filename: dirent.name,
+                    createdAt: stats.mtime,
+                });
+            }
+        }
+        files.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return files;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        return [];
+    }
+}
+export async function loadHandoff(handoff, options, container, tui, editor) {
+    const { sessionManager: messageHistory, modelManager } = options;
+    const filepath = `.acai/handoffs/${handoff.filename}`;
+    try {
+        const handoffContent = await readFile(filepath, "utf8");
+        container.addChild(new (await import("../../tui/index.js")).Text(`Loading handoff: ${(await import("../../terminal/style.js")).default.blue(handoff.name)}`, 0, 1));
+        messageHistory.create(modelManager.getModel("repl").modelId);
+        messageHistory.appendUserMessage(createUserMessage([], handoffContent));
+        container.addChild(new (await import("../../tui/index.js")).Text("Handoff loaded successfully.", 1, 0));
+        container.addChild(new (await import("../../tui/index.js")).Text("You can now continue with your previous work.", 2, 0));
+        tui.requestRender();
+        editor.setText("");
+    }
+    catch (error) {
+        container.addChild(new (await import("../../tui/index.js")).Text(`Error loading handoff: ${error}`, 0, 1));
+        tui.requestRender();
+        editor.setText("");
+    }
+}

package/dist/commands/prompt/index.d.ts

@@ -0,0 +1,5 @@
+import type { CommandOptions, ReplCommand } from "../types.ts";
+import type { PromptMetadata } from "./types.ts";
+export declare function loadPrompts(config: CommandOptions["config"]): Promise<Map<string, PromptMetadata>>;
+export declare const promptCommand: ({ modelManager, promptManager, config, promptHistory, workspace, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/prompt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/commands/prompt/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAOjD,wBAAsB,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,wCA0DjE;AAED,eAAO,MAAM,aAAa,GAAI,oEAM3B,cAAc,KAAG,WAuHnB,CAAC"}