@travisennis/acai 0.0.1

package/source/commands/model-command.ts

@@ -0,0 +1,123 @@
+import {
+  formatModelInfo,
+  getModelsByCategory,
+  isValidModel,
+  type ModelName,
+  type ModelProvider,
+  modelRegistry,
+  models,
+  providers,
+} from "../models/providers.ts";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export function modelCommand(options: CommandOptions): ReplCommand {
+  const { terminal, modelManager } = options;
+
+  function switchModel(newModelName: ModelName) {
+    try {
+      // Get current and new model configs
+      const currentModelConfig = modelManager.getModelMetadata("repl");
+      const newModelConfig = modelRegistry[newModelName]; // Ensure modelRegistry is available
+
+      if (!newModelConfig) {
+        terminal.error(`Model configuration not found for: ${newModelName}`);
+        return;
+      }
+
+      // Check for capability differences
+      if (
+        currentModelConfig.supportsToolCalling &&
+        !newModelConfig.supportsToolCalling
+      ) {
+        terminal.warn(
+          "The new model doesn't support tool calling, which may limit functionality.",
+        );
+      }
+      if (
+        currentModelConfig.supportsReasoning &&
+        !newModelConfig.supportsReasoning
+      ) {
+        terminal.warn(
+          "The new model doesn't support reasoning, which may change response quality.",
+        );
+      }
+
+      // Update model in ModelManager
+      modelManager.setModel("repl", newModelName);
+
+      // Assuming ModelManager handles the actual model instance switching internally.
+      terminal.info(`Model set to ${newModelName}.`); // Simplified message
+    } catch (error) {
+      terminal.error(`Failed to switch model: ${(error as Error).message}`);
+    }
+  }
+
+  return {
+    command: "/model",
+    description:
+      "List available models or switch to a different model. Usage: /model [provider:model-name|category|provider]",
+    result: "continue",
+    getSubCommands: () => Promise.resolve(models as unknown as string[]),
+    async execute(args: string[]): Promise<void> {
+      const arg = args.join(" ").trim();
+      const modelConfig = modelManager.getModelMetadata("repl");
+
+      // No args - display current model and list available models by category
+      if (!arg) {
+        const currentModel = modelConfig.id;
+        terminal.header(`Current model: ${currentModel}`);
+        terminal.header("Available models by category:");
+
+        // Display models by category
+        for (const category of ["fast", "balanced", "powerful"] as const) {
+          // Use 'as const' for stricter typing
+          terminal.writeln(
+            `\n${category.charAt(0).toUpperCase() + category.slice(1)} models:`,
+          );
+          for (const model of getModelsByCategory(category)) {
+            terminal.writeln(formatModelInfo(model));
+          }
+        }
+        return;
+      }
+
+      // Switch to a specific model
+      if (isValidModel(arg)) {
+        // Call the standalone switchModel function
+        switchModel(arg as ModelName);
+        return;
+      }
+
+      // Display models by category
+      const categories = ["fast", "balanced", "powerful"];
+      if (categories.includes(arg)) {
+        terminal.header(
+          `${arg.charAt(0).toUpperCase() + arg.slice(1)} models:`,
+        );
+        // Need to assert arg is a valid category if the check passes
+        for (const model of getModelsByCategory(
+          arg as "fast" | "balanced" | "powerful",
+        )) {
+          terminal.writeln(formatModelInfo(model));
+        }
+        return;
+      }
+
+      // Display models by provider
+      if (providers.includes(arg as ModelProvider)) {
+        terminal.header(`Models from ${arg}:`);
+        // Need to ensure modelRegistry is accessible and correctly typed
+        for (const model of Object.values(modelRegistry).filter(
+          (m) => m.provider === arg,
+        )) {
+          terminal.writeln(formatModelInfo(model));
+        }
+        return;
+      }
+
+      // Invalid model name
+      terminal.error(`Invalid model name or category: ${arg}`);
+      terminal.info("Usage: /model [provider:model-name|category|provider]");
+    },
+  };
+}

