@travisennis/acai 0.0.1

package/source/index.ts

@@ -0,0 +1,240 @@
+import { text } from "node:stream/consumers";
+import { parseArgs } from "node:util";
+import { select } from "@inquirer/prompts";
+import { asyncTry } from "@travisennis/stdlib/try";
+import { isDefined } from "@travisennis/stdlib/typeguards";
+import { Cli } from "./cli.ts";
+import { CommandManager } from "./commands/manager.ts";
+import { config } from "./config.ts";
+import { logger } from "./logger.ts";
+import { MessageHistory } from "./messages.ts";
+import { ModelManager } from "./models/manager.ts";
+import { isSupportedModel, type ModelName } from "./models/providers.ts";
+import { PromptManager } from "./prompts/manager.ts";
+import { Repl } from "./repl.ts";
+import { initTerminal } from "./terminal/index.ts";
+import { TokenTracker } from "./token-tracker.ts";
+import { TokenCounter } from "./token-utils.ts";
+import type { Message } from "./tools/types.ts";
+import { getPackageVersion } from "./version.ts";
+
+const helpText = `
+Usage
+  $ acai <input>
+
+Options
+  --model, -m        Sets the model to use
+  --prompt, -p       Sets the prompt
+  --oneshot, -o      Run once and exit
+  --continue         Load the most recent conversation
+  --resume           Select a recent conversation to resume
+  --autoAcceptAll    Accept all commands and edits without prompting
+  --help, -h         Show help
+  --version, -v      Show version
+
+Examples
+  $ acai --model anthopric:sonnet
+  $ acai -p "initial prompt"
+  $ acai -p "one-shot prompt" -o
+`;
+
+const parsed = parseArgs({
+  options: {
+    model: { type: "string", short: "m" },
+    prompt: { type: "string", short: "p" },
+    oneshot: { type: "boolean", short: "o", default: false },
+    continue: { type: "boolean", default: false },
+    resume: { type: "boolean", default: false },
+    autoAcceptAll: { type: "boolean", default: false },
+    help: { type: "boolean", short: "h" },
+    version: { type: "boolean", short: "v" },
+  },
+  allowPositionals: true,
+});
+
+const flags = parsed.values;
+const input = parsed.positionals;
+
+/**
+ * Global error handler function.
+ * @param {Error} error - The error to be handled.
+ * @throws {Error} Rethrows the error after logging it.
+ */
+export function handleError(error: Error): void {
+  logger.error({ error: error }, error.message);
+}
+
+export type Flags = typeof flags;
+
+async function main() {
+  const appConfig = await config.ensureAppConfig("acai");
+
+  if (flags.version === true) {
+    console.info(getPackageVersion());
+    process.exit(0);
+  }
+
+  if (flags.help === true) {
+    console.info(helpText);
+    process.exit(0);
+  }
+
+  const appDir = config.app;
+  const messageHistoryDir = await appDir.ensurePath("message-history");
+
+  // --- Argument Validation ---
+  if (flags.continue === true && flags.resume === true) {
+    console.error("Cannot use --continue and --resume flags together.");
+    process.exit(1);
+  }
+
+  const hasContinueOrResume = flags.continue === true || flags.resume === true;
+
+  if (hasContinueOrResume && flags.oneshot === true) {
+    console.error("Cannot use --continue or --resume with --oneshot.");
+    process.exit(1);
+  }
+
+  // --- Determine Initial Prompt (potential conflict) ---
+  const positionalPrompt = input.at(0);
+  let stdInPrompt: string | undefined;
+  // Check if there's data available on stdin
+  if (!process.stdin.isTTY) {
+    try {
+      // Non-TTY stdin means data is being piped in
+      stdInPrompt = await text(process.stdin);
+    } catch (error) {
+      console.error(`Error reading stdin: ${(error as Error).message}`);
+    }
+  }
+
+  const initialPromptInput =
+    typeof flags.prompt === "string" && flags.prompt.length > 0
+      ? flags.prompt
+      : positionalPrompt && positionalPrompt.length > 0
+        ? positionalPrompt
+        : undefined;
+
+  if (hasContinueOrResume && isDefined(initialPromptInput)) {
+    console.error("Cannot use --continue or --resume with an initial prompt.");
+    process.exit(1);
+  }
+
+  const terminal = initTerminal();
+  terminal.setTitle(`acai: ${process.cwd()}`);
+
+  const chosenModel: ModelName = isSupportedModel(flags.model)
+    ? (flags.model as ModelName)
+    : "openrouter:sonnet4";
+
+  const modelManager = new ModelManager({
+    stateDir: await appDir.ensurePath("audit"),
+  });
+  modelManager.setModel("repl", chosenModel);
+  modelManager.setModel("cli", chosenModel);
+  modelManager.setModel("title-conversation", "openrouter:gemini-flash25");
+  modelManager.setModel("conversation-summarizer", "openrouter:gemini-flash25");
+  modelManager.setModel("tool-repair", "openai:gpt-4.1");
+  modelManager.setModel("conversation-analyzer", "openrouter:gemini-flash25");
+  modelManager.setModel("init-project", chosenModel);
+  modelManager.setModel("task-agent", "openrouter:gemini-flash25");
+
+  const tokenTracker = new TokenTracker();
+  const tokenCounter = new TokenCounter();
+
+  const messageHistory = new MessageHistory({
+    stateDir: messageHistoryDir,
+    modelManager,
+    tokenTracker,
+  });
+  messageHistory.on("update-title", (title) => terminal.setTitle(title));
+
+  if (flags.continue === true) {
+    const histories = await MessageHistory.load(messageHistoryDir, 1);
+    const latestHistory = histories.at(0);
+    if (latestHistory) {
+      messageHistory.restore(latestHistory);
+      console.info(`Resuming conversation: ${latestHistory.title}`);
+      // Set terminal title after restoring
+      terminal.setTitle(latestHistory.title || `acai: ${process.cwd()}`);
+    } else {
+      logger.info("No previous conversation found to continue.");
+    }
+  } else if (flags.resume === true) {
+    const histories = await MessageHistory.load(messageHistoryDir, 10);
+    if (histories.length > 0) {
+      const choice = await select({
+        message: "Select a conversation to resume:",
+        choices: histories.map((h, index) => ({
+          name: `${index + 1}: ${h.title} (${h.updatedAt.toLocaleString()})`,
+          value: index,
+          description: `${h.messages.length} messages`,
+        })),
+      });
+      const selectedHistory = histories.at(choice);
+      if (selectedHistory) {
+        messageHistory.restore(selectedHistory);
+        logger.info(`Resuming conversation: ${selectedHistory.title}`);
+        // Set terminal title after restoring
+        terminal.setTitle(selectedHistory.title || `acai: ${process.cwd()}`);
+      } else {
+        // This case should theoretically not happen if choice is valid
+        logger.error("Selected history index out of bounds.");
+      }
+    } else {
+      logger.info("No previous conversations found to resume.");
+    }
+  }
+
+  // --- Setup Prompt Manager (only if not continuing/resuming) ---
+  const promptManager = new PromptManager(tokenCounter);
+  if (!hasContinueOrResume && isDefined(initialPromptInput)) {
+    promptManager.set(initialPromptInput);
+  }
+
+  if (stdInPrompt) {
+    promptManager.addContext(stdInPrompt);
+  }
+
+  const toolEvents: Map<string, Message[]> = new Map();
+
+  const commands = new CommandManager({
+    promptManager,
+    modelManager,
+    terminal,
+    messageHistory,
+    tokenTracker,
+    config,
+    tokenCounter,
+    toolEvents,
+  });
+
+  if (flags.oneshot === true) {
+    const cliProcess = new Cli({
+      promptManager,
+      config: appConfig,
+      messageHistory,
+      modelManager,
+      tokenTracker,
+      tokenCounter,
+    });
+    return (await asyncTry(cliProcess.run())).recover(handleError);
+  }
+
+  const repl = new Repl({
+    promptManager,
+    terminal,
+    config: appConfig,
+    messageHistory,
+    modelManager,
+    tokenTracker,
+    commands,
+    tokenCounter,
+    toolEvents,
+    autoAcceptAll: flags.autoAcceptAll === true,
+  });
+
+  return (await asyncTry(repl.run())).recover(handleError);
+}
+
+main();

