@travisennis/acai 0.0.1

package/source/commands/copy-command.ts

@@ -0,0 +1,55 @@
+import Clipboard from "@crosscopy/clipboard";
+import type { ModelMessage, TextPart } from "ai";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+function extractLastAssistantText(messages: ModelMessage[]): string | null {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i] as ModelMessage | undefined;
+    if (!msg) continue;
+    if (msg.role !== "assistant") continue;
+    if (!("content" in msg) || !Array.isArray(msg.content)) continue;
+
+    // Find last text part
+    for (let j = msg.content.length - 1; j >= 0; j--) {
+      const part = msg.content[j];
+      if (
+        part &&
+        part.type === "text" &&
+        typeof (part as TextPart).text === "string"
+      ) {
+        const text = (part as TextPart).text;
+        if (text.trim().length > 0) return text;
+      }
+    }
+  }
+  return null;
+}
+
+export function copyCommand(options: CommandOptions): ReplCommand {
+  return {
+    command: "/copy",
+    description: "Copy the last assistant response to the clipboard",
+    result: "continue",
+    async getSubCommands() {
+      return [];
+    },
+    async execute(_args: string[]) {
+      const { messageHistory, terminal } = options;
+      const history = messageHistory.get();
+
+      const lastText = extractLastAssistantText(history);
+      if (!lastText) {
+        terminal.info("No assistant response to copy.");
+        return;
+      }
+
+      try {
+        await Clipboard.setText(lastText);
+        terminal.success("Copied last response to clipboard.");
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        terminal.error(`Could not copy to clipboard: ${message}`);
+      }
+    },
+  };
+}

package/source/commands/edit-command.ts

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import { editor, search } from "@inquirer/prompts";
+import { globby } from "globby";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const editCommand = ({ terminal }: CommandOptions): ReplCommand => {
+  return {
+    command: "/edit",
+    description: "Opens file in $EDITOR for editing. Usage: /edit [file-path]",
+    result: "continue" as const,
+    getSubCommands: () => Promise.resolve([]),
+    execute: async (args: string[]) => {
+      let fileToEdit: string;
+
+      if (args.length > 0) {
+        // File path provided as argument
+        const filePath = args.join(" "); // Handle file paths with spaces
+        const resolvedPath = resolve(filePath);
+
+        if (!existsSync(resolvedPath)) {
+          terminal.error(`File not found: ${filePath}`);
+          return;
+        }
+
+        fileToEdit = filePath;
+      } else {
+        // No file path provided, use search prompt
+        fileToEdit = await search({
+          message: "Search for file:",
+          source: async (input) => {
+            if (!input) {
+              return [];
+            }
+
+            const foundFiles = await globby(`**/*${input}*`, {
+              gitignore: true,
+            });
+
+            return foundFiles.map((file) => ({
+              name: file,
+              value: file,
+            }));
+          },
+        });
+      }
+
+      const content = readFileSync(fileToEdit, { encoding: "utf8" });
+
+      const edit = await editor({
+        message: `Edit ${fileToEdit}?`,
+        postfix: extname(fileToEdit),
+        default: content,
+      });
+
+      writeFileSync(fileToEdit, edit);
+
+      if (content !== edit) {
+        terminal.info(`File updated: ${fileToEdit}`);
+      }
+    },
+  };
+};

package/source/commands/edit-prompt-command.ts

@@ -0,0 +1,31 @@
+import { editor } from "@inquirer/prompts";
+import { syncTry } from "@travisennis/stdlib/try";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const editPromptCommand = ({
+  terminal,
+  promptManager,
+}: CommandOptions): ReplCommand => {
+  return {
+    command: "/edit-prompt",
+    description: "Edit the prompt.",
+    result: "use" as const,
+    getSubCommands: () => Promise.resolve([]),
+    execute: async () => {
+      try {
+        const prompt = syncTry(() => promptManager.get());
+        const updatedPrompt = await editor({
+          message: " Edit prompt?",
+          postfix: "md",
+          default: prompt.unwrapOr(""),
+        });
+
+        terminal.writeln(`> ${updatedPrompt}`);
+
+        promptManager.set(updatedPrompt);
+      } catch (error) {
+        terminal.error(`Error updating prompt: ${(error as Error).message}`);
+      }
+    },
+  };
+};

package/source/commands/exit-command.ts

@@ -0,0 +1,18 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const exitCommand = ({
+  messageHistory,
+}: CommandOptions): ReplCommand => {
+  return {
+    command: "/exit",
+    aliases: ["/bye", "/quit"],
+    description: "Exits and saves the chat history.",
+    result: "break" as const,
+    getSubCommands: () => Promise.resolve([]),
+    execute: async () => {
+      if (!messageHistory.isEmpty()) {
+        await messageHistory.save();
+      }
+    },
+  };
+};

package/source/commands/files-command.ts

@@ -0,0 +1,85 @@
+import { readFile } from "node:fs/promises";
+import { checkbox } from "@inquirer/prompts";
+import { globby } from "globby";
+import { formatFile } from "../formatting.ts";
+import { TokenCounter } from "../token-utils.ts";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const filesCommand = ({
+  terminal,
+  promptManager,
+  modelManager,
+}: CommandOptions): ReplCommand => {
+  return {
+    command: "/files",
+    description:
+      "Finds files matching the given patterns and adds their content to the next prompt. Usage: /files or /files src/**/*.ts",
+    result: "continue" as const,
+    getSubCommands: () => Promise.resolve([]),
+    execute: async (args: string[]) => {
+      try {
+        let workingFiles: string[] = [];
+        if (!args || args.length === 0) {
+          // Get all files in the current directory
+          const foundFiles = await globby("**/*", { gitignore: true });
+
+          const selectedFiles = await checkbox<string>({
+            message: "Select files to include:",
+            choices: foundFiles,
+            pageSize: 15,
+          });
+
+          if (selectedFiles.length === 0) {
+            terminal.warn("No files selected.");
+            return;
+          }
+
+          // Process the selected files
+          workingFiles = selectedFiles;
+        } else {
+          const patternList = args.filter(Boolean);
+          const foundFiles = await globby(patternList, { gitignore: true });
+
+          if (foundFiles.length === 0) {
+            terminal.warn("No files found matching the pattern(s)");
+            return;
+          }
+
+          // Process the selected files
+          workingFiles = foundFiles;
+        }
+
+        // Read the content of the files and format them for the next prompt
+        const format = modelManager.getModelMetadata("repl").promptFormat;
+        let tokenCount = 0;
+
+        const tokenCounter = new TokenCounter();
+
+        await Promise.all(
+          workingFiles.map(async (filePath) => {
+            try {
+              const content = await readFile(filePath, "utf-8");
+              const formattedFile = formatFile(filePath, content, format);
+              tokenCount += tokenCounter.count(formattedFile);
+              promptManager.addContext(formattedFile);
+            } catch (error) {
+              terminal.error(
+                `Error reading file ${filePath}: ${(error as Error).message}`,
+              );
+            }
+          }),
+        );
+
+        tokenCounter.free();
+
+        terminal.success(
+          `File contents will be added to your next prompt (${workingFiles.length} files, ${tokenCount} tokens)`,
+        );
+      } catch (error) {
+        terminal.error(
+          `Error processing file patterns: ${(error as Error).message}`,
+        );
+      }
+    },
+  };
+};

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

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

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

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

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

@@ -0,0 +1,151 @@
+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,
+    };
+  }
+}