@nomyx/assistant/dist/cli.js

A powerful assistant library and cli for your AI projects. works with Vertex AI (Claude and Gemini)

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.main = main;
const readline_1 = __importDefault(require("readline"));
const AIAssistant_1 = require("./AIAssistant");
const dotenv_1 = __importDefault(require("dotenv"));
const path_1 = __importDefault(require("path"));
dotenv_1.default.config({ path: path_1.default.resolve(__dirname, '../.env') });
const tools = [];
const executionOptions = {
    maxRetries: 3,
    retryDelayMs: 1000,
    timeoutMs: 30000,
    statePersistenceDir: './state',
    maxHistoryLength: 5,
    initialWorkingDirectory: process.cwd(),
    providerName: process.env.AI_PROVIDER || 'openai',
    tools: tools
};
async function initializeAssistant() {
    const assistant = new AIAssistant_1.AIAssistant(console, executionOptions);
    await assistant.initialize();
    return assistant;
}
async function processQuery(query) {
    const assistant = await initializeAssistant();
    try {
        const stream = await assistant.processRequestStreamWithDetails(query);
        let buffer = '';
        for await (const chunk of stream) {
            buffer += chunk;
            let parsedData;
            try {
                parsedData = JSON.parse(buffer);
                buffer = ''; // Reset buffer after successful parse
            }
            catch (e) {
                // If parsing fails, continue to next chunk
                continue;
            }
            if (parsedData.choices && parsedData.choices[0] && parsedData.choices[0].delta) {
                const delta = parsedData.choices[0].delta;
                if (delta.content) {
                    process.stdout.write(delta.content);
                }
                if (delta.tool_calls) {
                    for (const toolCall of delta.tool_calls) {
                        process.stdout.write(`[Tool Execution: ${toolCall.function.name}]\n`);
                        process.stdout.write(`Arguments: ${JSON.stringify(toolCall.function.arguments)}\n`);
                    }
                }
            }
        }
    }
    catch (error) {
        process.stderr.write(`Error: ${error}\n`);
    }
}
async function startInteractiveMode() {
    const rl = readline_1.default.createInterface({
        input: process.stdin,
        output: process.stdout,
    });
    rl.on('line', async (input) => {
        if (input.trim()) {
            await processQuery(input);
            rl.prompt();
        }
    });
    rl.on('close', () => {
        process.exit(0);
    });
    rl.prompt();
}
async function main() {
    const args = process.argv.slice(2);
    if (args.length > 0) {
        const query = args.join(' ');
        await processQuery(query);
    }
    else {
        await startInteractiveMode();
    }
}
if (require.main === module) {
    main().catch((error) => {
        process.stderr.write(`Unhandled error: ${error}\n`);
        process.exit(1);
    });
}