@travisennis/acai 0.0.1 → 0.0.3

package/source/commands/generate-rules-command.ts

@@ -1,82 +0,0 @@
-import { checkbox } from "@inquirer/prompts";
-import { analyzeConversation } from "../conversation-analyzer.ts";
-import { logger } from "../logger.ts"; // Import logger
-import type { CommandOptions, ReplCommand } from "./types.ts";
-
-async function _processAndSaveRules(
-  newRules: string[] | null,
-  terminal: CommandOptions["terminal"],
-  config: CommandOptions["config"], // Simplified type
-) {
-  if (!newRules || newRules.length === 0) {
-    terminal.warn("No new generalizable rules were identified.");
-    return;
-  }
-
-  terminal.info("Generated potential rules:");
-  terminal.lineBreak();
-
-  const rulesToKeep = await checkbox({
-    message: "Select the rules you want to keep:",
-    choices: newRules.map((rule) => ({ name: rule, value: rule })),
-  });
-
-  if (rulesToKeep.length === 0) {
-    terminal.warn("No rules selected to save.");
-    return;
-  }
-
-  terminal.info("Saving selected rules...");
-  const existingRules = await config.readProjectLearnedRulesFile();
-  const rulesToAdd = rulesToKeep.join("\n");
-  const updatedProjectRules =
-    existingRules.endsWith("\n") || existingRules.length === 0
-      ? `${existingRules}${rulesToAdd}`
-      : `${existingRules}\n${rulesToAdd}`;
-
-  await config.writeProjectLearnedRulesFile(updatedProjectRules);
-  terminal.success("Selected rules saved to project learned rules.");
-  terminal.lineBreak();
-  terminal.display(rulesToAdd); // Display only the saved rules
-}
-
-export const generateRulesCommand = ({
-  terminal,
-  messageHistory,
-  modelManager,
-  tokenTracker,
-  config, // This is the config module from CommandOptions
-}: CommandOptions): ReplCommand => {
-  return {
-    command: "/generate-rules",
-    description:
-      "Analyzes the current conversation to generate and save new interaction rules, then displays them.",
-    result: "continue" as const,
-    getSubCommands: () => Promise.resolve([]),
-    execute: async () => {
-      if (messageHistory.isEmpty()) {
-        terminal.writeln("Cannot generate rules from an empty conversation.");
-        return;
-      }
-
-      terminal.lineBreak();
-      terminal.info("Analyzing conversation to generate rules...");
-      try {
-        const newRules = await analyzeConversation({
-          modelManager,
-          messages: messageHistory.get(),
-          tokenTracker,
-          terminal,
-        });
-
-        // Pass the config object available in CommandOptions scope
-        await _processAndSaveRules(newRules, terminal, config);
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error ? error.message : String(error);
-        terminal.error(`Error generating rules: ${errorMessage}`);
-        logger.error(error, "Error during rule generation:");
-      }
-    },
-  };
-};

package/source/commands/help-command.ts

@@ -1,27 +0,0 @@
-import type { CommandOptions, ReplCommand } from "./types.ts";
-
-export const helpCommand = (
-  { terminal }: CommandOptions,
-  cmds: Map<string, ReplCommand>,
-): ReplCommand => {
-  return {
-    command: "/help",
-    description: "Shows available commands.",
-    result: "continue" as const,
-    getSubCommands: () => Promise.resolve([]),
-    execute: () => {
-      const commands = cmds;
-
-      const entries: [string, string][] = Array.from(commands.entries())
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([key, cmd]) => [key, cmd.description]);
-
-      terminal.table(entries, {
-        header: ["Command", "Description"],
-        colWidths: [30, 70],
-      });
-
-      return Promise.resolve();
-    },
-  };
-};

package/source/commands/init-command.ts

