@travisennis/acai 0.0.1

package/dist/tools/web-search.d.ts

@@ -0,0 +1,13 @@
+import type { TokenCounter } from "../token-utils.ts";
+import type { SendData } from "./types.ts";
+export declare const WebSearchTool: {
+    name: "webSearch";
+};
+export declare const createWebSearchTool: ({ sendData, tokenCounter, }: {
+    sendData?: SendData;
+    tokenCounter: TokenCounter;
+}) => {
+    webSearch: import("ai").Tool<{
+        query: string;
+    }, string>;
+};

package/dist/tools/web-search.js

@@ -0,0 +1,80 @@
+import { tool } from "ai";
+import chalk from "chalk";
+import { SafeSearchType, search } from "duck-duck-scrape";
+import Exa from "exa-js";
+import { z } from "zod";
+export const WebSearchTool = {
+    name: "webSearch",
+};
+export const createWebSearchTool = ({ sendData, tokenCounter, }) => {
+    return {
+        [WebSearchTool.name]: tool({
+            description: "Searches the web and returns match documents with their title, url, and text content. The query should be formulated as a natural language question.",
+            inputSchema: z.object({
+                query: z.string().describe("The search query."),
+            }),
+            execute: async ({ query }, { toolCallId }) => {
+                sendData?.({
+                    id: toolCallId,
+                    event: "tool-init",
+                    data: `Web search: ${chalk.cyan(query)}`,
+                });
+                const result = await performSearch(query);
+                const sources = result.results.map((source) => `## ${source.title}\nURL: ${source.url}\n\n${source.text}`);
+                const resultText = `# Search Results:\n\n${sources.join("\n\n")}`;
+                const tokenCount = tokenCounter.count(resultText);
+                sendData?.({
+                    id: toolCallId,
+                    event: "tool-completion",
+                    data: `Found ${result.results.length} results. (${tokenCount} tokens)`,
+                });
+                return resultText;
+            },
+        }),
+    };
+};
+async function performSearch(query) {
+    // Check if EXA API key is available
+    const hasExaApiKey = process.env["EXA_API_KEY"] && process.env["EXA_API_KEY"].trim() !== "";
+    if (hasExaApiKey) {
+        // Use Exa search
+        try {
+            const exa = new Exa(process.env["EXA_API_KEY"]);
+            const result = await exa.searchAndContents(query, {
+                numResults: 5,
+                text: true,
+            });
+            return result;
+        }
+        catch (error) {
+            // If Exa fails, fall back to duck duck scrape
+            console.info("Exa search failed, falling back to DuckDuckGo:", error);
+            return await searchWithDuckDuckGo(query);
+        }
+    }
+    else {
+        // Use DuckDuckGo search as fallback
+        console.info("EXA_API_KEY not set, using DuckDuckGo search");
+        return await searchWithDuckDuckGo(query);
+    }
+}
+async function searchWithDuckDuckGo(query) {
+    try {
+        const searchResults = await search(query, {
+            safeSearch: SafeSearchType.MODERATE,
+        });
+        // Transform duck-duck-scrape results to match Exa format
+        // Take only first 5 results to match Exa behavior
+        const results = searchResults.results
+            .slice(0, 5)
+            .map((result) => ({
+            title: result.title,
+            url: result.url,
+            text: result.description || "",
+        }));
+        return { results };
+    }
+    catch (error) {
+        throw new Error(`Failed to perform web search: ${error}`);
+    }
+}

package/dist/utils/process.d.ts

@@ -0,0 +1,36 @@
+interface ExecuteOptions {
+    /** Working directory where the command will be executed */
+    cwd?: string;
+    /** Timeout in milliseconds before killing the process */
+    timeout?: number;
+    /** AbortSignal to cancel the execution */
+    abortSignal?: AbortSignal;
+    /** Whether to use shell syntax (defaults to false) */
+    shell?: boolean;
+    /** Whether to throw an error on non-zero exit codes (defaults to false) */
+    throwOnError?: boolean;
+    /** Whether to include stdout/stderr in the result even when there's an error (defaults to true) */
+    preserveOutputOnError?: boolean;
+    /** Maximum buffer size in bytes (defaults to 1MB) */
+    maxBuffer?: number;
+}
+export interface ExecuteResult {
+    /** Standard output from the command */
+    stdout: string;
+    /** Standard error from the command */
+    stderr: string;
+    /** Exit code (0 for success, non-zero for errors) */
+    code: number;
+    /** The signal that terminated the process, if any */
+    signal?: NodeJS.Signals;
+}
+/**
+ * Executes a command and returns the result, providing unified error handling
+ *
+ * @param command Either a string command with arguments or an array where the first item is the command
+ *               and the rest are arguments
+ * @param options Execution options
+ * @returns Promise resolving to an object containing stdout, stderr, and exit code
+ */
+export declare function executeCommand(command: string | [string, ...string[]], options?: ExecuteOptions): Promise<ExecuteResult>;
+export {};