package/source/commands/paste-command.ts

@@ -0,0 +1,62 @@
+import Clipboard from "@crosscopy/clipboard";
+import { formatBlock } from "../formatting.ts";
+import { logger } from "../logger.ts";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+const base64UrlRegex = /^data:(.*?);base64,/;
+
+export const pasteCommand = ({
+  terminal,
+  modelManager,
+  promptManager,
+}: CommandOptions): ReplCommand => {
+  return {
+    command: "/paste",
+    description:
+      "Pastes image or text content from the clipboard into the next prompt.",
+    result: "continue" as const,
+    getSubCommands: () => Promise.resolve([]),
+    execute: async () => {
+      try {
+        if (Clipboard.hasImage()) {
+          const base64DataUrl = await Clipboard.getImageBase64();
+          const mimeTypeMatch = base64DataUrl.match(base64UrlRegex);
+          const mimeType = mimeTypeMatch ? mimeTypeMatch[1] : "image/png";
+
+          promptManager.addContext({
+            type: "image",
+            image: base64DataUrl,
+            mediaType: mimeType,
+          });
+
+          terminal.success(
+            "Image from clipboard will be added to your next prompt.",
+          );
+          return;
+        }
+
+        const clipboardContent = await Clipboard.getText();
+        if (!clipboardContent || clipboardContent.trim() === "") {
+          terminal.warn("Clipboard is empty.");
+          return;
+        }
+
+        promptManager.addContext(
+          formatBlock(
+            clipboardContent,
+            "clipboard",
+            modelManager.getModelMetadata("repl").promptFormat,
+          ),
+        );
+
+        terminal.success(
+          "Clipboard content will be added to your next prompt.",
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        terminal.error(`Error processing clipboard content: ${message}`);
+        logger.error(error, "Paste command error:");
+      }
+    },
+  };
+};

package/source/commands/prompt-command.ts

@@ -0,0 +1,150 @@
+import { readdir, readFile } from "node:fs/promises";
+import path, { basename } from "node:path";
+import { processPrompt } from "../mentions.ts";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const promptCommand = ({
+  terminal,
+  modelManager,
+  promptManager,
+  config,
+}: CommandOptions): ReplCommand => {
+  return {
+    command: "/prompt",
+    description:
+      "Loads and executes prompts. Project prompts override user prompts with the same name.",
+    result: "use" as const,
+    getSubCommands: async (): Promise<string[]> => {
+      const getPromptNamesFromDir = async (
+        dirPath: string,
+      ): Promise<string[]> => {
+        try {
+          const dirents = await readdir(dirPath, { withFileTypes: true });
+          return dirents
+            .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md"))
+            .map((dirent) => basename(dirent.name, ".md"));
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+            return []; // Directory doesn't exist, return empty array
+          }
+          terminal.error(`Error reading prompts from ${dirPath}: ${error}`);
+          return []; // Return empty on other errors too, but log them
+        }
+      };
+
+      const userPromptDir = config.app.ensurePathSync("prompts"); // User prompts are global (~/.acai/prompts)
+      const projectPromptDir = config.project.ensurePathSync("prompts"); // Project prompts are local (./.acai/prompts)
+
+      const userPrompts = await getPromptNamesFromDir(userPromptDir);
+      const projectPrompts = await getPromptNamesFromDir(projectPromptDir);
+
+      // Combine and deduplicate, with project prompts taking precedence
+      const allPrompts = new Set([...userPrompts, ...projectPrompts]);
+      return Array.from(allPrompts).sort();
+    },
+    execute: async (args: string[]) => {
+      const promptName = args?.[0];
+      if (!promptName) {
+        terminal.warn(
+          "Please provide a prompt name. Usage: /prompt <prompt-name> [input...]",
+        );
+        return;
+      }
+
+      // Check for old format and provide helpful error
+      if (promptName.includes(":")) {
+        terminal.warn(
+          "The old format (user:name or project:name) is no longer supported. Use: /prompt <prompt-name> [input...]",
+        );
+        return;
+      }
+
+      try {
+        const promptResult = await findPrompt(promptName, config);
+
+        if (!promptResult) {
+          terminal.error(
+            `Prompt not found: ${promptName}. Available prompts can be seen with tab completion.`,
+          );
+          return;
+        }
+
+        let promptContent: string;
+        try {
+          promptContent = await readFile(promptResult.path, "utf8");
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+            terminal.error(
+              `Prompt file not found: ${promptName} at ${promptResult.path}`,
+            );
+            return;
+          }
+          throw error;
+        }
+
+        // Combine remaining arguments into a single string for input
+        const inputArgs = args.slice(1);
+        const inputString = inputArgs.join(" ");
+
+        // Replace {{INPUT}} placeholder with the input string
+        if (promptContent.includes("{{INPUT}}")) {
+          promptContent = promptContent.replace(/{{INPUT}}/g, inputString);
+        }
+
+        terminal.info(`Loaded ${promptResult.type} prompt: ${promptName}`);
+        if (inputArgs.length > 0) {
+          terminal.info(`Input: "${inputString}"`);
+        }
+
+        const processedPrompt = await processPrompt(promptContent, {
+          baseDir: process.cwd(),
+          model: modelManager.getModelMetadata("repl"),
+        });
+
+        for (const context of processedPrompt.context) {
+          promptManager.addContext(context);
+        }
+        promptManager.set(processedPrompt.message);
+      } catch (error) {
+        terminal.error(`Error loading prompt: ${(error as Error).message}`);
+      }
+    },
+  };
+};
+
+async function findPrompt(
+  promptName: string,
+  config: CommandOptions["config"],
+): Promise<{ path: string; type: "project" | "user" } | null> {
+  // Check project prompts first (they take precedence)
+  const projectPath = path.join(
+    config.project.ensurePathSync("prompts"),
+    `${promptName}.md`,
+  );
+
+  try {
+    await readFile(projectPath, "utf8");
+    return { path: projectPath, type: "project" };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw error; // Re-throw non-file-not-found errors
+    }
+  }
+
+  // Check user prompts if not found in project
+  const userPath = path.join(
+    config.app.ensurePathSync("prompts"),
+    `${promptName}.md`,
+  );
+
+  try {
+    await readFile(userPath, "utf8");
+    return { path: userPath, type: "user" };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw error; // Re-throw non-file-not-found errors
+    }
+  }
+
+  return null; // Prompt not found in either location
+}

