enton-cli 0.1.0

package/README.md

@@ -0,0 +1,188 @@
+# ENTON CLI
+
+🏦 **AI-powered financial assistant** - like Claude Code, but for finance.
+
+## Installation
+
+```bash
+npm install -g @enton/cli
+```
+
+Or run directly with npx:
+
+```bash
+npx @enton/cli "What is the price of AAPL?"
+```
+
+## Usage
+
+### Interactive Mode
+
+Just run `enton` to start an interactive session:
+
+```bash
+enton
+```
+
+```
+╔═══════════════════════════════════════════════════════════╗
+║  🏦 ENTON - AI Finance Agent                              ║
+╚═══════════════════════════════════════════════════════════╝
+
+Type your questions or commands. Type "exit" to quit.
+
+> What is the price of AAPL?
+🔧 get_stock_quote
+
+The current price for Apple (AAPL) is **$262.50**, down 1.78% from the previous close.
+
+📊 Tools: get_stock_quote | 1523ms
+
+> 
+```
+
+### Direct Query Mode
+
+Run a single query:
+
+```bash
+enton "Get me news about Tesla"
+```
+
+### Watch Mode
+
+Monitor real-time prices:
+
+```bash
+enton watch AAPL,TSLA,NVDA
+```
+
+```
+📈 ENTON Watch Mode
+Last update: 3:45:21 PM
+
+┌────────┬──────────┬────────────┬──────────┐
+│ Symbol │ Price    │ Change     │ % Change │
+├────────┼──────────┼────────────┼──────────┤
+│ AAPL   │ $262.50  │ ▼ $4.76    │ -1.78%   │
+│ TSLA   │ $245.80  │ ▲ $12.30   │ +5.27%   │
+│ NVDA   │ $138.20  │ ▲ $2.15    │ +1.58%   │
+└────────┴──────────┴────────────┴──────────┘
+
+Press Ctrl+C to exit
+```
+
+## Authentication
+
+Login with your ENTON account:
+
+```bash
+enton auth login
+```
+
+Or use an environment variable:
+
+```bash
+export ENTON_API_KEY=your_api_key
+enton
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `enton` | Start interactive mode |
+| `enton "query"` | Run a single query |
+| `enton auth login` | Authenticate with ENTON |
+| `enton auth logout` | Log out |
+| `enton auth status` | Check authentication status |
+| `enton watch SYMBOLS` | Watch real-time prices |
+| `enton config list` | List configuration |
+| `enton config set KEY VALUE` | Set a config value |
+
+## Interactive Commands
+
+While in interactive mode:
+
+- `/help` - Show available commands
+- `/clear` - Clear the screen
+- `/status` - Show connection status
+- `exit`, `quit`, `q` - Exit
+
+## Configuration
+
+Configure with `enton config`:
+
+```bash
+# Set API URL
+enton config set apiUrl https://api.enton.ai
+
+# Set output format
+enton config set outputFormat json
+
+# List all config
+enton config list
+```
+
+## JSON Output
+
+Use `--json` flag for machine-readable output:
+
+```bash
+enton "price of AAPL" --json
+```
+
+```json
+{
+  "answer": "The current price for Apple (AAPL) is $262.50...",
+  "toolsUsed": ["get_stock_quote"],
+  "iterations": 2,
+  "totalTime": 1523
+}
+```
+
+## Examples
+
+```bash
+# Stock prices
+enton "What is the price of AAPL?"
+enton "Compare NVDA vs AMD"
+
+# News
+enton "Get me news about Tesla"
+enton "Latest market news"
+
+# Analysis
+enton "Analyze MSFT stock"
+enton "Technical analysis for SPY"
+
+# Portfolio (requires auth)
+enton "Show my portfolio"
+enton "What are my positions?"
+
+# Trading (requires auth)
+enton "Buy 10 shares of AAPL"
+enton "Show my open orders"
+```
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/enton-ai/enton-cli
+cd enton-cli
+npm install
+
+# Run in development mode
+npm run dev
+
+# Build
+npm run build
+
+# Test
+npm test
+```
+
+## License
+
+MIT © ENTON AI

