@travisennis/acai 0.0.5 → 0.0.6

package/dist/commands/model-command.js

@@ -1,4 +1,7 @@
 import { formatModelInfo, getModelsByCategory, isValidModel, modelRegistry, models, providers, } from "../models/providers.js";
+import { getTerminalSize } from "../terminal/formatting.js";
+import style from "../terminal/style.js";
+import { Container, Input, Spacer, Text, } from "../tui/index.js";
 export function modelCommand(options) {
     const { terminal, modelManager } = options;
     function switchModel(newModelName) {
@@ -80,5 +83,258 @@ export function modelCommand(options) {
             terminal.info("Usage: /model [provider:model-name|category|provider]");
             return "continue";
         },
+        async handle(args, { tui, container, inputContainer, editor, }) {
+            const arg = args.join(" ").trim();
+            const modelConfig = modelManager.getModelMetadata("repl");
+            // No args - display current model and list available models by category
+            if (!arg) {
+                // Create model selector with current model
+                const modelSelector = new ModelSelectorComponent(modelConfig.id, (model) => {
+                    // Apply the selected model
+                    modelManager.setModel("repl", model);
+                    // Hide selector and show editor again
+                    hideModelSelector(inputContainer, editor, tui);
+                    tui.requestRender();
+                }, () => {
+                    // Just hide the selector
+                    hideModelSelector(inputContainer, editor, tui);
+                    tui.requestRender();
+                });
+                // Replace editor with selector
+                inputContainer.clear();
+                inputContainer.addChild(modelSelector);
+                tui.setFocus(modelSelector);
+                tui.requestRender();
+                return "continue";
+            }
+            // Switch to a specific model
+            if (isValidModel(arg)) {
+                try {
+                    // Get current and new model configs
+                    const currentModelConfig = modelManager.getModelMetadata("repl");
+                    const newModelConfig = modelRegistry[arg];
+                    if (!newModelConfig) {
+                        container.addChild(new Text(style.red(`Model configuration not found for: ${arg}`), 1, 0));
+                        tui.requestRender();
+                        editor.setText("");
+                        return "continue";
+                    }
+                    // Check for capability differences
+                    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));
+                    }
+                    // Update model in ModelManager
+                    modelManager.setModel("repl", arg);
+                    // container.addChild(
+                    //   new Text(style.green(`Model set to ${arg}.`), 3, 0),
+                    // );
+                    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";
+                }
+            }
+            // // Display models by category
+            // const categories = ["fast", "balanced", "powerful"];
+            // if (categories.includes(arg)) {
+            //   container.addChild(
+            //     new Text(
+            //       `${arg.charAt(0).toUpperCase() + arg.slice(1)} models:`,
+            //       1,
+            //       0,
+            //     ),
+            //   );
+            //   let lineIndex = 2;
+            //   for (const model of getModelsByCategory(
+            //     arg as "fast" | "balanced" | "powerful",
+            //   )) {
+            //     container.addChild(new Text(formatModelInfo(model), lineIndex, 0));
+            //     lineIndex++;
+            //   }
+            //   tui.requestRender();
+            //   editor.setText("");
+            //   return "continue";
+            // }
+            // // Display models by provider
+            // if (providers.includes(arg as ModelProvider)) {
+            //   container.addChild(new Text(`Models from ${arg}:`, 0, 1));
+            //   let lineIndex = 2;
+            //   for (const model of Object.values(modelRegistry).filter(
+            //     (m) => m.provider === arg,
+            //   )) {
+            //     container.addChild(new Text(formatModelInfo(model), lineIndex, 0));
+            //     lineIndex++;
+            //   }
+            //   tui.requestRender();
+            //   editor.setText("");
+            //   return "continue";
+            // }
+            // // Invalid model name
+            // container.addChild(
+            //   new Text(style.red(`Invalid model name or category: ${arg}`), 0, 1),
+            // );
+            // container.addChild(
+            //   new Text(
+            //     style.dim("Usage: /model [provider:model-name|category|provider]"),
+            //     2,
+            //     0,
+            //   ),
+            // );
+            tui.requestRender();
+            editor.setText("");
+            return "continue";
+        },
     };
 }