package/source/commands/reset-command.ts

@@ -0,0 +1,22 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const resetCommand = ({
+  terminal,
+  messageHistory,
+}: CommandOptions): ReplCommand => {
+  return {
+    command: "/reset",
+    description: "Saves the chat history and then resets it.",
+    result: "continue" as const,
+    getSubCommands: () => Promise.resolve([]),
+    execute: async () => {
+      if (!messageHistory.isEmpty()) {
+        await messageHistory.save();
+        messageHistory.clear();
+      }
+      terminal.setTitle(`acai: ${process.cwd()}`);
+
+      terminal.clear();
+    },
+  };
+};

package/source/commands/rules-command.ts

@@ -0,0 +1,76 @@
+import { editor } from "@inquirer/prompts";
+import { config } from "../config.ts";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const rulesCommand = ({ terminal }: CommandOptions): ReplCommand => {
+  return {
+    command: "/rules",
+    description:
+      "View, add, or edit rules. Usage: /rules [view|add <text>|edit]",
+    result: "continue" as const,
+    getSubCommands: () => Promise.resolve(["view", "add", "edit"]),
+    execute: async (args: string[]) => {
+      const subCommand = args[0] ?? "view"; // Default to 'view'
+      const commandArgs = args.slice(1).join(" ");
+
+      try {
+        switch (subCommand) {
+          case "view": {
+            const currentContent = await config.readAgentsFile();
+            if (currentContent) {
+              terminal.writeln("--- Current Rules ---");
+              terminal.writeln(currentContent);
+              terminal.writeln("---------------------");
+            } else {
+              terminal.writeln(
+                "No rules defined yet. Use '/rules add' or '/rules edit'.",
+              );
+            }
+            break;
+          }
+
+          case "add": {
+            const newMemory = commandArgs.trim();
+            if (!newMemory) {
+              terminal.error("Error: Memory text cannot be empty for 'add'.");
+              terminal.writeln("Usage: /memory add <new memory text>");
+              return;
+            }
+            const currentContent = await config.readAgentsFile();
+            const updatedContent = currentContent
+              ? `${currentContent.trim()}\n- ${newMemory}` // Ensure space after dash
+              : `- ${newMemory}`; // Start with dash if new file
+            await config.writeAgentsFile(updatedContent);
+            break;
+          }
+
+          case "edit": {
+            const currentContent = await config.readAgentsFile();
+            const updatedContent = await editor({
+              message: "Edit rules:",
+              postfix: "md",
+              default: currentContent,
+            });
+            // Check if the user cancelled the edit (editor returns the original content)
+            // Or if the content is actually different
+            if (updatedContent !== currentContent) {
+              await config.writeAgentsFile(updatedContent);
+            } else {
+              terminal.writeln("Edit cancelled or no changes made.");
+            }
+            break;
+          }
+
+          default:
+            terminal.writeln(
+              "Invalid subcommand. Usage: /rules [view|add <text>|edit]",
+            );
+            break;
+        }
+      } catch (_error) {
+        // Errors from read/write helpers are already logged
+        terminal.error("Failed to execute memory command.");
+      }
+    },
+  };
+};

