@travisennis/acai 0.0.1

package/source/terminal/markdown.ts

@@ -0,0 +1,155 @@
+import { EOL } from "node:os";
+import chalk from "chalk";
+import { highlight, supportsLanguage } from "cli-highlight";
+import Table from "cli-table3";
+import { marked, type Token } from "marked";
+import { logger } from "../logger.ts";
+import { link as terminalLink } from "./formatting.ts";
+import { getListNumber } from "./markdown-utils.ts";
+
+function logError(msg: string) {
+  logger.error(msg);
+}
+
+export function applyMarkdown(content: string): string {
+  return marked
+    .lexer(content)
+    .map((token) => format(token))
+    .join("")
+    .trim();
+}
+
+function format(
+  token: Token,
+  listDepth = 0,
+  orderedListNumber: number | null = null,
+  parent: Token | null = null,
+): string {
+  switch (token.type) {
+    case "blockquote":
+      return chalk.dim.italic(
+        (token.tokens ?? [])
+          .map((_) => format(_))
+          .map((l) => `  ${l}`)
+          .join(""),
+      );
+    case "code": {
+      if (token.lang && supportsLanguage(token.lang)) {
+        return highlight(token.text, { language: token.lang }) + EOL;
+      }
+      logError(
+        `Language not supported while highlighting code, falling back to markdown: ${token.lang}`,
+      );
+      return highlight(token.text, { language: "markdown" }) + EOL;
+    }
+    case "codespan":
+      // inline code
+      return chalk.blue(token.text);
+    case "em":
+      return chalk.italic((token.tokens ?? []).map((_) => format(_)).join(""));
+    case "strong":
+      return chalk.bold((token.tokens ?? []).map((_) => format(_)).join(""));
+    case "heading":
+      switch (token.depth) {
+        case 1: // h1
+          return (
+            chalk.bold.italic.underline(
+              (token.tokens ?? []).map((_) => format(_)).join(""),
+            ) +
+            EOL +
+            EOL
+          );
+        case 2: // h2
+          return (
+            chalk.bold((token.tokens ?? []).map((_) => format(_)).join("")) +
+            EOL +
+            EOL
+          );
+        default: // h3+
+          return (
+            chalk.bold.dim(
+              (token.tokens ?? []).map((_) => format(_)).join(""),
+            ) +
+            EOL +
+            EOL
+          );
+      }
+    case "hr":
+      return "---";
+    case "image": {
+      const alt = (token.title ?? token.text ?? "").toString().trim();
+      if (alt.length > 0) {
+        return `[Image: ${alt} (${token.href})]`;
+      }
+      return `[Image: ${token.href}]`;
+    }
+    case "link":
+      return terminalLink(token.text, token.href);
+    case "list": {
+      return token.items
+        .map((_: Token, index: number) =>
+          format(
+            _,
+            listDepth,
+            token.ordered ? token.start + index : null,
+            token,
+          ),
+        )
+        .join("");
+    }
+    case "list_item":
+      return (token.tokens ?? [])
+        .map(
+          (_) =>
+            `${"  ".repeat(listDepth)}${format(_, listDepth + 1, orderedListNumber, token)}`,
+        )
+        .join("");
+    case "paragraph":
+      return (token.tokens ?? []).map((_) => format(_)).join("") + EOL;
+    case "space":
+      return EOL;
+    case "text": {
+      if (parent?.type === "list_item") {
+        return `${orderedListNumber === null ? "-" : `${getListNumber(listDepth, orderedListNumber)}.`} ${token.tokens ? token.tokens.map((_) => format(_, listDepth, orderedListNumber, token)).join("") : token.text}${EOL}`;
+      }
+      return token.text;
+    }
+    case "table": {
+      const header = Array.isArray(token.header)
+        ? token.header
+        : [token.header];
+      const rows = Array.isArray(token.rows) ? token.rows : [token.rows];
+
+      // Calculate column widths based on terminal width
+      const padding = 5; // Account for table borders and padding
+      const availableWidth = Math.max(
+        10,
+        (process.stdout.columns || 80) - padding,
+      );
+      const colCount = header?.length ?? 1;
+      const width = Math.max(
+        10,
+        Math.floor(availableWidth / Math.max(1, colCount)),
+      );
+      const computedColWidths: number[] = new Array(colCount).fill(width);
+
+      const table = new Table({
+        head: header.map((h) => h.text),
+        colWidths: computedColWidths,
+        wordWrap: true, // Enable word wrapping for the description column
+      });
+
+      table.push(
+        ...rows.map((row) => row.map((c: { text: string }) => c.text)),
+      );
+
+      return `${table.toString()}\n`;
+    }
+    case "del": {
+      return chalk.strikethrough(token.text);
+    }
+    default:
+      console.log(token.type);
+      return "";
+  }
+}

