@travisennis/acai 0.0.1 → 0.0.3

package/source/dedent.ts

@@ -1,53 +0,0 @@
-type Dedent = (strings: TemplateStringsArray, ...values: unknown[]) => string;
-
-const spaces = /^(\s+)\S+/;
-
-export const dedent: Dedent = (
-  strings: TemplateStringsArray,
-  ...values: unknown[]
-): string => {
-  // Perform interpolation
-  let result = "";
-  for (let i = 0; i < strings.raw.length; i++) {
-    const next =
-      strings.raw[i] ??
-      ""
-        // handle escaped newlines, backticks, and interpolation characters
-        .replace(/\\\n[ \t]*/g, "")
-        .replace(/\\`/g, "`")
-        .replace(/\\\$/g, "$")
-        .replace(/\\\{/g, "{");
-
-    result += next;
-
-    if (i < values.length) {
-      result += values[i];
-    }
-  }
-
-  // Strip indentation
-  const lines = result.split("\n");
-  let mindent: null | number = null;
-
-  for (const line of lines) {
-    const m = line.match(spaces);
-    if (m) {
-      const indent = m[1]?.length ?? 0;
-      mindent = mindent === null ? indent : Math.min(mindent, indent);
-    }
-  }
-
-  if (mindent !== null) {
-    result = lines
-      .map((l) => (l[0] === " " || l[0] === "\t" ? l.slice(mindent) : l))
-      .join("\n");
-  }
-
-  // Trim leading and trailing whitespace
-  result = result.trim();
-
-  // Handle escaped newlines at the end
-  result = result.replace(/\\n/g, "\n");
-
-  return result;
-};

package/source/formatting.ts

@@ -1,132 +0,0 @@
-import path from "node:path";
-
-const MD_CODE_BLOCK = /```(?:[\w-]+)?\n(.*?)```/s;
-
-/**
- * Extracts the first code block content from the given text.
- * If a Markdown-style triple backtick code block is found, returns its inner content.
- * Otherwise, returns the original text unchanged.
- *
- * @param text - The input string potentially containing a Markdown code block.
- * @returns The extracted code inside the first code block, or the original text if no block is found.
- */
-export const extractCodeBlock = (text: string): string => {
-  const pattern = MD_CODE_BLOCK;
-  const match = text.match(pattern);
-  if (match) {
-    return match[1] ?? "";
-  }
-  return text;
-};
-
-export function extractXml(text: string, tag: string): string {
-  const match = text.match(new RegExp(`<${tag}>(.*?)</${tag}>`, "s"));
-  return match ? (match[1] ?? "") : "";
-}
-
-export function removeAllLineBreaks(text: string) {
-  return text.replace(/(\r\n|\n|\r)/gm, " ");
-}
-
-export function removeHtmlTags(text: string) {
-  return text.replace(/<[^>]*>?/gm, "");
-}
-
-const MD_TRIPLE_QUOTE = "```";
-
-export type FormatType = "xml" | "markdown" | "bracket";
-
-const codeBlockExtensions: Record<string, string> = {
-  js: "javascript",
-  ts: "typescript",
-  py: "python",
-  rb: "ruby",
-  java: "java",
-  cpp: "cpp",
-  cs: "csharp",
-  go: "go",
-  rs: "rust",
-  php: "php",
-  html: "html",
-  css: "css",
-  json: "json",
-  yml: "yaml",
-  yaml: "yaml",
-  md: "markdown",
-  sql: "sql",
-  sh: "bash",
-  bash: "bash",
-  txt: "text",
-};
-
-export function formatFile(
-  file: string,
-  content: string,
-  format: FormatType,
-): string {
-  const fileExtension = path.extname(file).slice(1);
-  const codeBlockName = codeBlockExtensions[fileExtension] || fileExtension;
-  switch (format) {
-    case "xml":
-      return `<file>\n<name>${file}</name>\n<content>\n${content}\n</content>\n</file>`;
-    case "markdown":
-      return `## File: ${file}\n${MD_TRIPLE_QUOTE} ${codeBlockName}\n${content}\n${MD_TRIPLE_QUOTE}`;
-    case "bracket":
-      return `[file name]: ${file}\n[file content begin]\n${content}\n[file content end]`;
-    default:
-      throw new Error(`Unsupported format: ${format}`);
-  }
-}
-
-export function formatUrl(
-  siteUrl: string,
-  content: string,
-  format: FormatType,
-): string {
-  switch (format) {
-    case "xml":
-      return `<webpage>\n<url>${siteUrl}</url>\n<content>\n${content}\n</content>\n</webpage>`;
-    case "markdown":
-      return `## URL: ${siteUrl}\n${MD_TRIPLE_QUOTE}\n${content}\n${MD_TRIPLE_QUOTE}`;
-    case "bracket":
-      return `[url]: ${siteUrl}\n[url content begin]\n${content}\n[url content end]`;
-    default:
-      throw new Error(`Unsupported format: ${format}`);
-  }
-}
-
-export function formatCodeSnippet(
-  file: string,
-  content: string,
-  format: FormatType,
-) {
-  const fileExtension = path.extname(file).slice(1);
-  const codeBlockName = codeBlockExtensions[fileExtension] || fileExtension;
-  switch (format) {
-    case "xml":
-      return `<code>\n${content}\n</code>`;
-    case "markdown":
-      return `${MD_TRIPLE_QUOTE} ${codeBlockName}\n${content}\n${MD_TRIPLE_QUOTE}`;
-    case "bracket":
-      return `[code begin]\n${content}\n[code end]`;
-    default:
-      throw new Error(`Unsupported format: ${format}`);
-  }
-}
-
-export function formatBlock(
-  content: string,
-  blockName: string,
-  format: FormatType,
-): string {
-  switch (format) {
-    case "xml":
-      return `<${blockName}>\n${content}\n</${blockName}>\n</file>`;
-    case "markdown":
-      return `## ${blockName}\n${MD_TRIPLE_QUOTE}\n${content}\n${MD_TRIPLE_QUOTE}`;
-    case "bracket":
-      return `[${blockName} begin]\n${content}\n[${blockName} end]`;
-    default:
-      throw new Error(`Unsupported format: ${format}`);
-  }
-}

package/source/index.ts

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

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

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