@@ -1,48 +0,0 @@
-import { platform } from "node:os";
-import { stepCountIs, streamText } from "ai";
-import { inGitDirectory } from "../tools/git-utils.ts";
-import { initTools } from "../tools/index.ts";
-import type { CommandOptions, ReplCommand } from "./types.ts";
-
-export const initCommand = ({
-  terminal,
-  modelManager,
-  tokenCounter,
-  toolEvents,
-}: CommandOptions): ReplCommand => {
-  return {
-    command: "/init",
-    description: "Creates the AGENTS.md file.",
-    result: "continue" as const,
-    getSubCommands: () => Promise.resolve([]),
-    execute: async () => {
-      const result = streamText({
-        model: modelManager.getModel("init-project"),
-        temperature: 0.5,
-        prompt: `Please analyze this codebase and create a AGENTS.md file containing:
-1. Build/lint/test commands - especially for running a single test
-2. Code style guidelines including imports, formatting, types, naming conventions, error handling, etc.
-
-The file you create will be given to agentic coding agents (such as yourself) that operate in this repository. Make it about 20 lines long.
-
-If there's already a AGENTS.md, improve it.
-If there are Cursor rules (in .cursor/rules/ or .cursorrules), Copilot rules (in .github/copilot-instructions.md), or Windsurf rules (in .windsurf/rules), make sure to include them.
-
-Your current working directory is ${process.cwd()}
-Is directory a git repo: ${(await inGitDirectory()) ? "Yes" : "No"}
-Platform: ${platform()}`,
-        stopWhen: stepCountIs(40),
-        tools: await initTools({
-          terminal,
-          tokenCounter,
-          events: toolEvents,
-          autoAcceptAll: true,
-        }),
-      });
-
-      for await (const text of result.textStream) {
-        terminal.write(text);
-      }
-    },
-  };
-};

package/source/commands/last-log-command.ts

@@ -1,88 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { editor } from "@inquirer/prompts";
-import chalk from "chalk";
-import { globby } from "globby";
-import { config } from "../config.ts";
-import type { CommandOptions, ReplCommand } from "./types.ts";
-
-const isoDateRegex = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)/;
-
-// Function to find the most recent log file
-async function findMostRecentLog(logDir: string): Promise<string | null> {
-  const logPattern = join(logDir, "*-repl-message.json");
-  const files = await globby(logPattern);
-
-  if (files.length === 0) {
-    return null;
-  }
-
-  const datedFiles = files
-    .map((file) => {
-      const filename = file.split("/").pop();
-      if (!filename) {
-        return null; // Skip if filename is somehow undefined
-      }
-      // Match the ISO date string at the beginning of the filename
-      const match = filename.match(isoDateRegex);
-      if (match?.[1]) {
-        try {
-          const date = new Date(match[1]);
-          // Check if the date is valid
-          if (!Number.isNaN(date.getTime())) {
-            return { file, date };
-          }
-        } catch (e) {
-          // Ignore files with invalid date strings
-          console.warn(`Could not parse date from filename: ${filename}`, e);
-        }
-      }
-      return null; // Exclude files that don't match the pattern or have invalid dates
-    })
-    .filter((item): item is { file: string; date: Date } => item !== null);
-
-  if (datedFiles.length === 0) {
-    return null; // No valid log files found
-  }
-
-  // Sort files by date (descending)
-  datedFiles.sort((a, b) => b.date.getTime() - a.date.getTime());
-
-  return datedFiles[0]?.file ?? null; // The first file is the most recent
-}
-
-export const lastLogCommand = ({ terminal }: CommandOptions): ReplCommand => {
-  return {
-    command: "/last-log",
-    description: "Opens the most recent REPL audit log in the editor.",
-    result: "continue" as const,
-    getSubCommands: () => Promise.resolve([]),
-    execute: async () => {
-      const logDir = config.app.ensurePathSync("audit");
-      const mostRecentLog = await findMostRecentLog(logDir);
-
-      if (!mostRecentLog) {
-        terminal.error(`No REPL audit logs found in '${logDir}'.`);
-        return;
-      }
-
-      try {
-        const content = await readFile(mostRecentLog, { encoding: "utf8" });
-
-        // Use the editor prompt to display the content (read-only)
-        await editor({
-          message: `Viewing ${chalk.green(mostRecentLog)}`,
-          postfix: ".json", // Set postfix for syntax highlighting if editor supports it
-          default: content,
-          // By not providing an onSubmit or similar handler to write the file,
-          // and not calling writeFileSync after, this effectively becomes read-only.
-        });
-        terminal.info("Closed log view");
-      } catch (error) {
-        terminal.error(
-          `Error reading or displaying log file ${mostRecentLog}: ${error}`,
-        );
-      }
-    },
-  };
-};

package/source/commands/manager.ts