package/source/terminal/types.ts

@@ -0,0 +1,84 @@
+/**
+ * Terminal theme options
+ */
+type TerminalTheme = "dark" | "light" | "system";
+
+/**
+ * Terminal configuration
+ */
+export interface TerminalConfig {
+  /**
+   * Terminal color theme
+   */
+  theme: TerminalTheme;
+
+  /**
+   * Whether to use colors in output
+   */
+  useColors: boolean;
+
+  /**
+   * Whether to show progress indicators
+   */
+  showProgressIndicators: boolean;
+
+  /**
+   * Whether to enable syntax highlighting for code
+   */
+  codeHighlighting: boolean;
+
+  /**
+   * Maximum terminal height (rows)
+   */
+  maxHeight?: number | undefined;
+
+  /**
+   * Maximum terminal width (columns)
+   */
+  maxWidth?: number | undefined;
+}
+
+/**
+ * Spinner instance for progress indicators
+ */
+export interface SpinnerInstance {
+  /**
+   * Spinner identifier
+   */
+  id: string;
+
+  /**
+   * Update spinner text
+   */
+  update(text: string): SpinnerInstance;
+
+  /**
+   * Mark spinner as successful and stop
+   */
+  succeed(text?: string): SpinnerInstance;
+
+  /**
+   * Mark spinner as failed and stop
+   */
+  fail(text?: string): SpinnerInstance;
+
+  /**
+   * Mark spinner with warning and stop
+   */
+  warn(text?: string): SpinnerInstance;
+
+  /**
+   * Mark spinner with info and stop
+   */
+  info(text?: string): SpinnerInstance;
+
+  /**
+   * Clear spinner without any indicator
+   */
+  clear(): SpinnerInstance;
+
+  /**
+   * Stop spinner without any indicator
+   */
+  stop(): SpinnerInstance;
+}

package/source/terminal-output.test.ts

