@travisennis/acai 0.0.1

package/dist/source/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/source/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/source/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/source/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/source/version.d.ts

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

package/dist/source/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/dist/terminal/formatting.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Terminal Formatting Utilities
+ *
+ * Provides functions for formatting and displaying text in the terminal.
+ */
+/**
+ * Clear the terminal screen
+ */
+export declare function clearScreen(): void;
+/**
+ * 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 declare function clearTerminal(): Promise<void>;
+/**
+ * Sets the terminal title
+ */
+export declare function setTerminalTitle(title: string): void;
+/**
+ * Get the terminal size (rows and columns)
+ */
+export declare function getTerminalSize(): {
+    rows: number;
+    columns: number;
+};
+/**
+ * Word wrap text to the specified width
+ */
+export declare function wordWrap(text: string, width: number): string;
+export declare const link: (text: string, url: string) => string;

package/dist/terminal/formatting.js

@@ -0,0 +1,106 @@
+/**
+ * Terminal Formatting Utilities
+ *
+ * Provides functions for formatting and displaying text in the terminal.
+ */
+import chalk from "chalk";
+/**
+ * Clear the terminal screen
+ */
+export function clearScreen() {
+    // 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() {
+    return new Promise((resolve) => {
+        process.stdout.write("\x1b[2J\x1b[3J\x1b[H", () => {
+            resolve();
+        });
+    });
+}
+/**
+ * Sets the terminal title
+ */
+export function setTerminalTitle(title) {
+    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() {
+    // 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, width) {
+    const lines = text.split("\n");
+    return lines.map((line) => wrapLine(line, width)).join("\n");
+}
+function wrapLine(line, width) {
+    // 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 = [];
+    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, url) => chalk.underline.blue([OSC, "8", SEP, SEP, url, BEL, text, OSC, "8", SEP, SEP, BEL].join(""));

package/dist/terminal/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Terminal Interface Module
+ *
+ * Provides a user interface for interacting with Claude Code in the terminal.
+ * Handles input/output, formatting, and display.
+ */
+import { type ChalkInstance } from "chalk";
+import type { SpinnerInstance, TerminalConfig } from "./types.ts";
+/**
+ * Initialize the terminal interface
+ */
+export declare function initTerminal(config?: Partial<TerminalConfig>): Terminal;
+/**
+ * Terminal class for handling user interaction
+ */
+export declare class Terminal {
+    private config;
+    private activeSpinners;
+    private terminalWidth;
+    private terminalHeight;
+    private isInteractive;
+    constructor(config: TerminalConfig);
+    /**
+     * Detect terminal capabilities
+     */
+    detectCapabilities(): void;
+    setTitle(title: string): void;
+    getLogo(): string;
+    /**
+     * Display the welcome message
+     */
+    displayWelcome(): void;
+    /**
+     * Clear the terminal screen
+     */
+    clear(): void;
+    /**
+     * Display formatted content
+     */
+    display(content: string, wrap?: boolean): void;
+    /**
+     * Display a message with emphasis
+     */
+    emphasize(message: string): void;
+    /**
+     * Display an informational message
+     */
+    info(message: string): void;
+    /**
+     * Display a success message
+     */
+    success(message: string): void;
+    /**
+     * Display a warning message
+     */
+    warn(message: string): void;
+    /**
+     * Display an error message
+     */
+    error(message: string): void;
+    /**
+     * Emits an alert.
+     */
+    alert(): void;
+    write(input: string): void;
+    writeln(input: string): void;
+    lineBreak(): void;
+    header(header: string, chalkFn?: ChalkInstance): void;
+    box(header: string, content: string): Promise<void>;
+    hr(chalkFn?: ChalkInstance): void;
+    /**
+     * Create a clickable link in the terminal if supported
+     */
+    link(text: string, url: string): string;
+    /**
+     * Display a table of data
+     */
+    table(data: [string, string | number][], options?: {
+        header?: string[];
+        colWidths?: number[];
+    }): void;
+    /**
+     * Create a spinner for showing progress
+     */
+    spinner(text: string, id?: string): SpinnerInstance;
+    /**
+     * Displays a horizontal progress bar in the console.
+     * @param current The current value.
+     * @param total The target value.
+     */
+    displayProgressBar(current: number, total: number): void;
+    private formatMarkdown;
+}
+export * from "./types.ts";