+function hideModelSelector(editorContainer, editor, tui) {
+    // Replace selector with editor in the container
+    editorContainer.clear();
+    editorContainer.addChild(editor);
+    tui.setFocus(editor);
+}
+/**
+ * Component that renders a model selector with search
+ */
+export 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;
+        // Load all models
+        this.loadModels();
+        const { columns } = getTerminalSize();
+        // Add top border
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        this.addChild(new Spacer(1));
+        // Create search input
+        this.searchInput = new Input();
+        this.searchInput.onSubmit = () => {
+            // Enter on search input selects the first filtered item
+            if (this.filteredModels[this.selectedIndex]) {
+                this.handleSelect(this.filteredModels[this.selectedIndex]);
+            }
+        };
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        // Create list container
+        this.listContainer = new Container();
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        // Add bottom border
+        this.addChild(new Text(style.blue("─".repeat(columns)), 0, 0));
+        // Initial render
+        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);
+        // Show visible slice of filtered models
+        for (let i = startIndex; i < endIndex; i++) {
+            const item = this.filteredModels[i];
+            if (!item)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            const isCurrent = this.currentModel === item;
+            let line = "";
+            if (isSelected) {
+                const prefix = style.blue("→ ");
+                const modelText = `${item}`;
+                // const providerBadge = style.gray(`[${item.provider}]`);
+                const checkmark = isCurrent ? style.green(" ✓") : "";
+                line = `${prefix + style.blue(modelText)} ${checkmark}`;
+            }
+            else {
+                const modelText = `  ${item}`;
+                // const providerBadge = style.gray(`[${item.provider}]`);
+                const checkmark = isCurrent ? style.green(" ✓") : "";
+                line = `${modelText} ${checkmark}`;
+            }
+            this.listContainer.addChild(new Text(line, 0, 0));
+        }
+        // Add scroll indicator if needed
+        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));
+        }
+        // Show "no results" if empty
+        if (this.filteredModels.length === 0) {
+            this.listContainer.addChild(new Text(style.gray("  No matching models"), 0, 0));
+        }
+    }
+    handleInput(keyData) {
+        // Up arrow
+        if (keyData === "\x1b[A") {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.updateList();
+        }
+        // Down arrow
+        else if (keyData === "\x1b[B") {
+            this.selectedIndex = Math.min(this.filteredModels.length - 1, this.selectedIndex + 1);
+            this.updateList();
+        }
+        // Enter
+        else if (keyData === "\r") {
+            const selectedModel = this.filteredModels[this.selectedIndex];
+            if (selectedModel) {
+                this.handleSelect(selectedModel);
+            }
+        }
+        // Escape
+        else if (keyData === "\x1b") {
+            this.onCancelCallback();
+        }
+        // Pass everything else to search input
+        else {
+            this.searchInput.handleInput(keyData);
+            this.filterModels(this.searchInput.getValue());
+        }
+    }
+    handleSelect(model) {
+        this.onSelectCallback(model);
+    }
+    getSearchInput() {
+        return this.searchInput;
+    }
+}

