@travisennis/acai 0.0.1 → 0.0.3

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

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

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

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

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

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

package/dist/source/version.js

@@ -1,21 +0,0 @@
-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-output.d.ts

@@ -1,8 +0,0 @@
-#!/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.
- */
-export {};

package/dist/terminal-output.js

@@ -1,213 +0,0 @@
-#!/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.js";
-// Initialize terminal
-const terminal = initTerminal({
-    useColors: true,
-    showProgressIndicators: true,
-});
-// Test all terminal methods and features
-function testTerminalOutput() {
-    // 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/dist/tools/memory-read.d.ts

@@ -1,13 +0,0 @@
-import type { SendData } from "./types.ts";
-export declare const MemoryReadTool: {
-    name: "memoryRead";
-};
-export declare const createMemoryReadTool: (options?: {
-    sendData?: SendData | undefined;
-}) => {
-    memoryRead: import("ai").Tool<{
-        filePath: string | null;
-    }, string | {
-        content: string;
-    }>;
-};

package/dist/tools/memory-read.js

@@ -1,135 +0,0 @@
-import { access, lstat, mkdir, readdir, readFile } from "node:fs/promises";
-import { isAbsolute, join, normalize, resolve, sep } from "node:path";
-import { tool } from "ai";
-import { z } from "zod";
-import { config } from "../config.js";
-export const MemoryReadTool = {
-    name: "memoryRead",
-};
-const MEMORY_DIR = config.app.ensurePathSync("memory");
-// Helper to check if a file exists
-// Moved to module level as it does not use sendData
-async function fileExists(filePath) {
-    try {
-        await access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// Helper function, does not use sendData directly
-const _readSpecificMemoryFile = async (resolvedMemoryDir, filePath) => {
-    const normalizedRelativePath = normalize(filePath);
-    if (normalizedRelativePath.startsWith("..") ||
-        normalizedRelativePath.includes("..") ||
-        isAbsolute(normalizedRelativePath)) {
-        throw new Error(`Error: Invalid filePath "${filePath}". Must be a relative path and cannot use '..'.`);
-    }
-    const fullPath = join(resolvedMemoryDir, normalizedRelativePath);
-    if (!fullPath.startsWith(resolvedMemoryDir + sep) &&
-        fullPath !== resolvedMemoryDir) {
-        throw new Error(`Error: Path "${filePath}" resolves outside the allowed memory directory.`);
-    }
-    if (!(await fileExists(fullPath))) {
-        throw new Error(`Error: Memory file '${filePath}' does not exist.`);
-    }
-    const stats = await lstat(fullPath);
-    if (stats.isDirectory()) {
-        throw new Error(`Error: '${filePath}' is a directory. Please provide a path to a file to read.`);
-    }
-    const content = await readFile(fullPath, "utf-8");
-    return { filePath, content };
-};
-// Helper function, does not use sendData directly
-const _listMemoryFilesAndIndex = async (resolvedMemoryDir) => {
-    const entries = await readdir(resolvedMemoryDir, {
-        recursive: true,
-        withFileTypes: true,
-    });
-    const filesOnly = entries
-        .filter((entry) => entry.isFile())
-        .map((entry) => join(entry.parentPath ?? resolvedMemoryDir, entry.name)); // entry.path is available with recursive
-    const fileListString = filesOnly.length > 0
-        ? filesOnly
-            .map((p) => `- ${normalize(p.replace(resolvedMemoryDir + sep, ""))}`)
-            .join("\n") // Show relative paths
-        : "No files in memory.";
-    const indexPath = join(resolvedMemoryDir, "index.md");
-    let indexContent = "(empty)";
-    if (await fileExists(indexPath)) {
-        const stats = await lstat(indexPath);
-        if (stats.isFile()) {
-            indexContent = await readFile(indexPath, "utf-8");
-        }
-    }
-    const output = `Root memory file (index.md):
-'''
-${indexContent}
-'''
-
-Files in the memory directory:
-${fileListString}`;
-    return { content: output };
-};
-export const createMemoryReadTool = (options = {}) => {
-    const { sendData } = options;
-    const memoryReadTool = tool({
-        description: 'Read from memory files. If no path is provided, lists all files and shows content of "index.md".',
-        inputSchema: z.object({
-            filePath: z
-                .string()
-                .nullable()
-                .describe('Optional path to a specific memory file to read, relative to the memory directory. Cannot use ".." or absolute paths.'),
-        }),
-        execute: async ({ filePath }, { toolCallId }) => {
-            sendData?.({
-                event: "tool-init",
-                id: toolCallId,
-                data: "Initializing memory read...",
-            });
-            const resolvedMemoryDir = resolve(MEMORY_DIR);
-            try {
-                await mkdir(resolvedMemoryDir, { recursive: true });
-                let result;
-                if (filePath) {
-                    sendData?.({
-                        event: "tool-update",
-                        id: toolCallId,
-                        data: { primary: "Reading file:", secondary: [filePath] },
-                    });
-                    result = await _readSpecificMemoryFile(resolvedMemoryDir, filePath);
-                }
-                else {
-                    sendData?.({
-                        event: "tool-update",
-                        id: toolCallId,
-                        data: { primary: "Listing memory files and index" },
-                    });
-                    result = await _listMemoryFilesAndIndex(resolvedMemoryDir);
-                }
-                sendData?.({
-                    event: "tool-completion",
-                    id: toolCallId,
-                    data: "Done",
-                });
-                return result;
-            }
-            catch (error) {
-                let errorMsg = "Error reading memory: An unknown error occurred";
-                if (error instanceof Error) {
-                    errorMsg = `Error reading memory: ${error.message}`;
-                }
-                sendData?.({
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: errorMsg,
-                });
-                return errorMsg;
-            }
-        },
-    });
-    return {
-        [MemoryReadTool.name]: memoryReadTool,
-    };
-};

package/dist/tools/memory-write.d.ts

@@ -1,12 +0,0 @@
-import type { SendData } from "./types.ts";
-export declare const MemoryWriteTool: {
-    name: "memoryWrite";
-};
-export declare const createMemoryWriteTool: (options?: {
-    sendData?: SendData | undefined;
-}) => {
-    memoryWrite: import("ai").Tool<{
-        filePath: string;
-        content: string;
-    }, string>;
-};