package/bin/enton.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+/**
+ * ENTON CLI Entry Point
+ * 
+ * This file bootstraps the CLI application.
+ * The actual logic is in dist/index.js (compiled TypeScript)
+ */
+
+const path = require('path');
+
+// Check if we're in development mode
+const isDev = process.env.NODE_ENV === 'development' || process.argv.includes('--dev');
+
+if (isDev) {
+  // In development, use tsx to run TypeScript directly
+  require('child_process').spawn(
+    'npx',
+    ['tsx', path.join(__dirname, '..', 'src', 'index.ts'), ...process.argv.slice(2)],
+    { stdio: 'inherit' }
+  );
+} else {
+  // In production, run compiled JavaScript
+  try {
+    require('../dist/index.js');
+  } catch (error) {
+    if (error.code === 'MODULE_NOT_FOUND') {
+      console.error('ENTON CLI is not built yet. Run `npm run build` first.');
+      console.error('Or use `npm run dev` for development mode.');
+      process.exit(1);
+    }
+    throw error;
+  }
+}

package/dist/api/client.d.ts

@@ -0,0 +1,61 @@
+/**
+ * ENTON API Client
+ * Handles communication with the ENTON backend
+ */
+export interface QueryOptions {
+    stream?: boolean;
+    onThinking?: (message: string) => void;
+    onToolStart?: (tool: string, args: any) => void;
+    onToolResult?: (tool: string, success: boolean, data?: any) => void;
+    onAnswer?: (answer: string) => void;
+}
+export interface QueryResponse {
+    answer: string;
+    toolsUsed: string[];
+    iterations: number;
+    totalTime: number;
+    metadata?: any;
+}
+export declare class EntonAPIClient {
+    baseUrl: string;
+    private apiKey;
+    private client;
+    constructor(baseUrl?: string, apiKey?: string | null);
+    /**
+     * Check if client is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Update API key
+     */
+    setApiKey(apiKey: string): void;
+    /**
+     * Send a query to ENTON with streaming support
+     */
+    query(query: string, options?: QueryOptions): Promise<QueryResponse>;
+    /**
+     * Stream query with SSE
+     */
+    private streamQuery;
+    /**
+     * Get user's portfolio (requires auth)
+     */
+    getPortfolio(): Promise<any>;
+    /**
+     * Get stock quote
+     */
+    getQuote(symbol: string): Promise<any>;
+    /**
+     * Get news for a symbol
+     */
+    getNews(query: string): Promise<any>;
+    /**
+     * Place an order (requires auth)
+     */
+    placeOrder(params: {
+        symbol: string;
+        side: 'buy' | 'sell';
+        quantity: number;
+    }): Promise<any>;
+}
+export default EntonAPIClient;