package/dist/commands/paste-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paste-command.d.ts","sourceRoot":"","sources":["../../source/commands/paste-command.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAsH9D,eAAO,MAAM,YAAY,GAAI,0DAK1B,cAAc,KAAG,WAqHnB,CAAC"}
+{"version":3,"file":"paste-command.d.ts","sourceRoot":"","sources":["../../source/commands/paste-command.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAsH9D,eAAO,MAAM,YAAY,GAAI,0DAK1B,cAAc,KAAG,WAqRnB,CAAC"}

package/dist/commands/paste-command.js

@@ -1,6 +1,8 @@
 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";
 function extractBase64Content(dataUrl) {
     return dataUrl.replace(/^data:.*?;base64,/, "");
 }
@@ -181,5 +183,95 @@ export const pasteCommand = ({ terminal, modelManager, promptManager, tokenCount
             }
             return "continue";
         },
+        async handle(_args, { tui, container, editor, }) {
+            try {
+                if (Clipboard.hasImage()) {
+                    const base64DataUrl = await Clipboard.getImageBase64();
+                    // Validate the base64 data
+                    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";
+                    }
+                    // Extract MIME type with better error handling and actual image format detection
+                    let mimeType;
+                    try {
+                        // First, try to get MIME type from data URL
+                        const dataUrlMimeType = extractMimeTypeFromDataUrl(base64DataUrl);
+                        // Then, detect actual image format from base64 content
+                        const base64Content = extractBase64Content(base64DataUrl);
+                        const detectedFormat = detectImageFormatFromBase64(base64Content);
+                        // Use detected format if available, otherwise fall back to data URL MIME type
+                        if (detectedFormat !== "unknown") {
+                            mimeType = detectedFormat;
+                            // Log if there's a mismatch between data URL and actual format
+                            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";
+                    }
+                    // Ensure the data URL format is correct
+                    if (!base64DataUrl.startsWith(`data:${mimeType};base64,`)) {
+                        // Fix malformed data URLs
+                        const base64Content = base64DataUrl.replace(/^data:.*?;base64,/, "");
+                        const correctedDataUrl = `data:${mimeType};base64,${base64Content}`;
+                        // Final validation
+                        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/pickup-command.d.ts

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

package/dist/commands/pickup-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickup-command.d.ts","sourceRoot":"","sources":["../../source/commands/pickup-command.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,aAAa,GAAI,SAAS,cAAc,KAAG,WAoMvD,CAAC"}

package/dist/commands/pickup-command.js

@@ -0,0 +1,161 @@
+import { readdir, readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { createUserMessage } from "../messages.js";
+import style from "../terminal/style.js";
+import { Text } from "../tui/index.js";
+export const pickupCommand = (options) => {
+    return {
+        command: "/pickup",
+        description: "Loads a handoff file into a new session to continue previous work. Usage: /pickup <filename>",
+        getSubCommands: async () => {
+            const getHandoffFileNames = async () => {
+                try {
+                    const dirents = await readdir(options.workspace.primaryDir, {
+                        withFileTypes: true,
+                    });
+                    return dirents
+                        .filter((dirent) => dirent.isFile() && dirent.name.match(/^handoff-.*\.md$/))
+                        .map((dirent) => basename(dirent.name, ".md"));
+                }
+                catch (error) {
+                    if (error.code === "ENOENT") {
+                        return []; // Directory doesn't exist, return empty array
+                    }
+                    options.terminal.error(`Error reading handoff files: ${error}`);
+                    return []; // Return empty on other errors too, but log them
+                }
+            };
+            return await getHandoffFileNames();
+        },
+        execute: async (args) => {
+            const { terminal, messageHistory, modelManager } = options;
+            // Validate that filename is provided
+            const filename = args.join(" ").trim();
+            if (!filename) {
+                const availableFiles = await getAvailableHandoffFiles(options);
+                if (availableFiles.length === 0) {
+                    terminal.error("No handoff files found. Create a handoff file first using /handoff <purpose>");
+                }
+                else {
+                    terminal.error("Please specify a handoff file to load.");
+                    terminal.info("Available handoff files:");
+                    availableFiles.forEach((file) => {
+                        terminal.info(`  • ${file}.md`);
+                    });
+                }
+                return "continue";
+            }
+            // Ensure filename has .md extension for file operations
+            const filenameWithExt = filename.endsWith(".md")
+                ? filename
+                : `${filename}.md`;
+            const filepath = `${options.workspace.primaryDir}/${filenameWithExt}`;
+            try {
+                // Read the handoff file
+                const handoffContent = await readFile(filepath, "utf8");
+                terminal.info(`Loading handoff file: ${filenameWithExt}`);
+                // Create new session (like compact-command does)
+                messageHistory.create(modelManager.getModel("repl").modelId);
+                // Append handoff content as user message
+                messageHistory.appendUserMessage(createUserMessage([], handoffContent));
+                terminal.info("Handoff file loaded successfully into new session.");
+                terminal.info("You can now continue with your previous work.");
+                return "use";
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    terminal.error(`Handoff file not found: ${filenameWithExt}`);
+                    // Show available files as helpful suggestion
+                    const availableFiles = await getAvailableHandoffFiles(options);
+                    if (availableFiles.length > 0) {
+                        terminal.info("Available handoff files:");
+                        availableFiles.forEach((file) => {
+                            terminal.info(`  • ${file}.md`);
+                        });
+                    }
+                }
+                else {
+                    terminal.error(`Error reading handoff file: ${error}`);
+                }
+                return "continue";
+            }
+        },
+        async handle(args, { tui, container, editor, }) {
+            const { messageHistory, modelManager } = options;
+            // Validate that filename is provided
+            const filename = args.join(" ").trim();
+            if (!filename) {
+                const availableFiles = await getAvailableHandoffFiles(options);
+                if (availableFiles.length === 0) {
+                    container.addChild(new Text(style.red("No handoff files found. Create a handoff file first using /handoff <purpose>"), 1, 0));
+                }
+                else {
+                    container.addChild(new Text(style.red("Please specify a handoff file to load."), 0, 1));
+                    container.addChild(new Text("Available handoff files:", 2, 0));
+                    availableFiles.forEach((file, index) => {
+                        container.addChild(new Text(`  • ${file}.md`, 3 + index, 0));
+                    });
+                }
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+            // Ensure filename has .md extension for file operations
+            const filenameWithExt = filename.endsWith(".md")
+                ? filename
+                : `${filename}.md`;
+            const filepath = `${options.workspace.primaryDir}/${filenameWithExt}`;
+            try {
+                // Read the handoff file
+                const handoffContent = await readFile(filepath, "utf8");
+                container.addChild(new Text(`Loading handoff file: ${style.blue(filenameWithExt)}`, 1, 0));
+                // Create new session (like compact-command does)
+                messageHistory.create(modelManager.getModel("repl").modelId);
+                // Append handoff content as user message
+                messageHistory.appendUserMessage(createUserMessage([], handoffContent));
+                container.addChild(new Text(style.green("Handoff file loaded successfully into new session."), 2, 0));
+                container.addChild(new Text("You can now continue with your previous work.", 3, 0));
+                tui.requestRender();
+                editor.setText("");
+                return "use";
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    container.addChild(new Text(style.red(`Handoff file not found: ${filenameWithExt}`), 1, 0));
+                    // Show available files as helpful suggestion
+                    const availableFiles = await getAvailableHandoffFiles(options);
+                    if (availableFiles.length > 0) {
+                        container.addChild(new Text("Available handoff files:", 2, 0));
+                        availableFiles.forEach((file, index) => {
+                            container.addChild(new Text(`  • ${file}.md`, 3 + index, 0));
+                        });
+                    }
+                }
+                else {
+                    container.addChild(new Text(style.red(`Error reading handoff file: ${error}`), 0, 1));
+                }
+                tui.requestRender();
+                editor.setText("");
+                return "continue";
+            }
+        },
+    };
+};
+async function getAvailableHandoffFiles(options) {
+    try {
+        const dirents = await readdir(options.workspace.primaryDir, {
+            withFileTypes: true,
+        });
+        return dirents
+            .filter((dirent) => dirent.isFile() && dirent.name.match(/^handoff-.*\.md$/))
+            .map((dirent) => basename(dirent.name, ".md"))
+            .sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        options.terminal.error(`Error reading handoff files: ${error}`);
+        return [];
+    }
+}

package/dist/commands/prompt-command.d.ts

@@ -1,3 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
-export declare const promptCommand: ({ terminal, modelManager, promptManager, config, promptHistory, }: CommandOptions) => ReplCommand;
+export declare const promptCommand: ({ terminal, modelManager, promptManager, config, promptHistory, workspace, }: CommandOptions) => ReplCommand;
 //# sourceMappingURL=prompt-command.d.ts.map

package/dist/commands/prompt-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-command.d.ts","sourceRoot":"","sources":["../../source/commands/prompt-command.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,aAAa,GAAI,mEAM3B,cAAc,KAAG,WAuHnB,CAAC"}
+{"version":3,"file":"prompt-command.d.ts","sourceRoot":"","sources":["../../source/commands/prompt-command.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,aAAa,GAAI,8EAO3B,cAAc,KAAG,WAgPnB,CAAC"}