@@ -1,151 +0,0 @@
-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";
-import { applicationLogCommand } from "./application-log-command.ts";
-import { clearCommand } from "./clear-command.ts";
-import { compactCommand } from "./compact-command.ts";
-import { copyCommand } from "./copy-command.ts";
-import { editCommand } from "./edit-command.ts";
-import { editPromptCommand } from "./edit-prompt-command.ts";
-import { exitCommand } from "./exit-command.ts";
-import { filesCommand } from "./files-command.ts";
-import { generateRulesCommand } from "./generate-rules-command.ts";
-import { helpCommand } from "./help-command.ts";
-import { initCommand } from "./init-command.ts";
-import { lastLogCommand } from "./last-log-command.ts";
-import { modelCommand } from "./model-command.ts";
-import { pasteCommand } from "./paste-command.ts";
-import { promptCommand } from "./prompt-command.ts";
-import { resetCommand } from "./reset-command.ts";
-import { rulesCommand } from "./rules-command.ts";
-import { saveCommand } from "./save-command.ts";
-import type { CommandOptions, ReplCommand } from "./types.ts";
-import { usageCommand } from "./usage-command.ts";
-
-export class CommandManager {
-  private commands: Map<string, ReplCommand>;
-  private promptManager: PromptManager;
-  private modelManager: ModelManager;
-  private messageHistory: MessageHistory;
-  private tokenTracker: TokenTracker;
-  private terminal: Terminal;
-  private config: ConfigManager;
-  private tokenCounter: TokenCounter;
-  private toolEvents: Map<string, Message[]>;
-
-  constructor({
-    promptManager,
-    modelManager,
-    terminal,
-    messageHistory,
-    tokenTracker,
-    config,
-    tokenCounter,
-    toolEvents,
-  }: CommandOptions) {
-    this.commands = new Map();
-    this.promptManager = promptManager;
-    this.modelManager = modelManager;
-    this.terminal = terminal;
-    this.messageHistory = messageHistory;
-    this.tokenTracker = tokenTracker;
-    this.config = config;
-    this.tokenCounter = tokenCounter;
-    this.toolEvents = toolEvents;
-    this.initializeCommmands();
-  }
-
-  initializeCommmands() {
-    // Import and register each command
-    const options: CommandOptions = {
-      promptManager: this.promptManager,
-      modelManager: this.modelManager,
-      terminal: this.terminal,
-      messageHistory: this.messageHistory,
-      tokenTracker: this.tokenTracker,
-      config: this.config,
-      tokenCounter: this.tokenCounter,
-      toolEvents: this.toolEvents,
-    };
-
-    // Register all commands
-    const cmds = [
-      clearCommand(options),
-      compactCommand(options),
-      editCommand(options),
-      editPromptCommand(options),
-      exitCommand(options),
-      filesCommand(options),
-      initCommand(options),
-      pasteCommand(options),
-      promptCommand(options),
-      resetCommand(options),
-      saveCommand(options),
-      rulesCommand(options),
-      modelCommand(options),
-      usageCommand(options),
-      lastLogCommand(options),
-      generateRulesCommand(options),
-      applicationLogCommand(options),
-      copyCommand(options),
-    ];
-
-    // Add help command with access to all commands
-    const helpCmd = helpCommand(options, this.commands);
-    cmds.push({
-      ...helpCmd,
-      execute: () => helpCmd.execute([]),
-    });
-
-    // Register all commands
-    for (const cmd of cmds) {
-      this.commands.set(cmd.command, cmd);
-      const aliases: string[] = cmd.aliases ?? [];
-      for (const alias of aliases) {
-        this.commands.set(alias, cmd);
-      }
-    }
-  }
-
-  getCommands() {
-    return Array.from(this.commands.keys()).sort();
-  }
-
-  async getSubCommands(command: string): Promise<string[]> {
-    return (await this.commands.get(command)?.getSubCommands()) ?? [];
-  }
-
-  async handle({ userInput }: { userInput: string }) {
-    const commandArgs = userInput.split(" ");
-    const command = commandArgs.at(0);
-    const args = commandArgs.slice(1);
-
-    if (command) {
-      const replCommand = this.commands.get(command);
-      if (replCommand) {
-        await replCommand.execute(args);
-        if (replCommand.result === "continue") {
-          return {
-            continue: true,
-            break: false,
-          };
-        }
-        if (replCommand.result === "break") {
-          return {
-            continue: false,
-            break: true,
-          };
-        }
-      }
-    }
-    return {
-      continue: false,
-      break: false,
-    };
-  }
-}

package/source/commands/model-command.ts

@@ -1,123 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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:");
-      }
-    },
-  };
-};