@@ -0,0 +1,266 @@
+#!/usr/bin/env -S node --no-warnings
+
+/**
+ * Terminal Output Test Module
+ *
+ * Exercises all methods and features of the Terminal class for testing purposes.
+ * Demonstrates various markdown rendering capabilities.
+ */
+
+import { initTerminal } from "./terminal/index.ts";
+
+// Initialize terminal
+const terminal = initTerminal({
+  useColors: true,
+  showProgressIndicators: true,
+});
+
+// Test all terminal methods and features
+function testTerminalOutput(): void {
+  // Clear screen and show welcome
+  terminal.clear();
+  terminal.displayWelcome();
+
+  // Test basic output methods
+  terminal.header("Basic Output Methods");
+  terminal.writeln("This is a basic write line");
+  terminal.write("This is a basic write without newline");
+  terminal.lineBreak();
+  terminal.emphasize("This is emphasized text");
+  terminal.info("This is an info message");
+  terminal.success("This is a success message");
+  terminal.warn("This is a warning message");
+  terminal.error("This is an error message");
+  terminal.lineBreak();
+
+  // Test markdown display
+  terminal.header("Markdown Display Features");
+
+  // Headers
+  terminal.display("# This is an H1 Header");
+  terminal.display("## This is an H2 Header");
+  terminal.display("### This is an H3 Header");
+  terminal.display("#### This is an H4 Header");
+  terminal.display("##### This is an H5 Header");
+  terminal.display("###### This is an H6 Header");
+
+  // Text formatting
+  terminal.display("**This is bold text**");
+  terminal.display("*This is italic text*");
+  terminal.display("***This is bold and italic text***");
+  terminal.display("This is `inline code` text");
+  terminal.display("~~This is strikethrough text~~");
+
+  // Links
+  terminal.display("This is a [link](https://example.com)");
+
+  // Images
+  terminal.display("This is an ![image](https://example.com/image.jpg)");
+
+  // Blockquotes
+  terminal.display("> This is a blockquote");
+  terminal.display("> This is a\n> multi-line blockquote");
+
+  // Horizontal rule
+  terminal.display("---");
+
+  // Lists
+  terminal.display("- This is an unordered list item");
+  terminal.display("- This is another unordered list item");
+  terminal.display("  - This is a nested list item");
+  terminal.display("    - This is a double nested list item");
+
+  terminal.display("1. This is an ordered list item");
+  terminal.display("2. This is another ordered list item");
+  terminal.display("   1. This is a nested ordered list item");
+  terminal.display("   2. This is another nested ordered list item");
+
+  // Code blocks
+  terminal.display(
+    "```javascript\nconst greeting = 'Hello World';\nconsole.log(greeting);\n```",
+  );
+  terminal.display("```python\ndef hello():\n    print('Hello World')\n```");
+  terminal.display("```\nThis is a plain code block\n```");
+
+  // Tables
+  terminal.display(
+    "| Header 1 | Header 2 | Header 3 |\n|----------|----------|----------|\n| Cell 1   | Cell 2   | Cell 3   |\n| Cell 4   | Cell 5   | Cell 6   |",
+  );
+
+  // Paragraphs
+  terminal.display(
+    "This is a paragraph with some **bold** and *italic* text. " +
+      "It also contains `inline code` and a [link](https://example.com). " +
+      "Here's an ![image](image.jpg) for good measure.",
+  );
+
+  terminal.display(
+    "This is another paragraph that demonstrates how line breaks work " +
+      "in markdown with the terminal display. It should wrap appropriately based " +
+      "on the terminal width.",
+  );
+
+  // Complex markdown example
+  const complexMarkdown = `
+# Complex Markdown Example
+
+This is a complex example showing various **markdown** features in *one* document.
+
+## Features Demonstrated
+
+1. **Headers** of different levels
+2. *Text formatting* options
+3. \`Code elements\` of various types
+4. [External links](https://example.com)
+5. ![Images](image.jpg)
+6. Blockquotes
+
+   > Blockquotes
+
+7. Horizontal rules
+8. Lists (ordered and unordered)
+9. Tables
+10. Code blocks
+
+## Code Example
+
+Here's some JavaScript code:
+
+\`\`\`javascript
+function fibonacci(n) {
+  if (n <= 1) return n;
+  return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+console.log(fibonacci(10)); // 55
+\`\`\`
+
+## Table Example
+
+| Name | Age | City |
+|------|-----|------|
+| John | 30  | New York |
+| Jane | 25  | Boston |
+| Bob  | 35  | Chicago |
+
+## Blockquote Example
+
+> This is a blockquote.
+> 
+> It can span multiple lines.
+> 
+> > It can also contain nested blockquotes.
+
+---
+
+## List Examples
+
+### Unordered List
+
+- Item 1
+- Item 2
+  - Nested item 2.1
+  - Nested item 2.2
+    - Double nested item 2.2.1
+- Item 3
+
+### Ordered List
+
+1. First item
+2. Second item
+   1. Nested item 2.1
+   2. Nested item 2.2
+      1. Double nested item 2.2.1
+3. Third item
+
+## Inline Elements
+
+This paragraph contains **bold text**, *italic text*, \`inline code\`, 
+~~strikethrough text~~, [a link](https://example.com), and ![an image](image.jpg).
+
+The end of this complex example.
+  `;
+
+  terminal.header("Complex Markdown Example");
+  terminal.display(complexMarkdown);
+
+  // Test other terminal features
+  terminal.header("Other Terminal Features");
+
+  // Box display
+  terminal.box("Info Box", "This is content inside a box with a header");
+  terminal.box(
+    "Code",
+    `
+\`\`\`javascript
+function fibonacci(n) {
+  if (n <= 1) return n;
+  return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+console.log(fibonacci(10)); // 55
+\`\`\`
+`,
+  );
+
+  terminal.box(
+    "Markdown Block",
+    `
+This paragraph contains **bold text**, *italic text*, \`inline code\`, 
+~~strikethrough text~~, [a link](https://example.com), and ![an image](image.jpg).
+`,
+  );
+
+  // Horizontal rule
+  terminal.hr();
+
+  // Table
+  terminal.table(
+    [
+      ["Headers", "Working"],
+      ["Text Formatting", "Working"],
+      ["Lists", "Working"],
+      ["Code Blocks", "Working"],
+      ["Tables", "Working"],
+      ["Links", "Working"],
+      ["Images", "Working"],
+      ["Blockquotes", "Working"],
+    ],
+    { header: ["Feature", "Status"] },
+  );
+
+  // Progress bar
+  terminal.header("Progress Bar Example");
+  for (let i = 0; i <= 100; i += 10) {
+    terminal.displayProgressBar(i, 100);
+  }
+
+  // Spinner (demonstration)
+  // terminal.header("Spinner Example");
+  // const spinner = terminal.spinner("Loading...");
+  // setTimeout(() => {
+  //   spinner.succeed("Loading complete!");
+  // }, 2000);
+
+  // Terminal info
+  terminal.header("Terminal Information");
+  terminal.writeln(
+    `Terminal size: ${terminal["terminalWidth"]}x${terminal["terminalHeight"]}`,
+  );
+  terminal.writeln(`Is interactive: ${terminal["isInteractive"]}`);
+
+  // Link example
+  terminal.header("Link Example");
+  terminal.writeln(
+    `Visit ${terminal.link("Google", "https://google.com")} for search`,
+  );
+
+  // Alert
+  terminal.alert();
+
+  // Final message
+  terminal.success("All terminal features tested successfully!");
+}
+
+// Run the test
+testTerminalOutput();

