@travisennis/acai 0.0.1 → 0.0.3

package/dist/source/index.js

@@ -1,213 +0,0 @@
-import { text } from "node:stream/consumers";
-import { parseArgs } from "node:util";
-import { select } from "@inquirer/prompts";
-import { asyncTry } from "@travisennis/stdlib/try";
-import { isDefined } from "@travisennis/stdlib/typeguards";
-import { Cli } from "./cli.js";
-import { CommandManager } from "./commands/manager.js";
-import { config } from "./config.js";
-import { logger } from "./logger.js";
-import { MessageHistory } from "./messages.js";
-import { ModelManager } from "./models/manager.js";
-import { isSupportedModel } from "./models/providers.js";
-import { PromptManager } from "./prompts/manager.js";
-import { Repl } from "./repl.js";
-import { initTerminal } from "./terminal/index.js";
-import { TokenTracker } from "./token-tracker.js";
-import { TokenCounter } from "./token-utils.js";
-import { getPackageVersion } from "./version.js";
-const helpText = `
-Usage
-  $ acai <input>
-
-Options
-  --model, -m        Sets the model to use
-  --prompt, -p       Sets the prompt
-  --oneshot, -o      Run once and exit
-  --continue         Load the most recent conversation
-  --resume           Select a recent conversation to resume
-  --autoAcceptAll    Accept all commands and edits without prompting
-  --help, -h         Show help
-  --version, -v      Show version
-
-Examples
-  $ acai --model anthopric:sonnet
-  $ acai -p "initial prompt"
-  $ acai -p "one-shot prompt" -o
-`;
-const parsed = parseArgs({
-    options: {
-        model: { type: "string", short: "m" },
-        prompt: { type: "string", short: "p" },
-        oneshot: { type: "boolean", short: "o", default: false },
-        continue: { type: "boolean", default: false },
-        resume: { type: "boolean", default: false },
-        autoAcceptAll: { type: "boolean", default: false },
-        help: { type: "boolean", short: "h" },
-        version: { type: "boolean", short: "v" },
-    },
-    allowPositionals: true,
-});
-const flags = parsed.values;
-const input = parsed.positionals;
-/**
- * Global error handler function.
- * @param {Error} error - The error to be handled.
- * @throws {Error} Rethrows the error after logging it.
- */
-export function handleError(error) {
-    logger.error({ error: error }, error.message);
-}
-async function main() {
-    const appConfig = await config.ensureAppConfig("acai");
-    if (flags.version === true) {
-        console.info(getPackageVersion());
-        process.exit(0);
-    }
-    if (flags.help === true) {
-        console.info(helpText);
-        process.exit(0);
-    }
-    const appDir = config.app;
-    const messageHistoryDir = await appDir.ensurePath("message-history");
-    // --- Argument Validation ---
-    if (flags.continue === true && flags.resume === true) {
-        console.error("Cannot use --continue and --resume flags together.");
-        process.exit(1);
-    }
-    const hasContinueOrResume = flags.continue === true || flags.resume === true;
-    if (hasContinueOrResume && flags.oneshot === true) {
-        console.error("Cannot use --continue or --resume with --oneshot.");
-        process.exit(1);
-    }
-    // --- Determine Initial Prompt (potential conflict) ---
-    const positionalPrompt = input.at(0);
-    let stdInPrompt;
-    // Check if there's data available on stdin
-    if (!process.stdin.isTTY) {
-        try {
-            // Non-TTY stdin means data is being piped in
-            stdInPrompt = await text(process.stdin);
-        }
-        catch (error) {
-            console.error(`Error reading stdin: ${error.message}`);
-        }
-    }
-    const initialPromptInput = typeof flags.prompt === "string" && flags.prompt.length > 0
-        ? flags.prompt
-        : positionalPrompt && positionalPrompt.length > 0
-            ? positionalPrompt
-            : undefined;
-    if (hasContinueOrResume && isDefined(initialPromptInput)) {
-        console.error("Cannot use --continue or --resume with an initial prompt.");
-        process.exit(1);
-    }
-    const terminal = initTerminal();
-    terminal.setTitle(`acai: ${process.cwd()}`);
-    const chosenModel = isSupportedModel(flags.model)
-        ? flags.model
-        : "openrouter:sonnet4";
-    const modelManager = new ModelManager({
-        stateDir: await appDir.ensurePath("audit"),
-    });
-    modelManager.setModel("repl", chosenModel);
-    modelManager.setModel("cli", chosenModel);
-    modelManager.setModel("title-conversation", "openrouter:gemini-flash25");
-    modelManager.setModel("conversation-summarizer", "openrouter:gemini-flash25");
-    modelManager.setModel("tool-repair", "openai:gpt-4.1");
-    modelManager.setModel("conversation-analyzer", "openrouter:gemini-flash25");
-    modelManager.setModel("init-project", chosenModel);
-    modelManager.setModel("task-agent", "openrouter:gemini-flash25");
-    const tokenTracker = new TokenTracker();
-    const tokenCounter = new TokenCounter();
-    const messageHistory = new MessageHistory({
-        stateDir: messageHistoryDir,
-        modelManager,
-        tokenTracker,
-    });
-    messageHistory.on("update-title", (title) => terminal.setTitle(title));
-    if (flags.continue === true) {
-        const histories = await MessageHistory.load(messageHistoryDir, 1);
-        const latestHistory = histories.at(0);
-        if (latestHistory) {
-            messageHistory.restore(latestHistory);
-            console.info(`Resuming conversation: ${latestHistory.title}`);
-            // Set terminal title after restoring
-            terminal.setTitle(latestHistory.title || `acai: ${process.cwd()}`);
-        }
-        else {
-            logger.info("No previous conversation found to continue.");
-        }
-    }
-    else if (flags.resume === true) {
-        const histories = await MessageHistory.load(messageHistoryDir, 10);
-        if (histories.length > 0) {
-            const choice = await select({
-                message: "Select a conversation to resume:",
-                choices: histories.map((h, index) => ({
-                    name: `${index + 1}: ${h.title} (${h.updatedAt.toLocaleString()})`,
-                    value: index,
-                    description: `${h.messages.length} messages`,
-                })),
-            });
-            const selectedHistory = histories.at(choice);
-            if (selectedHistory) {
-                messageHistory.restore(selectedHistory);
-                logger.info(`Resuming conversation: ${selectedHistory.title}`);
-                // Set terminal title after restoring
-                terminal.setTitle(selectedHistory.title || `acai: ${process.cwd()}`);
-            }
-            else {
-                // This case should theoretically not happen if choice is valid
-                logger.error("Selected history index out of bounds.");
-            }
-        }
-        else {
-            logger.info("No previous conversations found to resume.");
-        }
-    }
-    // --- Setup Prompt Manager (only if not continuing/resuming) ---
-    const promptManager = new PromptManager(tokenCounter);
-    if (!hasContinueOrResume && isDefined(initialPromptInput)) {
-        promptManager.set(initialPromptInput);
-    }
-    if (stdInPrompt) {
-        promptManager.addContext(stdInPrompt);
-    }
-    const toolEvents = new Map();
-    const commands = new CommandManager({
-        promptManager,
-        modelManager,
-        terminal,
-        messageHistory,
-        tokenTracker,
-        config,
-        tokenCounter,
-        toolEvents,
-    });
-    if (flags.oneshot === true) {
-        const cliProcess = new Cli({
-            promptManager,
-            config: appConfig,
-            messageHistory,
-            modelManager,
-            tokenTracker,
-            tokenCounter,
-        });
-        return (await asyncTry(cliProcess.run())).recover(handleError);
-    }
-    const repl = new Repl({
-        promptManager,
-        terminal,
-        config: appConfig,
-        messageHistory,
-        modelManager,
-        tokenTracker,
-        commands,
-        tokenCounter,
-        toolEvents,
-        autoAcceptAll: flags.autoAcceptAll === true,
-    });
-    return (await asyncTry(repl.run())).recover(handleError);
-}
-main();