package/source/commands/save-command.ts

@@ -0,0 +1,20 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const saveCommand = ({
+  messageHistory,
+  terminal,
+}: CommandOptions): ReplCommand => {
+  return {
+    command: "/save",
+    description: "Saves the chat history.",
+    result: "continue" as const,
+    getSubCommands: () => Promise.resolve([]),
+    execute: async () => {
+      if (!messageHistory.isEmpty()) {
+        await messageHistory.save();
+      }
+
+      terminal.info("Message history saved.");
+    },
+  };
+};

package/source/commands/types.ts

@@ -0,0 +1,28 @@
+import type { ConfigManager } from "../config.ts";
+import type { MessageHistory } from "../messages.ts";
+import type { ModelManager } from "../models/manager.ts";
+import type { PromptManager } from "../prompts/manager.ts";
+import type { Terminal } from "../terminal/index.ts";
+import type { TokenTracker } from "../token-tracker.ts";
+import type { TokenCounter } from "../token-utils.ts";
+import type { Message } from "../tools/types.ts";
+
+export interface ReplCommand {
+  command: string;
+  aliases?: string[];
+  description: string;
+  result: "break" | "continue" | "use";
+  getSubCommands: () => Promise<string[]>;
+  execute: (args: string[]) => Promise<void>;
+}
+
+export interface CommandOptions {
+  promptManager: PromptManager;
+  modelManager: ModelManager;
+  terminal: Terminal;
+  messageHistory: MessageHistory;
+  tokenTracker: TokenTracker;
+  config: ConfigManager;
+  tokenCounter: TokenCounter;
+  toolEvents: Map<string, Message[]>;
+}

package/source/commands/usage-command.ts

@@ -0,0 +1,26 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export function usageCommand({
+  terminal,
+  tokenTracker,
+}: CommandOptions): ReplCommand {
+  return {
+    command: "/usage",
+    description: "Show token usage breakdown",
+    result: "continue",
+    getSubCommands: () => Promise.resolve([]),
+    execute() {
+      const entries = Object.entries(tokenTracker.getUsageBreakdown());
+      if (entries.length === 0) {
+        terminal.info("No usage yet.");
+      } else {
+        terminal.table(entries, {
+          header: ["App", "Tokens"],
+          colWidths: [30, 70],
+        });
+      }
+
+      return Promise.resolve();
+    },
+  };
+}