package/source/token-tracker.ts

@@ -0,0 +1,78 @@
+import { EventEmitter } from "node:events";
+import { isNumber } from "@travisennis/stdlib/typeguards";
+import type { LanguageModelUsage } from "ai";
+
+interface TokenUsage {
+  tool: string;
+  usage: Partial<LanguageModelUsage>;
+}
+
+interface TokenTrackerEvents {
+  usage: [LanguageModelUsage];
+}
+
+export class TokenTracker extends EventEmitter<TokenTrackerEvents> {
+  private usages: TokenUsage[] = [];
+
+  trackUsage(tool: string, usage: LanguageModelUsage | undefined) {
+    if (usage) {
+      const u = { tool, usage };
+      this.usages.push(u);
+      this.emit("usage", usage);
+    }
+  }
+
+  getTotalUsage(): LanguageModelUsage {
+    return this.usages.reduce(
+      (acc, { usage }) => {
+        acc.inputTokens += isNumber(usage.inputTokens) ? usage.inputTokens : 0;
+        acc.outputTokens += isNumber(usage.outputTokens)
+          ? usage.outputTokens
+          : 0;
+        acc.totalTokens += isNumber(usage.totalTokens) ? usage.totalTokens : 0;
+        return acc;
+      },
+      { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+    );
+  }
+
+  getUsageByApp(app: string): LanguageModelUsage {
+    return this.usages
+      .filter(({ tool }) => tool === app)
+      .reduce(
+        (acc, { usage }) => {
+          acc.inputTokens += isNumber(usage.inputTokens)
+            ? usage.inputTokens
+            : 0;
+          acc.outputTokens += isNumber(usage.outputTokens)
+            ? usage.outputTokens
+            : 0;
+          acc.totalTokens += isNumber(usage.totalTokens)
+            ? usage.totalTokens
+            : 0;
+          return acc;
+        },
+        { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+      );
+  }
+
+  getUsageBreakdown(): Record<string, number> {
+    return this.usages.reduce(
+      (acc, { tool, usage }) => {
+        acc[tool] =
+          (acc[tool] || 0) +
+          (isNumber(usage.totalTokens) ? usage.totalTokens : 0);
+        return acc;
+      },
+      {} as Record<string, number>,
+    );
+  }
+
+  printSummary() {
+    const breakdown = this.getUsageBreakdown();
+    console.info("Token Usage Summary:", {
+      total: this.getTotalUsage(),
+      breakdown,
+    });
+  }
+}

package/source/token-utils.ts

@@ -0,0 +1,17 @@
+import { encoding_for_model, type TiktokenModel } from "tiktoken";
+
+export class TokenCounter {
+  private tiktokenEncoding: ReturnType<typeof encoding_for_model>;
+
+  constructor(model: TiktokenModel = "chatgpt-4o-latest") {
+    this.tiktokenEncoding = encoding_for_model(model);
+  }
+
+  count(input: string): number {
+    return this.tiktokenEncoding.encode(input).length;
+  }
+
+  free() {
+    this.tiktokenEncoding.free();
+  }
+}

package/source/tools/agent.ts

@@ -0,0 +1,107 @@
+import { generateText, stepCountIs, tool } from "ai";
+import chalk from "chalk";
+import { z } from "zod";
+import { AiConfig } from "../models/ai-config.ts";
+import type { ModelManager } from "../models/manager.ts";
+import type { TokenTracker } from "../token-tracker.ts";
+import type { TokenCounter } from "../token-utils.ts";
+import { BashTool } from "./bash.ts";
+import { DirectoryTreeTool } from "./directory-tree.ts";
+import { GrepTool } from "./grep.ts";
+import { initCliTools } from "./index.ts";
+import { ReadFileTool } from "./read-file.ts";
+import { ReadMultipleFilesTool } from "./read-multiple-files.ts";
+import type { SendData } from "./types.ts";
+
+export const AgentTool = {
+  name: "agent" as const,
+};
+
+const TOOLS = [
+  GrepTool.name,
+  BashTool.name,
+  ReadFileTool.name,
+  ReadMultipleFilesTool.name,
+  DirectoryTreeTool.name,
+] as const;
+
+type ToolName = (typeof TOOLS)[number];
+
+function getToolDescription(): string {
+  const toolNames = TOOLS.join(", ");
+  return `Launch a new agent that has access to the following tools: ${toolNames}. When you are searching for a keyword or file and are not confident that you will find the right match on the first try, use the ${AgentTool.name} tool to perform the search for you. For example:
+
+- If you are searching for a keyword like "config" or "logger", the ${AgentTool.name} tool is appropriate
+- If you want to read a specific file path, use the ${ReadFileTool.name} or appropriate command via the ${BashTool.name} tool instead of this tool, to find the match more quickly
+- If you are searching for a specific class definition like "class Foo", use the ${GrepTool.name} tool instead, to find the match more quickly
+
+Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted.`;
+}
+
+const inputSchema = z.object({
+  prompt: z.string().describe("The task for the agent to perform"),
+});
+
+export const createAgentTools = (options: {
+  modelManager: ModelManager;
+  tokenTracker: TokenTracker;
+  tokenCounter: TokenCounter;
+  sendData?: SendData | undefined;
+}) => {
+  const { modelManager, tokenTracker, tokenCounter, sendData } = options;
+  return {
+    [AgentTool.name]: tool({
+      description: getToolDescription(),
+      inputSchema: inputSchema,
+      execute: async ({ prompt }, { abortSignal, toolCallId }) => {
+        sendData?.({
+          event: "tool-init",
+          id: toolCallId,
+          data: `Initializing agent with prompt: ${chalk.cyan(prompt)}`,
+        });
+        try {
+          const modelConfig = modelManager.getModelMetadata("task-agent");
+          const aiConfig = new AiConfig({
+            modelMetadata: modelConfig,
+            prompt: prompt,
+          });
+
+          const { text, usage } = await generateText({
+            model: modelManager.getModel("task-agent"),
+            maxOutputTokens: aiConfig.getMaxTokens(),
+            system:
+              "You are a code search assistant that will be given a task that will require you to search a code base to find relevant code and files.",
+            prompt: prompt,
+            stopWhen: stepCountIs(30),
+            providerOptions: aiConfig.getProviderOptions(),
+            tools: await initCliTools({ tokenCounter }),
+            abortSignal: abortSignal,
+            // biome-ignore lint/style/useNamingConvention: third-party code
+            experimental_activeTools: [...TOOLS] as ToolName[],
+          });
+
+          tokenTracker.trackUsage("task-agent", usage);
+
+          sendData?.({
+            event: "tool-completion",
+            id: toolCallId,
+            data: "Finished running the agent tool.",
+          });
+
+          return text;
+        } catch (error) {
+          sendData?.({
+            event: "tool-error",
+            id: toolCallId,
+            data: "Error running agent tool.",
+          });
+          return Promise.resolve((error as Error).message);
+        }
+      },
+    }),
+  };
+};