package/dist/source/logger.d.ts

@@ -1,2 +0,0 @@
-import pino from "pino";
-export declare const logger: pino.Logger<never, boolean>;

package/dist/source/logger.js

@@ -1,24 +0,0 @@
-import { join } from "node:path";
-import pino from "pino";
-import { config } from "./config.js";
-const transport = pino.transport({
-    target: "pino-roll",
-    options: {
-        file: join(config.app.ensurePathSync("logs"), "acai.log"),
-        size: "10m",
-        symlink: true,
-        limit: {
-            count: 3,
-        },
-        mkdir: true,
-    },
-});
-export const logger = pino({
-    level: process.env["LOG_LEVEL"] ?? "debug",
-    formatters: {
-        level: (label) => {
-            return { level: label.toUpperCase() };
-        },
-    },
-    timestamp: pino.stdTimeFunctions.isoTime,
-}, transport);

package/dist/source/mentions.d.ts

@@ -1,9 +0,0 @@
-import type { ModelMetadata } from "./models/providers.ts";
-import type { ContextItem } from "./prompts/manager.ts";
-export declare function processPrompt(message: string, { baseDir, model }: {
-    baseDir: string;
-    model: ModelMetadata;
-}): Promise<{
-    message: string;
-    context: ContextItem[];
-}>;