package/dist/api/client.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * ENTON API Client
+ * Handles communication with the ENTON backend
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntonAPIClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const eventsource_1 = __importDefault(require("eventsource"));
+class EntonAPIClient {
+    constructor(baseUrl = 'https://api.enton.ai', apiKey = null) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.client = axios_1.default.create({
+            baseURL: baseUrl,
+            timeout: 300000, // 5 minutes for complex queries
+            headers: {
+                'Content-Type': 'application/json',
+                ...(apiKey ? { 'Authorization': `Bearer ${apiKey}` } : {})
+            }
+        });
+    }
+    /**
+     * Check if client is authenticated
+     */
+    isAuthenticated() {
+        return !!this.apiKey;
+    }
+    /**
+     * Update API key
+     */
+    setApiKey(apiKey) {
+        this.apiKey = apiKey;
+        this.client.defaults.headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    /**
+     * Send a query to ENTON with streaming support
+     */
+    async query(query, options = {}) {
+        if (options.stream !== false) {
+            return this.streamQuery(query, options);
+        }
+        // Non-streaming query
+        const response = await this.client.post('/api/ai-agent-system', {
+            task: query
+        });
+        return {
+            answer: response.data.answer || response.data.summary,
+            toolsUsed: response.data.result?.metadata?.toolsUsed || [],
+            iterations: response.data.result?.metadata?.iterations || 1,
+            totalTime: response.data.result?.metadata?.totalTime || 0,
+            metadata: response.data.result?.metadata
+        };
+    }
+    /**
+     * Stream query with SSE
+     */
+    streamQuery(query, options) {
+        return new Promise((resolve, reject) => {
+            const encodedQuery = encodeURIComponent(query);
+            const url = `${this.baseUrl}/api/ai-agent-system?task=${encodedQuery}`;
+            const headers = {};
+            if (this.apiKey) {
+                headers['Authorization'] = `Bearer ${this.apiKey}`;
+            }
+            const eventSource = new eventsource_1.default(url, { headers });
+            const toolsUsed = [];
+            let answer = '';
+            let iterations = 0;
+            let startTime = Date.now();
+            eventSource.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    switch (data.type) {
+                        case 'heartbeat':
+                            // Keep-alive, ignore
+                            break;
+                        case 'thought':
+                        case 'thinking':
+                            options.onThinking?.(data.message || 'Thinking...');
+                            break;
+                        case 'tool_selection':
+                        case 'tool_execution_start':
+                            options.onToolStart?.(data.toolName || data.tool, data.toolInput || data.args);
+                            if (data.toolName && !toolsUsed.includes(data.toolName)) {
+                                toolsUsed.push(data.toolName);
+                            }
+                            break;
+                        case 'tool_execution_result':
+                            options.onToolResult?.(data.toolName || data.tool, data.data?.success !== false, data.data);
+                            break;
+                        case 'final_answer_preparation':
+                        case 'answer':
+                            answer = data.data?.answer || data.answer || data.message;
+                            options.onAnswer?.(answer);
+                            break;
+                        case 'final_result':
+                            answer = data.answer || data.content || data.summary || answer;
+                            iterations = data.result?.metadata?.iterations || iterations;
+                            eventSource.close();
+                            resolve({
+                                answer,
+                                toolsUsed,
+                                iterations,
+                                totalTime: Date.now() - startTime,
+                                metadata: data.result?.metadata
+                            });
+                            break;
+                        case 'error_event':
+                            eventSource.close();
+                            reject(new Error(data.message || 'Unknown error'));
+                            break;
+                    }
+                }
+                catch (e) {
+                    // Ignore parse errors for non-JSON messages
+                }
+            };
+            eventSource.onerror = (error) => {
+                eventSource.close();
+                reject(new Error('Connection error'));
+            };
+            // Timeout after 5 minutes
+            setTimeout(() => {
+                eventSource.close();
+                reject(new Error('Request timeout'));
+            }, 300000);
+        });
+    }
+    /**
+     * Get user's portfolio (requires auth)
+     */
+    async getPortfolio() {
+        const response = await this.query('show my portfolio');
+        return response;
+    }
+    /**
+     * Get stock quote
+     */
+    async getQuote(symbol) {
+        return this.query(`What is the price of ${symbol}?`);
+    }
+    /**
+     * Get news for a symbol
+     */
+    async getNews(query) {
+        return this.query(`Get me news about ${query}`);
+    }
+    /**
+     * Place an order (requires auth)
+     */
+    async placeOrder(params) {
+        return this.query(`${params.side} ${params.quantity} shares of ${params.symbol}`);
+    }
+}
+exports.EntonAPIClient = EntonAPIClient;
+exports.default = EntonAPIClient;

package/dist/commands/auth.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Authentication Command
+ */
+export declare function authCommand(action: 'login' | 'logout' | 'status'): Promise<void>;
+export default authCommand;