package/dist/utils/process.js

@@ -0,0 +1,75 @@
+import { execFile } from "node:child_process";
+import { isUndefined } from "@travisennis/stdlib/typeguards";
+const MS_IN_SECOND = 1000;
+const SECONDS_IN_MINUTE = 60;
+const DEFAULT_TIMEOUT = 2 * SECONDS_IN_MINUTE * MS_IN_SECOND;
+/**
+ * Executes a command and returns the result, providing unified error handling
+ *
+ * @param command Either a string command with arguments or an array where the first item is the command
+ *               and the rest are arguments
+ * @param options Execution options
+ * @returns Promise resolving to an object containing stdout, stderr, and exit code
+ */
+export function executeCommand(command, options) {
+    const { cwd = process.cwd(), timeout = DEFAULT_TIMEOUT, abortSignal, shell = false, throwOnError = false, preserveOutputOnError = true, maxBuffer = 1_000_000, } = options || {};
+    let cmd;
+    let args;
+    if (Array.isArray(command)) {
+        [cmd, ...args] = command;
+    }
+    else {
+        const parts = command.split(" ");
+        cmd = parts[0] ?? "";
+        args = parts.slice(1);
+    }
+    if (isUndefined(cmd) || cmd.trim() === "") {
+        const result = {
+            stdout: "",
+            stderr: "Missing command",
+            code: 1,
+        };
+        return throwOnError
+            ? Promise.reject(new Error("Missing command"))
+            : Promise.resolve(result);
+    }
+    return new Promise((resolve, reject) => {
+        try {
+            execFile(cmd, args, {
+                cwd,
+                timeout,
+                signal: abortSignal,
+                shell,
+                maxBuffer,
+            }, (error, stdout, stderr) => {
+                if (error) {
+                    const errorCode = typeof error.code === "number" ? error.code : 1;
+                    const result = {
+                        stdout: preserveOutputOnError ? stdout : "",
+                        stderr: preserveOutputOnError ? stderr : "",
+                        code: errorCode,
+                        signal: error.signal ?? undefined,
+                    };
+                    if (throwOnError) {
+                        reject(Object.assign(error, { result }));
+                    }
+                    else {
+                        resolve(result);
+                    }
+                }
+                else {
+                    resolve({ stdout, stderr, code: 0 });
+                }
+            });
+        }
+        catch (error) {
+            const result = { stdout: "", stderr: "", code: 1 };
+            if (throwOnError) {
+                reject(error);
+            }
+            else {
+                resolve(result);
+            }
+        }
+    });
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare function getPackageVersion(fallback?: string): string;

package/dist/version.js

@@ -0,0 +1,21 @@
+import { readFileSync } from "node:fs";
+import { join } from "@travisennis/stdlib/desm";
+export function getPackageVersion(fallback = "unavailable") {
+    try {
+        const pkgPath = join(import.meta.url, "..", "package.json");
+        const pkgRaw = readFileSync(pkgPath, "utf8");
+        const parsed = JSON.parse(pkgRaw);
+        const v = typeof parsed.version === "string" ? parsed.version : undefined;
+        if (v && v.length > 0) {
+            return v;
+        }
+    }
+    catch {
+        // ignore
+    }
+    const envV = process.env["npm_package_version"];
+    if (typeof envV === "string" && envV.length > 0) {
+        return envV;
+    }
+    return fallback;
+}

package/knip.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://unpkg.com/knip@5/schema.json",
+  "entry": ["source/index.ts"],
+  "project": ["source/**/*.{js,ts}"]
+}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@travisennis/acai",
+  "version": "0.0.1",
+  "description": "An AI assistant for developing software.",
+  "type": "module",
+  "bin": {
+    "acai": "dist/index.js"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "llm",
+    "coding",
+    "assistant"
+  ],
+  "author": "Travis Ennis",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc --pretty -p tsconfig.build.json",
+    "clean": "rm -rf ./dist/",
+    "compile": "tsc --pretty -p tsconfig.json",
+    "lint": "biome lint",
+    "lint:fix": "biome lint --unsafe --write",
+    "lint:staged": "biome lint --error-on-warnings --no-errors-on-unmatched --staged",
+    "format:staged": "biome check --staged --formatter-enabled=true --linter-enabled=false --no-errors-on-unmatched",
+    "prepare": "husky",
+    "test": "c8 node --no-warnings --test test/**/*.test.ts",
+    "pretest": "npm run compile",
+    "format": "biome check --formatter-enabled=true --linter-enabled=false --write ./ && biome format --write",
+    "dev": "node --no-warnings --env-file=.env ./source/index.ts",
+    "oxlint": "npx oxlint@latest --ignore-path .gitignore --deny correctness --deny suspicous --deny pedantic --deny style --node-plugin",
+    "knip": "npx knip",
+    "check": "npx npm-check-updates --interactive --format group",
+    "cpd": "npx jscpd ./source",
+    "typecheck:staged": "tsc --noEmit --pretty -p tsconfig.json"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^2.0.2",
+    "@ai-sdk/deepseek": "^1.0.6",
+    "@ai-sdk/google": "^2.0.5",
+    "@ai-sdk/openai": "^2.0.11",
+    "@ai-sdk/openai-compatible": "^1.0.6",
+    "@crosscopy/clipboard": "^0.2.8",
+    "@inquirer/prompts": "^7.8.1",
+    "@travisennis/stdlib": "^0.0.13",
+    "ai": "^5.0.11",
+    "chalk": "^5.5.0",
+    "cheerio": "^1.1.2",
+    "cli-highlight": "^2.1.11",
+    "cli-table3": "^0.6.5",
+    "diff": "^8.0.2",
+    "duck-duck-scrape": "^2.2.7",
+    "exa-js": "^1.8.27",
+    "globby": "^14.1.0",
+    "ignore": "^7.0.5",
+    "log-update": "^6.1.0",
+    "marked": "16.1.2",
+    "node-notifier": "^10.0.1",
+    "ora": "^8.2.0",
+    "p-throttle": "^7.0.0",
+    "pino": "^9.8.0",
+    "pino-pretty": "^13.1.1",
+    "pino-roll": "^3.1.0",
+    "simple-git": "^3.28.0",
+    "tiktoken": "^1.0.22",
+    "wrap-ansi": "^9.0.0",
+    "zod": "^3.25.75"
+  },
+  "devDependencies": {
+    "@ai-sdk/provider": "^2.0.0",
+    "@biomejs/biome": "2.1.4",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@types/node": "^24.2.1",
+    "@types/node-notifier": "^8.0.5",
+    "c8": "^10.1.3",
+    "commitlint": "^19.8.1",
+    "husky": "^9.1.7",
+    "typescript": "^5.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/source/cli.ts

@@ -0,0 +1,172 @@
+import type { AsyncReturnType } from "@travisennis/stdlib/types";
+import {
+  generateObject,
+  generateText,
+  NoSuchToolError,
+  stepCountIs,
+  type ToolCallRepairFunction,
+} from "ai";
+import type z from "zod";
+import { logger } from "./logger.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 { minSystemPrompt } from "./prompts.ts";
+import type { TokenTracker } from "./token-tracker.ts";
+import type { TokenCounter } from "./token-utils.ts";
+import { DeleteFileTool } from "./tools/delete-file.ts";
+import { EditFileTool } from "./tools/edit-file.ts";
+import { initCliTools } from "./tools/index.ts";
+import { MoveFileTool } from "./tools/move-file.ts";
+import { SaveFileTool } from "./tools/save-file.ts";
+import { ThinkTool } from "./tools/think.ts";
+
+interface CliOptions {
+  messageHistory: MessageHistory;
+  promptManager: PromptManager;
+  modelManager: ModelManager;
+  tokenTracker: TokenTracker;
+  config: Record<PropertyKey, unknown>;
+  tokenCounter: TokenCounter;
+}
+
+type CompleteToolSet = AsyncReturnType<typeof initCliTools>;
+
+export class Cli {
+  private options: CliOptions;
+  constructor(options: CliOptions) {
+    this.options = options;
+  }
+
+  async run() {
+    const {
+      config,
+      promptManager,
+      modelManager,
+      tokenTracker,
+      messageHistory,
+      tokenCounter,
+    } = this.options;
+
+    logger.info(config, "Config:");
+
+    const abortController = new AbortController();
+    const { signal } = abortController;
+
+    const cb = () => {
+      abortController.abort();
+    };
+
+    // Handle Ctrl+C (SIGINT)
+    process.on("SIGINT", cb);
+
+    const langModel = modelManager.getModel("cli");
+    const modelConfig = modelManager.getModelMetadata("cli");
+
+    const userPrompt = promptManager.get();
+
+    const userMsg = promptManager.getUserMessage();
+
+    messageHistory.appendUserMessage(userMsg);
+
+    const finalSystemPrompt = await minSystemPrompt();
+
+    const aiConfig = new AiConfig({
+      modelMetadata: modelConfig,
+      prompt: userPrompt,
+    });
+
+    const maxTokens = aiConfig.getMaxTokens();
+
+    const tools = modelConfig.supportsToolCalling
+      ? await initCliTools({ tokenCounter })
+      : undefined;
+
+    try {
+      const result = await generateText({
+        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_activeTools: [
+          EditFileTool.name,
+          SaveFileTool.name,
+          MoveFileTool.name,
+          DeleteFileTool.name,
+          ThinkTool.name,
+        ],
+        // biome-ignore lint/style/useNamingConvention: third-party controlled
+        experimental_repairToolCall: modelConfig.supportsToolCalling
+          ? toolCallRepair(modelManager)
+          : undefined,
+        abortSignal: signal,
+      });
+
+      if (result.response.messages.length > 0) {
+        messageHistory.appendResponseMessages(result.response.messages);
+      }
+
+      // this tracks the usage of every step in the call to streamText. it's a cumulative usage.
+      tokenTracker.trackUsage("cli", result.usage);
+
+      process.stdout.end(
+        result.text.endsWith("\n") ? result.text : `${result.text}\n`,
+      );
+    } catch (e) {
+      if (e instanceof Error) {
+        logger.error(e);
+      } else {
+        logger.error(JSON.stringify(e, null, 2));
+      }
+    }
+  }
+}
+
+const toolCallRepair = (modelManager: ModelManager) => {
+  const fn: ToolCallRepairFunction<CompleteToolSet> = async ({
+    toolCall,
+    tools,
+    inputSchema,
+    error,
+  }) => {
+    if (NoSuchToolError.isInstance(error)) {
+      return null; // do not attempt to fix invalid tool names
+    }
+    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/commands/application-log-command.ts

@@ -0,0 +1,53 @@
+import { readFile } from "node:fs/promises";
+import { editor } from "@inquirer/prompts";
+import { config } from "../config.ts";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const applicationLogCommand = ({
+  terminal,
+}: CommandOptions): ReplCommand => {
+  return {
+    command: "/application-logs",
+    description:
+      "Opens the application log file defined in acai.json in the editor.",
+    result: "continue" as const,
+    getSubCommands: () => Promise.resolve([]),
+    execute: async () => {
+      let logFilePath: string | undefined;
+      try {
+        const projectConfig = await config.readProjectConfig();
+        logFilePath = projectConfig.logs?.path;
+
+        if (!logFilePath) {
+          terminal.error(
+            "Application log path is not defined in .acai/acai.json under the 'logs.path' key.",
+          );
+          return;
+        }
+
+        const content = await readFile(logFilePath, { encoding: "utf8" });
+
+        // Use the editor prompt to display the content (read-only)
+        await editor({
+          message: `Viewing ${logFilePath}`,
+          // Attempt to infer postfix from file extension, default otherwise
+          postfix: logFilePath.includes(".")
+            ? `.${logFilePath.split(".").pop()}`
+            : ".log",
+          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 for: ${logFilePath}`);
+      } catch (error) {
+        if (logFilePath && (error as NodeJS.ErrnoException).code === "ENOENT") {
+          terminal.error(`Application log file not found at: ${logFilePath}`);
+        } else {
+          terminal.error(
+            `Error reading or displaying log file ${logFilePath ?? "specified in config"}: ${error}`,
+          );
+        }
+      }
+    },
+  };
+};

package/source/commands/clear-command.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const clearCommand = ({ terminal }: CommandOptions): ReplCommand => {
+  return {
+    command: "/clear",
+    description: "Clears the terminal screen.",
+    result: "continue" as const, // Keep the REPL running
+    getSubCommands: () => Promise.resolve([]),
+    execute: () => {
+      terminal.clear();
+      return Promise.resolve();
+    },
+  };
+};

package/source/commands/compact-command.ts

@@ -0,0 +1,64 @@
+import { generateText } from "ai";
+import { createUserMessage } from "../messages.ts";
+import type { CommandOptions, ReplCommand } from "./types.ts";
+
+export const compactCommand = (options: CommandOptions): ReplCommand => {
+  return {
+    command: "/compact",
+    description:
+      "Saves, summarizes, and resets the chat history. Optional instructions can be provided for the summary.",
+    result: "continue" as const,
+    getSubCommands: () => Promise.resolve([]),
+    execute: async (args: string[]) => {
+      const { messageHistory, terminal } = options;
+      if (!messageHistory.isEmpty()) {
+        const additionalInstructions = args.join(" ");
+        await summarizeAndReset(options, additionalInstructions);
+      }
+      terminal.info("Message history summarized and reset.");
+    },
+  };
+};
+
+async function summarizeAndReset(
+  { messageHistory, modelManager, tokenTracker }: CommandOptions,
+  additionalInstructions?: string,
+) {
+  const app = "conversation-summarizer";
+
+  // save existing message history
+  await messageHistory.save();
+
+  // summarize message history
+  let userPrompt = `Your tasks is to provide a detailed summary of our conversation so far. Focus on information that would be helpful for continuing the conversation and the task, including what was the orginal task requested by the user, what we have done so far and why, which files we're working on, and what we're going to do next. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently. You need to provide enough information that another coding agent can you use your summary to pick up where you have left off.
+
+Your summary should include the following sections:
+1. Primary Request and Intent: Capture all of the user's explicit requests and intents in detail
+2. Key Technical Concepts: List all important technical concepts, technologies, and frameworks discussed.
+3. Files and Code Sections: Enumerate specific files and code sections examined, modified, or created. Pay special attention to the most recent messages and include full code snippets where applicable and include a summary of why this file read or edit is important.
+4. Errors and fixes: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+5. Problem Solving: Document problems solved and any ongoing troubleshooting efforts.
+6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent.
+7. Pending Tasks: Outline any pending tasks that you have explicitly been asked to work on.
+8. Current Work: Describe in detail precisely what was being worked on immediately before this summary request, paying special attention to the most recent messages from both user and assistant. Include file names and code snippets where applicable.
+9. Optional Next Step: List the next step that you will take that is related to the most recent work you were doing. IMPORTANT: ensure that this step is DIRECTLY in line with the user's explicit requests, and the task you were working on immediately before this summary request. If your last task was concluded, then only list next steps if they are explicitly in line with the users request. Do not start on tangential requests without confirming with the user first.
+
+ If there is a next step, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no drift in task interpretation.`;
+  if (additionalInstructions && additionalInstructions.trim().length > 0) {
+    userPrompt += `\n\nAdditional instructions provided by the user: ${additionalInstructions}`;
+  }
+  messageHistory.appendUserMessage(createUserMessage([], userPrompt));
+  const { text, usage } = await generateText({
+    model: modelManager.getModel(app),
+    system:
+      "You are a helpful AI assistant tasked with summarizing conversations so that a coding agent such as yourself can understand what actions have been taken on a code base and what future work still needs to be done.",
+    messages: messageHistory.get(),
+  });
+
+  tokenTracker.trackUsage(app, usage);
+
+  //clear messages
+  messageHistory.clear();
+
+  messageHistory.appendUserMessage(createUserMessage([text]));
+}