package/dist/source/mentions.js

@@ -1,182 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { isString } from "@travisennis/stdlib/typeguards";
-import { formatFile, formatUrl } from "./formatting.js";
-import { readUrl } from "./tools/web-fetch.js";
-import { executeCommand } from "./utils/process.js";
-// Helper function to recursively read all files in a directory
-async function readDirectoryRecursive(dirPath, format) {
-    const allContents = [];
-    async function readDir(currentPath, relativePath = "") {
-        const entries = await fs.readdir(currentPath, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(currentPath, entry.name);
-            const relativeFilePath = path.join(relativePath, entry.name);
-            if (entry.isDirectory()) {
-                await readDir(fullPath, relativeFilePath);
-            }
-            else if (entry.isFile()) {
-                try {
-                    const fileContents = await fs.readFile(fullPath, "utf8");
-                    allContents.push(formatFile(relativeFilePath, fileContents, format));
-                }
-                catch (error) {
-                    allContents.push(`Error reading file ${relativeFilePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
-                }
-            }
-        }
-    }
-    await readDir(dirPath);
-    if (allContents.length === 0) {
-        return `Directory ${path.basename(dirPath)} is empty or contains no readable files.`;
-    }
-    return allContents.join("\n\n");
-}
-// Returns the formatted string or an error message string
-async function processFileCommand(context) {
-    const { baseDir, match } = context;
-    const filePath = match.trim();
-    const format = context.model.promptFormat;
-    try {
-        // Resolve paths to absolute to prevent traversal issues
-        const resolvedBaseDir = path.resolve(baseDir);
-        const resolvedFilePath = path.resolve(resolvedBaseDir, filePath);
-        // Security Check: Ensure the resolved path is still within the base directory
-        if (!resolvedFilePath.startsWith(resolvedBaseDir + path.sep)) {
-            return `Error: Access denied. Attempted to read file outside the allowed directory: ${filePath}`;
-        }
-        // Check if path exists
-        const stats = await fs.stat(resolvedFilePath);
-        // If it's a directory, read all files recursively
-        if (stats.isDirectory()) {
-            return await readDirectoryRecursive(resolvedFilePath, format);
-        }
-        // If it's a file, process as before
-        if (stats.isFile()) {
-            const fileContents = await fs.readFile(resolvedFilePath, "utf8");
-            return formatFile(filePath, fileContents, format);
-        }
-        return `Error: ${filePath} is neither a regular file nor directory.`;
-    }
-    catch (error) {
-        // Handle both ENOENT (file not found) and permission errors
-        if (error && typeof error === "object" && "code" in error) {
-            if (error.code === "ENOENT") {
-                return `Error: File or directory not found: ${filePath}\nPlease check that the path is correct and exists.`;
-            }
-            if (error.code === "EACCES") {
-                return `Error: Permission denied accessing: ${filePath}`;
-            }
-        }
-        if (error instanceof Error) {
-            return `Error accessing ${filePath}: ${error.message}`;
-        }
-        // Fallback for unknown error types
-        return `Error accessing ${filePath}: An unknown error occurred.`;
-    }
-}
-async function processShellCommand(command) {
-    try {
-        const { stdout, stderr, code } = await executeCommand(command, {
-            shell: true,
-        });
-        if (code === 0) {
-            return stdout;
-        }
-        return `Error executing command: ${command}\n${stderr}`;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            return `Error executing command ${command}: ${error.message}`;
-        }
-        return `Error executing command ${command}: An unknown error occurred.`;
-    }
-}
-// Returns the formatted string or an error message string
-async function processUrlCommand(context) {
-    const { match } = context;
-    const urlPath = match;
-    try {
-        return Object.assign(await readUrl(urlPath), { source: urlPath });
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            return {
-                contentType: "text/plain",
-                data: `Url: ${urlPath} Status: Error fetching URL: ${error.message}`,
-                source: urlPath,
-            };
-        }
-        // Fallback for unknown error types
-        return {
-            contentType: "text/plain",
-            data: `Url: ${urlPath} Status: Error fetching URL: An unknown error occurred.`,
-            source: urlPath,
-        };
-    }
-}
-export async function processPrompt(message, { baseDir, model }) {
-    const fileRegex = /@([^\s@]+(?:\.[\w\d]+))/g;
-    const urlRegex = /@(https?:\/\/[^\s]+)/g;
-    const shellRegex = /!`([^`]+)`/g;
-    // Collect all matches for files and urls
-    const fileMatches = Array.from(message.matchAll(fileRegex));
-    const urlMatches = Array.from(message.matchAll(urlRegex));
-    const shellMatches = Array.from(message.matchAll(shellRegex));
-    const mentionProcessingPromises = [];
-    // Process file references - collect promises
-    for (const match of fileMatches) {
-        const firstMatch = match[1];
-        if (firstMatch) {
-            const context = {
-                model,
-                baseDir,
-                match: firstMatch,
-            };
-            mentionProcessingPromises.push(processFileCommand(context));
-        }
-    }
-    // Process url references - collect promises
-    for (const match of urlMatches) {
-        const firstMatch = match[1];
-        if (firstMatch) {
-            const context = {
-                model,
-                baseDir, // baseDir is not used by processUrlCommand but kept for consistency
-                match: firstMatch,
-            };
-            mentionProcessingPromises.push(processUrlCommand(context));
-        }
-    }
-    let processedMessage = message;
-    // Process shell commands
-    for (const match of shellMatches) {
-        const command = match[1];
-        if (command) {
-            const output = await processShellCommand(command);
-            processedMessage = processedMessage.replace(match[0], output);
-        }
-    }
-    // Wait for all mentions to be processed
-    const mentionResults = await Promise.all(mentionProcessingPromises);
-    const context = [];
-    for (const mention of mentionResults) {
-        if (isString(mention)) {
-            context.push(mention);
-        }
-        else if (mention.data.startsWith("data")) {
-            context.push({
-                type: "image",
-                mediaType: mention.contentType,
-                image: mention.data,
-            });
-        }
-        else {
-            context.push(formatUrl(mention.source, mention.data.trim(), model.promptFormat));
-        }
-    }
-    return {
-        message: processedMessage,
-        context,
-    };
-}

package/dist/source/messages.d.ts

@@ -1,69 +0,0 @@
-import EventEmitter from "node:events";
-import { type AssistantModelMessage, type ImagePart, // Added ImagePart
-type ModelMessage, type ToolModelMessage, type UserModelMessage } from "ai";
-import type { ModelManager } from "./models/manager.ts";
-import type { TokenTracker } from "./token-tracker.ts";
-export type UserMessageContentItem = string | ImagePart;
-export declare function createUserMessage(contentItems: UserMessageContentItem[], prompt?: string): UserModelMessage;
-export declare function createAssistantMessage(content: string): AssistantModelMessage;
-/**
-A message that was generated during the generation process.
-It can be either an assistant message or a tool message.
- */
-type ResponseMessage = AssistantModelMessage | ToolModelMessage;
-export type SavedMessageHistory = {
-    title: string;
-    createdAt: Date;
-    updatedAt: Date;
-    messages: ModelMessage[];
-};
-interface MessageHistoryEvents {
-    "update-title": [string];
-    "clear-history": [];
-}
-export declare class MessageHistory extends EventEmitter<MessageHistoryEvents> {
-    private history;
-    private title;
-    private createdAt;
-    private updatedAt;
-    private stateDir;
-    private modelManager;
-    private tokenTracker;
-    constructor({ stateDir, modelManager, tokenTracker, }: {
-        stateDir: string;
-        modelManager: ModelManager;
-        tokenTracker: TokenTracker;
-    });
-    private validMessage;
-    get(): ModelMessage[];
-    clear(): void;
-    appendUserMessage(msg: string): void;
-    appendUserMessage(msg: UserModelMessage): void;
-    appendAssistantMessage(msg: string): void;
-    appendAssistantMessage(msg: AssistantModelMessage): void;
-    appendResponseMessages(responseMessages: ResponseMessage[]): void;
-    isEmpty(): boolean;
-    save(): Promise<void>;
-    private generateTitle;
-    getFirstUserMessage(): UserModelMessage | undefined;
-    static load(stateDir: string, count?: number): Promise<SavedMessageHistory[]>;
-    restore(savedHistory: SavedMessageHistory): void;
-}
-/**
- * Normalizes an array of messages for API consumption by:
- * 1. Filtering out progress-type messages
- * 2. Processing user and assistant messages
- * 3. Handling tool results by either:
- *    - Adding them as new messages if they're the first tool result
- *    - Adding them as new messages if the previous message wasn't a tool result
- *    - Merging them with the previous message if it was also a tool result
- *
- * This consolidation of sequential tool results into a single message
- * ensures proper formatting for API consumption while maintaining the
- * logical flow of the conversation.
- *
- * @param messages - Array of messages to normalize
- * @returns Normalized array of user and assistant messages ready for API
- */
-export declare function normalizeMessagesForApi(messages: ModelMessage[]): ModelMessage[];
-export {};