package/dist/commands/auth.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Authentication Command
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authCommand = authCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const open_1 = __importDefault(require("open"));
+const manager_1 = require("../config/manager");
+const client_1 = require("../api/client");
+async function authCommand(action) {
+    switch (action) {
+        case 'login':
+            await login();
+            break;
+        case 'logout':
+            await logout();
+            break;
+        case 'status':
+            await status();
+            break;
+    }
+}
+async function login() {
+    console.log(chalk_1.default.bold('\n🔐 ENTON Authentication\n'));
+    const { method } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'method',
+            message: 'How would you like to authenticate?',
+            choices: [
+                { name: 'Open browser (recommended)', value: 'browser' },
+                { name: 'Enter API key manually', value: 'manual' },
+                { name: 'Use environment variable', value: 'env' }
+            ]
+        }
+    ]);
+    switch (method) {
+        case 'browser':
+            await browserAuth();
+            break;
+        case 'manual':
+            await manualAuth();
+            break;
+        case 'env':
+            await envAuth();
+            break;
+    }
+}
+async function browserAuth() {
+    console.log(chalk_1.default.dim('\nOpening ENTON in your browser...\n'));
+    const config = (0, manager_1.getConfig)();
+    const authUrl = `${config.apiUrl}/settings/api-keys`;
+    await (0, open_1.default)(authUrl);
+    console.log(chalk_1.default.cyan(`If the browser doesn't open, visit:\n${authUrl}\n`));
+    const { apiKey } = await inquirer_1.default.prompt([
+        {
+            type: 'password',
+            name: 'apiKey',
+            message: 'Paste your API key here:',
+            mask: '*',
+            validate: (input) => input.length > 0 || 'API key is required'
+        }
+    ]);
+    await verifyAndSaveKey(apiKey);
+}
+async function manualAuth() {
+    const { apiKey } = await inquirer_1.default.prompt([
+        {
+            type: 'password',
+            name: 'apiKey',
+            message: 'Enter your API key:',
+            mask: '*',
+            validate: (input) => input.length > 0 || 'API key is required'
+        }
+    ]);
+    await verifyAndSaveKey(apiKey);
+}
+async function envAuth() {
+    const envKey = process.env.ENTON_API_KEY;
+    if (!envKey) {
+        console.log(chalk_1.default.red('\n❌ ENTON_API_KEY environment variable not set\n'));
+        console.log(chalk_1.default.dim('Set it with:'));
+        console.log(chalk_1.default.cyan('  export ENTON_API_KEY=your_api_key\n'));
+        return;
+    }
+    await verifyAndSaveKey(envKey);
+}
+async function verifyAndSaveKey(apiKey) {
+    const spinner = (0, ora_1.default)('Verifying API key...').start();
+    try {
+        const config = (0, manager_1.getConfig)();
+        const client = new client_1.EntonAPIClient(config.apiUrl, apiKey);
+        // Test the key with a simple query
+        const response = await client.query('hello', { stream: false });
+        if (response.answer) {
+            // Save the key securely
+            await (0, manager_1.saveApiKey)(apiKey);
+            spinner.succeed(chalk_1.default.green('Successfully authenticated!'));
+            console.log(chalk_1.default.dim('\nYour API key has been saved securely.\n'));
+        }
+        else {
+            spinner.fail(chalk_1.default.red('Invalid API key'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Authentication failed'));
+        console.log(chalk_1.default.dim(`  ${error.message}\n`));
+    }
+}
+async function logout() {
+    const { confirm } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Are you sure you want to logout?',
+            default: false
+        }
+    ]);
+    if (confirm) {
+        await (0, manager_1.deleteApiKey)();
+        console.log(chalk_1.default.green('\n✅ Successfully logged out\n'));
+    }
+}
+async function status() {
+    console.log(chalk_1.default.bold('\n🔐 Authentication Status\n'));
+    const apiKey = await (0, manager_1.getApiKey)();
+    const config = (0, manager_1.getConfig)();
+    console.log(`  API URL: ${chalk_1.default.cyan(config.apiUrl)}`);
+    if (apiKey) {
+        console.log(`  Status: ${chalk_1.default.green('✅ Authenticated')}`);
+        console.log(`  API Key: ${chalk_1.default.dim(apiKey.substring(0, 8) + '...')}`);
+        // Test connection
+        const spinner = (0, ora_1.default)('Testing connection...').start();
+        try {
+            const client = new client_1.EntonAPIClient(config.apiUrl, apiKey);
+            await client.query('hello', { stream: false });
+            spinner.succeed(chalk_1.default.green('Connection OK'));
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red('Connection failed'));
+            console.log(chalk_1.default.dim(`  ${error.message}`));
+        }
+    }
+    else {
+        console.log(`  Status: ${chalk_1.default.yellow('⚠️  Not authenticated')}`);
+        console.log(chalk_1.default.dim('\n  Run `enton auth login` to authenticate\n'));
+    }
+    console.log('');
+}
+exports.default = authCommand;

package/dist/commands/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Config Command - Manage CLI configuration
+ */
+export declare function configCommand(action: 'set' | 'get' | 'list', key?: string, value?: string): Promise<void>;
+export default configCommand;