package/source/logger.ts

@@ -0,0 +1,29 @@
+import { join } from "node:path";
+import pino from "pino";
+import { config } from "./config.ts";
+
+const transport = pino.transport({
+  target: "pino-roll",
+  options: {
+    file: join(config.app.ensurePathSync("logs"), "acai.log"),
+    size: "10m",
+    symlink: true,
+    limit: {
+      count: 3,
+    },
+    mkdir: true,
+  },
+});
+
+export const logger = pino(
+  {
+    level: process.env["LOG_LEVEL"] ?? "debug",
+    formatters: {
+      level: (label) => {
+        return { level: label.toUpperCase() };
+      },
+    },
+    timestamp: pino.stdTimeFunctions.isoTime,
+  },
+  transport,
+);

package/source/mentions.ts

@@ -0,0 +1,227 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { isString } from "@travisennis/stdlib/typeguards";
+import type { FormatType } from "./formatting.ts";
+import { formatFile, formatUrl } from "./formatting.ts";
+import type { ModelMetadata } from "./models/providers.ts";
+import type { ContextItem } from "./prompts/manager.ts";
+import { type ReadUrlResult, readUrl } from "./tools/web-fetch.ts";
+import { executeCommand } from "./utils/process.ts";
+
+interface CommandContext {
+  model: ModelMetadata;
+  baseDir: string;
+  match: string;
+}
+
+// Helper function to recursively read all files in a directory
+async function readDirectoryRecursive(
+  dirPath: string,
+  format: FormatType,
+): Promise<string> {
+  const allContents: string[] = [];
+
+  async function readDir(
+    currentPath: string,
+    relativePath = "",
+  ): Promise<void> {
+    const entries = await fs.readdir(currentPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentPath, entry.name);
+      const relativeFilePath = path.join(relativePath, entry.name);
+
+      if (entry.isDirectory()) {
+        await readDir(fullPath, relativeFilePath);
+      } else if (entry.isFile()) {
+        try {
+          const fileContents = await fs.readFile(fullPath, "utf8");
+          allContents.push(formatFile(relativeFilePath, fileContents, format));
+        } catch (error) {
+          allContents.push(
+            `Error reading file ${relativeFilePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
+          );
+        }
+      }
+    }
+  }
+
+  await readDir(dirPath);
+
+  if (allContents.length === 0) {
+    return `Directory ${path.basename(dirPath)} is empty or contains no readable files.`;
+  }
+
+  return allContents.join("\n\n");
+}
+
+// Returns the formatted string or an error message string
+async function processFileCommand(context: CommandContext): Promise<string> {
+  const { baseDir, match } = context;
+  const filePath = match.trim();
+  const format = context.model.promptFormat;
+
+  try {
+    // Resolve paths to absolute to prevent traversal issues
+    const resolvedBaseDir = path.resolve(baseDir);
+    const resolvedFilePath = path.resolve(resolvedBaseDir, filePath);
+
+    // Security Check: Ensure the resolved path is still within the base directory
+    if (!resolvedFilePath.startsWith(resolvedBaseDir + path.sep)) {
+      return `Error: Access denied. Attempted to read file outside the allowed directory: ${filePath}`;
+    }
+
+    // Check if path exists
+    const stats = await fs.stat(resolvedFilePath);
+
+    // If it's a directory, read all files recursively
+    if (stats.isDirectory()) {
+      return await readDirectoryRecursive(resolvedFilePath, format);
+    }
+
+    // If it's a file, process as before
+    if (stats.isFile()) {
+      const fileContents = await fs.readFile(resolvedFilePath, "utf8");
+      return formatFile(filePath, fileContents, format);
+    }
+
+    return `Error: ${filePath} is neither a regular file nor directory.`;
+  } catch (error) {
+    // Handle both ENOENT (file not found) and permission errors
+    if (error && typeof error === "object" && "code" in error) {
+      if (error.code === "ENOENT") {
+        return `Error: File or directory not found: ${filePath}\nPlease check that the path is correct and exists.`;
+      }
+      if (error.code === "EACCES") {
+        return `Error: Permission denied accessing: ${filePath}`;
+      }
+    }
+    if (error instanceof Error) {
+      return `Error accessing ${filePath}: ${error.message}`;
+    }
+    // Fallback for unknown error types
+    return `Error accessing ${filePath}: An unknown error occurred.`;
+  }
+}
+
+async function processShellCommand(command: string): Promise<string> {
+  try {
+    const { stdout, stderr, code } = await executeCommand(command, {
+      shell: true,
+    });
+    if (code === 0) {
+      return stdout;
+    }
+    return `Error executing command: ${command}\n${stderr}`;
+  } catch (error) {
+    if (error instanceof Error) {
+      return `Error executing command ${command}: ${error.message}`;
+    }
+    return `Error executing command ${command}: An unknown error occurred.`;
+  }
+}
+
+// Returns the formatted string or an error message string
+async function processUrlCommand(
+  context: CommandContext,
+): Promise<ReadUrlResult & { source: string }> {
+  const { match } = context;
+  const urlPath = match;
+  try {
+    return Object.assign(await readUrl(urlPath), { source: urlPath });
+  } catch (error) {
+    if (error instanceof Error) {
+      return {
+        contentType: "text/plain",
+        data: `Url: ${urlPath} Status: Error fetching URL: ${error.message}`,
+        source: urlPath,
+      };
+    }
+    // Fallback for unknown error types
+    return {
+      contentType: "text/plain",
+      data: `Url: ${urlPath} Status: Error fetching URL: An unknown error occurred.`,
+      source: urlPath,
+    };
+  }
+}
+
+export async function processPrompt(
+  message: string,
+  { baseDir, model }: { baseDir: string; model: ModelMetadata },
+): Promise<{ message: string; context: ContextItem[] }> {
+  const fileRegex = /@([^\s@]+(?:\.[\w\d]+))/g;
+  const urlRegex = /@(https?:\/\/[^\s]+)/g;
+  const shellRegex = /!`([^`]+)`/g;
+
+  // Collect all matches for files and urls
+  const fileMatches = Array.from(message.matchAll(fileRegex));
+  const urlMatches = Array.from(message.matchAll(urlRegex));
+  const shellMatches = Array.from(message.matchAll(shellRegex));
+
+  const mentionProcessingPromises: Promise<
+    string | (ReadUrlResult & { source: string })
+  >[] = [];
+
+  // Process file references - collect promises
+  for (const match of fileMatches) {
+    const firstMatch = match[1];
+    if (firstMatch) {
+      const context = {
+        model,
+        baseDir,
+        match: firstMatch,
+      };
+      mentionProcessingPromises.push(processFileCommand(context));
+    }
+  }
+
+  // Process url references - collect promises
+  for (const match of urlMatches) {
+    const firstMatch = match[1];
+    if (firstMatch) {
+      const context = {
+        model,
+        baseDir, // baseDir is not used by processUrlCommand but kept for consistency
+        match: firstMatch,
+      };
+      mentionProcessingPromises.push(processUrlCommand(context));
+    }
+  }
+
+  let processedMessage = message;
+  // Process shell commands
+  for (const match of shellMatches) {
+    const command = match[1];
+    if (command) {
+      const output = await processShellCommand(command);
+      processedMessage = processedMessage.replace(match[0], output);
+    }
+  }
+
+  // Wait for all mentions to be processed
+  const mentionResults = await Promise.all(mentionProcessingPromises);
+
+  const context: ContextItem[] = [];
+
+  for (const mention of mentionResults) {
+    if (isString(mention)) {
+      context.push(mention);
+    } else if (mention.data.startsWith("data")) {
+      context.push({
+        type: "image",
+        mediaType: mention.contentType,
+        image: mention.data,
+      });
+    } else {
+      context.push(
+        formatUrl(mention.source, mention.data.trim(), model.promptFormat),
+      );
+    }
+  }
+
+  return {
+    message: processedMessage,
+    context,
+  };
+}