carto-cli 0.1.0-rc.1

package/dist/commands/ai.js

@@ -0,0 +1,489 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAiFeature = handleAiFeature;
+exports.handleAiProxy = handleAiProxy;
+const api_1 = require("../api");
+const colors_1 = require("../colors");
+const fs_1 = require("fs");
+const readline = __importStar(require("readline"));
+const AI_FEATURES = {
+    'aiagent': {
+        buildQueryParams: (args) => ({ mapId: args[0] }),
+        buildFirstMessageVars: () => ({
+            conversation_start_time: new Date().toISOString(),
+            user_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'
+        }),
+        requiredArg: 'map ID',
+        argName: '<map-id>'
+    }
+    // Future features can be added here:
+    // 'workflowsCreatorAgent': {
+    //   buildQueryParams: (args: string[]) => ({ workflowId: args[0] }),
+    //   requiredArg: 'workflow ID',
+    //   argName: '<workflow-id>'
+    // }
+};
+/**
+ * Handle AI Feature commands (aiagent, workflowsCreatorAgent, etc.)
+ */
+async function handleAiFeature(featureName, args, options, token, baseUrl, jsonOutput, debug = false, profile) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        const feature = AI_FEATURES[featureName];
+        if (!feature) {
+            throw new Error(`Unknown AI feature: ${featureName}`);
+        }
+        // Validate required argument
+        if (args.length === 0) {
+            throw new Error(`${featureName} requires ${feature.requiredArg}. Usage: carto ai ${featureName} ${feature.argName} [message]`);
+        }
+        // Fetch agent token if we're using aiagent feature
+        let agentClient = client;
+        if (featureName === 'aiagent') {
+            const mapId = args[0];
+            if (!jsonOutput) {
+                console.log((0, colors_1.dim)('Fetching agent configuration...'));
+            }
+            try {
+                const mapData = await client.getWorkspace(`/maps/${mapId}`);
+                if (!mapData.agent || !mapData.agent.config) {
+                    throw new Error(`Map does not have an AI agent configured. Enable an agent in the map settings first.`);
+                }
+                if (!mapData.agent.token) {
+                    throw new Error(`Map agent is missing authentication token. Please reconfigure the agent.`);
+                }
+                // Create new client with agent-specific token
+                agentClient = await api_1.ApiClient.create(mapData.agent.token, baseUrl, debug, profile);
+                if (!jsonOutput) {
+                    console.log((0, colors_1.dim)('Agent configured with model: ' + (mapData.agent.config?.model || 'unknown')));
+                }
+            }
+            catch (err) {
+                if (err.message.includes('does not have') || err.message.includes('is missing')) {
+                    throw err;
+                }
+                throw new Error(`Failed to fetch agent configuration: ${err.message}`);
+            }
+        }
+        const message = args[1];
+        // Interactive mode: no message provided
+        if (!message && !options.file && process.stdin.isTTY) {
+            await interactiveMode(agentClient, featureName, feature, args, options, jsonOutput);
+            return;
+        }
+        // One-shot mode: message provided
+        const userMessage = await getMessageFromInput(message, options);
+        if (!userMessage) {
+            throw new Error('No message provided. Use: carto ai ' + featureName + ' ' + feature.argName + ' "message" or --file <path>');
+        }
+        await oneShotMode(agentClient, featureName, feature, args, userMessage, options, jsonOutput);
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else {
+                console.log((0, colors_1.error)('✗ ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Interactive mode - multi-turn conversation with readline
+ */
+async function interactiveMode(client, featureName, feature, args, options, jsonOutput) {
+    const conversationState = {
+        lastMessageId: options.conversationId || null,
+        conversationId: null,
+        isFirstMessage: !options.conversationId
+    };
+    if (!jsonOutput) {
+        console.log((0, colors_1.bold)(`\n🤖 Interactive AI Chat (${featureName})`));
+        console.log((0, colors_1.dim)('Type your message and press Enter. Type "exit" or "quit" to end.\n'));
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: (0, colors_1.bold)('You: ')
+    });
+    rl.prompt();
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        if (input === 'exit' || input === 'quit') {
+            rl.close();
+            return;
+        }
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        try {
+            // Disable prompt while processing
+            rl.pause();
+            if (!jsonOutput) {
+                console.log((0, colors_1.bold)('\nAssistant: '));
+            }
+            await sendMessage(client, featureName, feature, args, input, conversationState, jsonOutput);
+            if (!jsonOutput) {
+                console.log(''); // Empty line before next prompt
+            }
+            // Re-enable prompt
+            rl.resume();
+            rl.prompt();
+        }
+        catch (err) {
+            console.log((0, colors_1.error)('\n✗ Error: ' + err.message));
+            rl.resume();
+            rl.prompt();
+        }
+    });
+    rl.on('close', () => {
+        if (!jsonOutput) {
+            console.log((0, colors_1.dim)('\n\nGoodbye!'));
+        }
+        process.exit(0);
+    });
+}
+/**
+ * One-shot mode - single message
+ */
+async function oneShotMode(client, featureName, feature, args, message, options, jsonOutput) {
+    const conversationState = {
+        lastMessageId: options.conversationId || null,
+        conversationId: null,
+        isFirstMessage: !options.conversationId
+    };
+    if (!jsonOutput) {
+        console.log((0, colors_1.bold)('Assistant: '));
+    }
+    await sendMessage(client, featureName, feature, args, message, conversationState, jsonOutput);
+    if (jsonOutput && conversationState.lastMessageId) {
+        // Output conversation ID for continuation
+        console.log(JSON.stringify({
+            success: true,
+            conversationId: conversationState.conversationId,
+            messageId: conversationState.lastMessageId
+        }));
+    }
+}
+/**
+ * Send a message to AI Feature and handle streaming response
+ */
+async function sendMessage(client, featureName, feature, args, message, conversationState, jsonOutput) {
+    const queryParams = feature.buildQueryParams(args);
+    const body = {
+        input: message
+    };
+    // Add parent for conversation continuation
+    if (conversationState.lastMessageId) {
+        body.parent = conversationState.lastMessageId;
+    }
+    // Add vars for first message
+    if (conversationState.isFirstMessage && feature.buildFirstMessageVars) {
+        body.vars = feature.buildFirstMessageVars();
+    }
+    let responseText = '';
+    await client.streamAiFeature(featureName, queryParams, body, async (chunk) => {
+        if (chunk.type === 'delta') {
+            // Streaming text chunk
+            if (jsonOutput) {
+                console.log(JSON.stringify({ type: 'delta', text: chunk.delta }));
+            }
+            else {
+                process.stdout.write(chunk.delta);
+            }
+            responseText += chunk.delta;
+        }
+        else if (chunk.type === 'response') {
+            // Complete response with IDs
+            conversationState.lastMessageId = chunk.id;
+            conversationState.conversationId = chunk.conversationId;
+            conversationState.isFirstMessage = false;
+            if (chunk.message && chunk.message !== responseText) {
+                // Full message provided (fallback if no deltas)
+                if (jsonOutput) {
+                    console.log(JSON.stringify({ type: 'response', message: chunk.message, id: chunk.id }));
+                }
+                else {
+                    process.stdout.write(chunk.message);
+                }
+            }
+            if (chunk.actions && chunk.actions.length > 0) {
+                // Frontend actions requested
+                if (jsonOutput) {
+                    console.log(JSON.stringify({ type: 'actions', actions: chunk.actions }));
+                }
+                else {
+                    console.log((0, colors_1.dim)(`\n[Agent requested ${chunk.actions.length} action(s)]`));
+                }
+            }
+        }
+        else if (chunk.type === 'action_execution') {
+            // Backend action started
+            if (jsonOutput) {
+                console.log(JSON.stringify({ type: 'action_execution', action: chunk.action, action_id: chunk.action_id }));
+            }
+            else {
+                console.log((0, colors_1.dim)(`\n[Executing: ${chunk.action}...]`));
+            }
+        }
+        else if (chunk.type === 'action_execution_finished') {
+            // Backend action completed
+            if (jsonOutput) {
+                console.log(JSON.stringify({ type: 'action_finished', action: chunk.action, action_id: chunk.action_id }));
+            }
+        }
+        else if (chunk.type === 'error') {
+            // Error from API
+            if (jsonOutput) {
+                console.log(JSON.stringify({ type: 'error', message: chunk.message }));
+            }
+            else {
+                console.log((0, colors_1.error)('\n✗ Error: ' + (chunk.message || 'Unknown error')));
+            }
+        }
+        else if (chunk.type === 'end') {
+            // Stream ended
+            if (jsonOutput) {
+                console.log(JSON.stringify({ type: 'end', conversationId: chunk.conversationId }));
+            }
+        }
+        else if (chunk.type === 'debug') {
+            // Debug information
+            if (jsonOutput) {
+                console.log(JSON.stringify({ type: 'debug', message: chunk.message, details: chunk.details }));
+            }
+        }
+    });
+}
+/**
+ * Handle AI Proxy commands (chat, models, etc.)
+ */
+async function handleAiProxy(args, options, token, baseUrl, jsonOutput, debug = false, profile) {
+    try {
+        const client = await api_1.ApiClient.create(token, baseUrl, debug, profile);
+        if (args.length === 0) {
+            throw new Error('AI proxy requires a subcommand (chat, models, info)');
+        }
+        const proxyCommand = args[0];
+        switch (proxyCommand) {
+            case 'chat':
+                await handleProxyChat(args.slice(1), options, client, jsonOutput);
+                break;
+            case 'models':
+                await handleProxyModels(options, client, jsonOutput);
+                break;
+            case 'info':
+                await handleProxyInfo(options, client, jsonOutput);
+                break;
+            default:
+                throw new Error(`Unknown proxy command: ${proxyCommand}. Available: chat, models, info`);
+        }
+    }
+    catch (err) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            if (err.message.includes('401') || err.message.includes('Token not defined')) {
+                console.log((0, colors_1.error)('✗ Authentication required'));
+                console.log('Please run: carto auth login');
+            }
+            else {
+                console.log((0, colors_1.error)('✗ ' + err.message));
+            }
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Handle proxy chat command (OpenAI-compatible chat completions)
+ */
+async function handleProxyChat(args, options, client, jsonOutput) {
+    // Get message from args, stdin, or file
+    const message = await getMessageFromInput(args[0], options);
+    if (!message) {
+        throw new Error('No message provided. Use: carto ai proxy chat "message" or --file <path> or pipe via stdin');
+    }
+    // Validate model is provided
+    if (!options.model) {
+        throw new Error('Model is required. Use --model <name>. See available models with: carto ai proxy models');
+    }
+    // Build OpenAI chat completion request
+    const requestBody = {
+        model: options.model,
+        messages: []
+    };
+    // Add system message if provided
+    if (options.system) {
+        requestBody.messages.push({
+            role: 'system',
+            content: options.system
+        });
+    }
+    // Add user message
+    requestBody.messages.push({
+        role: 'user',
+        content: message
+    });
+    // Add optional parameters
+    if (options.temperature !== undefined) {
+        requestBody.temperature = parseFloat(options.temperature);
+    }
+    if (options.maxTokens !== undefined) {
+        requestBody.max_tokens = parseInt(options.maxTokens);
+    }
+    if (options.topP !== undefined) {
+        requestBody.top_p = parseFloat(options.topP);
+    }
+    if (!jsonOutput) {
+        console.log((0, colors_1.dim)(`Model: ${options.model}`));
+        console.log((0, colors_1.bold)('\nAssistant:\n'));
+    }
+    // Call LiteLLM proxy
+    const response = await client.postLiteLLMProxy('/v1/chat/completions', requestBody);
+    if (jsonOutput) {
+        console.log(JSON.stringify(response));
+    }
+    else {
+        // Pretty-print response
+        if (response.choices && response.choices.length > 0) {
+            const content = response.choices[0].message?.content || '';
+            console.log(content);
+            console.log();
+            console.log((0, colors_1.dim)(`Tokens: ${response.usage?.total_tokens || 'N/A'} (prompt: ${response.usage?.prompt_tokens || 'N/A'}, completion: ${response.usage?.completion_tokens || 'N/A'})`));
+        }
+        else {
+            console.log((0, colors_1.error)('No response from model'));
+        }
+    }
+}
+/**
+ * Handle proxy models command (list available models)
+ */
+async function handleProxyModels(options, client, jsonOutput) {
+    const response = await client.getLiteLLMProxy('/v1/models');
+    if (jsonOutput) {
+        console.log(JSON.stringify(response));
+    }
+    else {
+        // Pretty-print models list
+        if (response.data && Array.isArray(response.data)) {
+            console.log((0, colors_1.bold)('\nAvailable Models:\n'));
+            response.data.forEach((model) => {
+                console.log((0, colors_1.bold)('  • ' + model.id));
+                if (model.owned_by) {
+                    console.log((0, colors_1.dim)(`    Owner: ${model.owned_by}`));
+                }
+                if (model.created) {
+                    const date = new Date(model.created * 1000).toLocaleString();
+                    console.log((0, colors_1.dim)(`    Created: ${date}`));
+                }
+                console.log();
+            });
+            console.log((0, colors_1.dim)(`Total: ${response.data.length} model(s)`));
+        }
+        else {
+            console.log((0, colors_1.error)('No models found'));
+        }
+    }
+}
+/**
+ * Handle proxy info command (show connection information)
+ */
+async function handleProxyInfo(options, client, jsonOutput) {
+    if (jsonOutput) {
+        console.log(JSON.stringify({
+            name: 'CARTO LiteLLM',
+            apiMode: 'openai-compatible',
+            apiHost: client.litellmUrl,
+            apiBase: `${client.litellmUrl}/v1`,
+            apiKey: client['token'] || '(not set)',
+            endpoints: {
+                chat: '/v1/chat/completions',
+                completions: '/v1/completions',
+                embeddings: '/v1/embeddings',
+                models: '/v1/models'
+            }
+        }));
+    }
+    else {
+        console.log((0, colors_1.bold)('\nCARTO LiteLLM Proxy Configuration\n'));
+        console.log((0, colors_1.bold)('API Mode:     ') + 'OpenAI Compatible');
+        console.log((0, colors_1.bold)('API Host:     ') + client.litellmUrl);
+        console.log((0, colors_1.bold)('API Base URL: ') + `${client.litellmUrl}/v1`);
+        console.log((0, colors_1.bold)('API Key:      ') + (client['token'] || '(not set)'));
+        console.log();
+        console.log((0, colors_1.bold)('Endpoints:'));
+        console.log('  Chat completions: ' + (0, colors_1.dim)('/v1/chat/completions'));
+        console.log('  Completions:      ' + (0, colors_1.dim)('/v1/completions'));
+        console.log('  Embeddings:       ' + (0, colors_1.dim)('/v1/embeddings'));
+        console.log('  Models:           ' + (0, colors_1.dim)('/v1/models'));
+        console.log();
+        console.log((0, colors_1.dim)('Use this information to configure OpenAI-compatible tools and MCP servers.'));
+        console.log((0, colors_1.dim)('To list available models, run: carto aiproxy models'));
+    }
+}
+/**
+ * Get message from various input sources (arg, file, stdin)
+ */
+async function getMessageFromInput(message, options) {
+    let msg = message;
+    // Priority 1: --file flag
+    if (options.file) {
+        try {
+            msg = (0, fs_1.readFileSync)(options.file, 'utf-8').trim();
+        }
+        catch (err) {
+            throw new Error(`Failed to read file: ${err.message}`);
+        }
+    }
+    // Priority 2: stdin
+    if (!msg && !process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        msg = Buffer.concat(chunks).toString('utf-8').trim();
+    }
+    return msg;
+}