@travisennis/acai 0.0.1

package/source/repl.ts

@@ -0,0 +1,572 @@
+import { isNumber, isRecord } from "@travisennis/stdlib/typeguards";
+import type { AsyncReturnType } from "@travisennis/stdlib/types";
+import {
+  generateObject,
+  NoSuchToolError,
+  type StepResult,
+  stepCountIs,
+  streamText,
+  type ToolCallRepairFunction,
+  type ToolSet,
+} from "ai";
+import chalk, { type ChalkInstance } from "chalk";
+import type z from "zod";
+import type { CommandManager } from "./commands/manager.ts";
+import { config as configManager } from "./config.ts";
+import { logger } from "./logger.ts";
+import { processPrompt } from "./mentions.ts";
+import type { MessageHistory } from "./messages.ts";
+import { AiConfig } from "./models/ai-config.ts";
+import type { ModelManager } from "./models/manager.js";
+import type { PromptManager } from "./prompts/manager.ts";
+import { systemPrompt } from "./prompts.ts";
+import { ReplPrompt } from "./repl-prompt.ts";
+import type { Terminal } from "./terminal/index.ts";
+import { isMarkdown } from "./terminal/markdown-utils.ts";
+import type { TokenTracker } from "./token-tracker.ts";
+import type { TokenCounter } from "./token-utils.ts";
+import {
+  getCurrentBranch,
+  getDiffStat,
+  hasUncommittedChanges,
+  inGitDirectory,
+} from "./tools/git-utils.ts"; // Modified import
+import { initAgents, initTools } from "./tools/index.ts";
+import type { Message } from "./tools/types.ts";
+
+interface ReplOptions {
+  messageHistory: MessageHistory;
+  promptManager: PromptManager;
+  modelManager: ModelManager;
+  tokenTracker: TokenTracker;
+  terminal: Terminal;
+  commands: CommandManager;
+  config: Record<PropertyKey, unknown>;
+  tokenCounter: TokenCounter;
+  toolEvents: Map<string, Message[]>;
+  autoAcceptAll: boolean;
+}
+
+type CompleteToolSet = AsyncReturnType<typeof initTools> &
+  AsyncReturnType<typeof initAgents>;
+
+type OnFinishResult<Tools extends ToolSet = CompleteToolSet> = Omit<
+  StepResult<Tools>,
+  "stepType" | "isContinued"
+> & {
+  /**
+Details for all steps.
+   */
+  readonly steps: StepResult<Tools>[];
+};
+
+export class Repl {
+  private options: ReplOptions;
+  constructor(options: ReplOptions) {
+    this.options = options;
+  }
+
+  async run() {
+    const {
+      config,
+      promptManager,
+      terminal,
+      modelManager,
+      tokenTracker,
+      messageHistory,
+      commands,
+      tokenCounter,
+      toolEvents,
+      autoAcceptAll,
+    } = this.options;
+
+    logger.info(config, "Config:");
+
+    terminal.displayWelcome();
+
+    const promptHistory: string[] = [];
+
+    let currentContextWindow = 0;
+    messageHistory.on("clear-history", () => {
+      currentContextWindow = 0;
+    });
+
+    let prevCb: (() => void) | null = null;
+
+    while (true) {
+      const abortController = new AbortController();
+      const { signal } = abortController;
+
+      const cb = () => {
+        abortController.abort();
+      };
+
+      if (prevCb) {
+        process.removeListener("SIGINT", prevCb);
+      }
+
+      // Handle Ctrl+C (SIGINT)
+      process.on("SIGINT", cb);
+      prevCb = cb;
+
+      const langModel = modelManager.getModel("repl");
+      const modelConfig = modelManager.getModelMetadata("repl");
+
+      const currentDir = process.cwd().split("/").pop() || process.cwd();
+      const branch = await getCurrentBranch();
+
+      let branchDisplay = "";
+      if (branch) {
+        const hasChanges = await hasUncommittedChanges();
+        const asterisk = hasChanges ? "*" : "";
+        branchDisplay = ` ${chalk.gray(branch + asterisk)}`;
+      }
+
+      terminal.hr();
+      terminal.writeln(`${chalk.blue(currentDir)}${branchDisplay}`);
+      terminal.writeln(chalk.dim(langModel.modelId));
+      terminal.displayProgressBar(
+        currentContextWindow,
+        modelConfig.contextWindow,
+      );
+
+      if (!promptManager.isPending()) {
+        // For interactive input
+        const prompt = new ReplPrompt({ commands, history: promptHistory });
+        const userInput = await prompt.input();
+        prompt.close();
+
+        // see if the userInput contains a command
+        const commandResult = await commands.handle({ userInput });
+        if (commandResult.break) {
+          break;
+        }
+        if (commandResult.continue) {
+          terminal.lineBreak();
+          continue;
+        }
+
+        if (!userInput.trim()) {
+          continue;
+        }
+
+        // if there is no pending prompt then use the user's input. otherwise, the prompt was loaded from a command
+        if (!promptManager.isPending()) {
+          const processedPrompt = await processPrompt(userInput, {
+            baseDir: process.cwd(),
+            model: modelConfig,
+          });
+          for (const context of processedPrompt.context) {
+            promptManager.addContext(context);
+          }
+          promptManager.set(processedPrompt.message);
+        }
+
+        terminal.lineBreak();
+      }
+
+      // flag to see if the user prompt has added context
+      const hasAddedContext = promptManager.hasContext();
+
+      if (hasAddedContext) {
+        terminal.info("Context will be added to prompt.");
+        terminal.lineBreak();
+      }
+
+      const userPrompt = promptManager.get();
+
+      const userMsg = promptManager.getUserMessage();
+
+      messageHistory.appendUserMessage(userMsg);
+
+      const finalSystemPrompt = await systemPrompt({
+        supportsToolCalling: modelConfig.supportsToolCalling,
+      });
+
+      const aiConfig = new AiConfig({
+        modelMetadata: modelConfig,
+        prompt: userPrompt,
+      });
+
+      const maxTokens = aiConfig.getMaxTokens();
+
+      const tools = modelConfig.supportsToolCalling
+        ? {
+            ...(await initTools({
+              terminal,
+              tokenCounter,
+              autoAcceptAll,
+              events: toolEvents,
+            })),
+            ...(await initAgents({
+              terminal,
+              modelManager,
+              tokenTracker,
+              tokenCounter,
+              events: toolEvents,
+            })),
+          }
+        : undefined;
+
+      try {
+        const result = streamText({
+          model: langModel,
+          maxOutputTokens: maxTokens,
+          messages: [
+            {
+              role: "system",
+              content: finalSystemPrompt,
+              providerOptions: {
+                anthropic: { cacheControl: { type: "ephemeral" } },
+              },
+            },
+            ...messageHistory.get(),
+          ],
+          temperature: modelConfig.defaultTemperature,
+          stopWhen: stepCountIs(60),
+          maxRetries: 2,
+          providerOptions: aiConfig.getProviderOptions(),
+          tools,
+          // biome-ignore lint/style/useNamingConvention: third-party controlled
+          experimental_repairToolCall: modelConfig.supportsToolCalling
+            ? toolCallRepair(modelManager, terminal)
+            : undefined,
+          abortSignal: signal,
+          onFinish: async (result) => {
+            logger.debug("onFinish called");
+            if (result.response.messages.length > 0) {
+              messageHistory.appendResponseMessages(result.response.messages);
+            }
+
+            terminal.hr();
+
+            // Notify if configured in project config (acai.json)
+            const projectConfig = await configManager.readProjectConfig();
+            if (projectConfig.notify) {
+              terminal.alert();
+            }
+
+            // Create a more visual representation of steps/tool usage
+            this.displayToolUse(result, terminal);
+
+            if (await inGitDirectory()) {
+              // Added check
+              const stats = await getDiffStat();
+              terminal.writeln(
+                `${chalk.dim("Files changed:")} ${chalk.yellow(stats.filesChanged)} ` +
+                  `${chalk.green(`+${stats.insertions}`)} ` + // Insertions first (green)
+                  `${chalk.red(`-${stats.deletions}`)}`, // Deletions last (red)
+              );
+            }
+
+            const total =
+              (result as { totalUsage?: typeof result.usage }).totalUsage ??
+              result.usage;
+            const outgoingTokens = isNumber(total.inputTokens)
+              ? total.inputTokens
+              : 0;
+            const incomingTokens = isNumber(total.outputTokens)
+              ? total.outputTokens
+              : 0;
+            const tokenSummary = `Tokens: ↑ ${outgoingTokens} ↓ ${incomingTokens}`;
+            terminal.writeln(chalk.dim(tokenSummary));
+
+            // Track aggregate usage across all steps when available
+            tokenTracker.trackUsage("repl", total);
+
+            // Derive current context window from final step usage
+            const finalTotalTokens = result.usage.totalTokens;
+            if (isNumber(finalTotalTokens)) {
+              currentContextWindow = finalTotalTokens ?? 0;
+            } else {
+              // Fallback: find the stopped step
+              for (const step of result.steps) {
+                if (step.finishReason === "stop") {
+                  const usage = step.usage;
+                  currentContextWindow = Number.isNaN(usage.totalTokens)
+                    ? 0
+                    : (usage.totalTokens ?? 0);
+                }
+              }
+            }
+
+            // comment out auto-summarization for now. it's been causing issues.
+            // if (currentContextWindow > 70000) {
+            //   logger.info(
+            //     `Condensing history from ${currentContextWindow} to 0`,
+            //   );
+            //   await messageHistory.summarizeAndReset();
+            // }
+
+            terminal.hr();
+          },
+          onError: ({ error }) => {
+            logger.error(
+              error, // Log the full error object
+              "Error on REPL streamText",
+            );
+            terminal.error(
+              (error as Error).message.length > 100
+                ? `${(error as Error).message.slice(0, 100)}...`
+                : (error as Error).message,
+            );
+          },
+        });
+
+        let accumulatedText = "";
+        let lastType: "reasoning" | "text" | null = null;
+
+        for await (const chunk of result.fullStream) {
+          // Handle text-related chunks (reasoning or text-delta)
+          if (chunk.type === "reasoning-delta" || chunk.type === "text-delta") {
+            if (chunk.type === "reasoning-delta") {
+              if (lastType !== "reasoning") {
+                terminal.writeln(chalk.dim("<think>"));
+              }
+              terminal.write(chalk.dim(chunk.text)); // Stream reasoning directly
+              lastType = "reasoning";
+            } else if (chunk.type === "text-delta") {
+              if (lastType === "reasoning") {
+                // Finishing reasoning: Print </think>
+                terminal.writeln(chalk.dim("\n</think>\n"));
+              }
+              accumulatedText += chunk.text;
+              lastType = "text";
+            }
+          } else if (chunk.type === "tool-result") {
+            const messages = toolEvents.get(chunk.toolCallId);
+            if (messages) {
+              displayToolMessages(messages, terminal);
+              toolEvents.delete(chunk.toolCallId);
+            } else {
+              logger.warn(`No tool events found for ${chunk.toolCallId}`);
+            }
+          } else {
+            // Close thinking tags when moving from reasoning to any other chunk type
+            if (lastType === "reasoning") {
+              terminal.write(chalk.dim("\n</think>\n\n"));
+            }
+            // if there is accumulatedText, display it
+            if (accumulatedText) {
+              terminal.writeln(`${chalk.blue.bold("●")} Response:`);
+              terminal.display(accumulatedText, true);
+              terminal.lineBreak();
+            }
+            accumulatedText = "";
+            lastType = null;
+          }
+        }
+
+        // Ensure the final closing tag for reasoning is written if it was the last type
+        if (lastType === "reasoning") {
+          terminal.write(chalk.gray("\n</think>\n\n"));
+        }
+
+        // if there is accumulatedText, display it
+        if (accumulatedText) {
+          terminal.writeln(`${chalk.green.bold("●")} Response:`);
+          terminal.display(accumulatedText, true);
+          terminal.lineBreak();
+        }
+
+        terminal.lineBreak(); // Add a final newline for clarity
+
+        await result.consumeStream();
+      } catch (e) {
+        if (isRecord(e) && isRecord(e["data"]) && "error" in e["data"]) {
+          terminal.error(
+            (e["data"]["error"] as Record<"message", string>).message,
+          );
+        } else {
+          terminal.error(
+            (e as Error).message.length > 100
+              ? `${(e as Error).message.slice(0, 100)}...`
+              : (e as Error).message,
+          );
+        }
+        terminal.lineBreak();
+        if (e instanceof Error) {
+          logger.error(e);
+        } else {
+          logger.error(JSON.stringify(e, null, 2));
+        }
+      }
+    }
+  }
+
+  private displayToolUse(result: OnFinishResult, terminal: Terminal) {
+    const toolsCalled: string[] = [];
+    const toolColors = new Map<string, ChalkInstance>();
+
+    const chalkColors = [
+      "red",
+      "green",
+      "yellow",
+      "blue",
+      "magenta",
+      "cyan",
+      "white",
+      "gray",
+      "redBright",
+      "greenBright",
+      "yellowBright",
+      "blueBright",
+      "magentaBright",
+      "cyanBright",
+      "whiteBright",
+      "blackBright",
+    ] as const;
+
+    terminal.writeln(chalk.dim(`Steps: ${result.steps.length}`));
+
+    for (const step of result.steps) {
+      let currentToolCalls: Array<{ toolName: string }> = [];
+
+      if (step.toolResults.length > 0) {
+        currentToolCalls = step.toolResults;
+      } else if (step.toolCalls.length > 0) {
+        currentToolCalls = step.toolCalls;
+      }
+
+      for (const toolCallOrResult of currentToolCalls) {
+        const toolName = toolCallOrResult.toolName;
+        if (!toolColors.has(toolName)) {
+          const availableColors = chalkColors.filter(
+            (color) =>
+              !Array.from(toolColors.values()).some((c) => c === chalk[color]),
+          );
+          const color =
+            availableColors.length > 0
+              ? (availableColors[
+                  Math.floor(Math.random() * availableColors.length)
+                ] ?? "white")
+              : "white";
+          toolColors.set(toolName, chalk[color]);
+        }
+        toolsCalled.push(toolName);
+      }
+    }
+
+    if (toolsCalled.length > 0) {
+      terminal.writeln(chalk.dim("Tools:"));
+      for (const toolCalled of toolsCalled) {
+        const colorFn = toolColors.get(toolCalled) ?? chalk.white;
+        terminal.write(`${colorFn("██")} `);
+      }
+      terminal.lineBreak();
+
+      const uniqueTools = new Set(toolsCalled);
+      for (const [index, toolCalled] of Array.from(uniqueTools).entries()) {
+        const colorFn = toolColors.get(toolCalled) ?? chalk.white;
+        terminal.write(colorFn(toolCalled));
+        if (index < new Set(toolsCalled).size - 1) {
+          terminal.write(" - ");
+        }
+      }
+      terminal.lineBreak();
+      terminal.lineBreak();
+    }
+  }
+}
+
+function displayToolMessages(messages: Message[], terminal: Terminal) {
+  const isError = messages[messages.length - 1]?.event === "tool-error";
+  const indicator = isError ? chalk.red.bold("●") : chalk.blue.bold("●");
+  const initMessage =
+    messages.find((m) => m.event === "tool-init")?.data ?? "Tool Execution";
+
+  terminal.write(`${indicator} `); // Write indicator without newline (sync)
+  terminal.display(initMessage); // Display initial message (async)
+
+  for (const msg of messages) {
+    switch (msg.event) {
+      case "tool-update":
+        _handleToolUpdateMessage(msg.data, terminal);
+        break;
+      case "tool-completion":
+        _handleToolCompletionMessage(msg.data, terminal);
+        break;
+      case "tool-error":
+        _handleToolErrorMessage(msg.data, terminal);
+        break;
+      // 'tool-init' is handled before the loop, so no case needed here.
+      default:
+        // Optional: Log an unexpected event type for debugging, or do nothing.
+        logger.debug(`Unhandled tool message event: ${msg.event}`);
+        break;
+    }
+  }
+  terminal.lineBreak();
+}
+
+// Helper function to handle tool update messages
+function _handleToolUpdateMessage(
+  data: { primary: string; secondary?: string[] },
+  terminal: Terminal,
+) {
+  if (data.secondary && data.secondary.length > 0) {
+    const content = data.secondary.join("\n");
+    if (content.trim().length !== 0) {
+      terminal.display(`└── ${data.primary}`);
+      terminal.hr();
+      if (isMarkdown(content)) {
+        terminal.display(content, true);
+      } else {
+        terminal.write(chalk.green(content));
+        terminal.lineBreak();
+      }
+      terminal.hr();
+    }
+  } else {
+    terminal.display(`└── ${data.primary}`);
+  }
+}
+
+// Helper function to handle tool completion messages
+function _handleToolCompletionMessage(data: string, terminal: Terminal) {
+  terminal.display(`└── ${data}`);
+}
+
+// Helper function to handle tool error messages
+function _handleToolErrorMessage(data: string, terminal: Terminal) {
+  terminal.write("└── ");
+  terminal.error(data);
+}
+
+const toolCallRepair = (modelManager: ModelManager, terminal: Terminal) => {
+  const fn: ToolCallRepairFunction<CompleteToolSet> = async ({
+    toolCall,
+    tools,
+    inputSchema,
+    error,
+  }) => {
+    if (NoSuchToolError.isInstance(error)) {
+      return null; // do not attempt to fix invalid tool names
+    }
+
+    terminal.warn(`Attempting to repair tool call: ${toolCall.toolName}.`);
+    terminal.lineBreak();
+
+    const tool = tools[toolCall.toolName as keyof typeof tools];
+
+    try {
+      const { object: repairedArgs } = await generateObject({
+        model: modelManager.getModel("tool-repair"),
+        schema: tool.inputSchema as z.ZodSchema<unknown>,
+        prompt: [
+          `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
+          JSON.stringify(toolCall.input),
+          "The tool accepts the following schema:",
+          JSON.stringify(inputSchema(toolCall)),
+          "Please fix the arguments.",
+        ].join("\n"),
+      });
+
+      return { ...toolCall, args: JSON.stringify(repairedArgs) };
+    } catch (err) {
+      logger.error(err, `Failed to repair tool call: ${toolCall.toolName}.`);
+      return null;
+    }
+  };
+  return fn;
+};

package/source/terminal/formatting.ts

@@ -0,0 +1,121 @@
+/**
+ * Terminal Formatting Utilities
+ *
+ * Provides functions for formatting and displaying text in the terminal.
+ */
+
+import chalk from "chalk";
+
+/**
+ * Clear the terminal screen
+ */
+export function clearScreen(): void {
+  // Clear screen and move cursor to top-left
+  process.stdout.write("\x1b[2J\x1b[0f");
+}
+
+/**
+ * Clear the terminal screen including scrollback buffer
+ *
+ * Unlike clearScreen, this function:
+ * 1. Clears the entire screen (\x1b[2J)
+ * 2. Clears the scrollback buffer (\x1b[3J)
+ * 3. Moves cursor to home position (\x1b[H)
+ * 4. Returns a Promise that resolves when the write operation completes
+ *
+ * @returns Promise that resolves when the terminal has been cleared
+ */
+export function clearTerminal(): Promise<void> {
+  return new Promise((resolve) => {
+    process.stdout.write("\x1b[2J\x1b[3J\x1b[H", () => {
+      resolve();
+    });
+  });
+}
+
+/**
+ * Sets the terminal title
+ */
+export function setTerminalTitle(title: string): void {
+  if (process.platform === "win32") {
+    process.title = title ? `✳✳ ${title}` : title;
+  } else {
+    process.stdout.write(`\x1b]0;${title ? `✳✳ ${title}` : ""}\x07`);
+  }
+}
+
+/**
+ * Get the terminal size (rows and columns)
+ */
+export function getTerminalSize(): { rows: number; columns: number } {
+  // Default to a reasonable size if we can't determine the actual size
+  const defaultSize = { rows: 24, columns: 80 };
+
+  try {
+    if (process.stdout.isTTY) {
+      return {
+        rows: process.stdout.rows || defaultSize.rows,
+        columns: process.stdout.columns || defaultSize.columns,
+      };
+    }
+  } catch (_error) {
+    // Ignore errors
+  }
+
+  return defaultSize;
+}
+
+/**
+ * Word wrap text to the specified width
+ */
+export function wordWrap(text: string, width: number): string {
+  const lines = text.split("\n");
+
+  return lines.map((line) => wrapLine(line, width)).join("\n");
+}
+
+function wrapLine(line: string, width: number): string {
+  // If the line is a code block or already shorter than the width, leave it as is
+  if (line.trim().startsWith("┃") || line.length <= width) {
+    return line;
+  }
+
+  // Word wrap the line
+  const words = line.split(" ");
+  const wrappedLines: string[] = [];
+  let currentLine = "";
+
+  for (const word of words) {
+    // If adding this word would exceed the width
+    if (currentLine.length + word.length + 1 > width) {
+      // Add the current line to wrapped lines if it's not empty
+      if (currentLine) {
+        wrappedLines.push(currentLine);
+        currentLine = word;
+      } else {
+        // If the current line is empty, it means the word itself is longer than the width
+        wrappedLines.push(word);
+      }
+    } else {
+      // Add the word to the current line
+      currentLine = currentLine ? `${currentLine} ${word}` : word;
+    }
+  }
+
+  // Add the last line if it's not empty
+  if (currentLine) {
+    wrappedLines.push(currentLine);
+  }
+
+  return wrappedLines.join("\n");
+}
+
+// const ESC = "\u001B[";
+const OSC = "\u001B]";
+const BEL = "\u0007";
+const SEP = ";";
+
+export const link = (text: string, url: string) =>
+  chalk.underline.blue(
+    [OSC, "8", SEP, SEP, url, BEL, text, OSC, "8", SEP, SEP, BEL].join(""),
+  );