ff1-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,627 @@
+#!/usr/bin/env node
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Suppress punycode deprecation warning from jsdom dependency
+process.removeAllListeners('warning');
+process.on('warning', (warning) => {
+    if (warning.name === 'DeprecationWarning' && warning.message.includes('punycode')) {
+        return; // Ignore punycode deprecation warnings from dependencies
+    }
+    console.warn(warning.name + ': ' + warning.message);
+});
+require("dotenv/config");
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const readline = __importStar(require("readline"));
+const config_1 = require("./src/config");
+const main_1 = require("./src/main");
+const program = new commander_1.Command();
+/**
+ * Display playlist creation summary with next steps.
+ *
+ * @param {Playlist} playlist - The created playlist object
+ * @param {string} outputPath - Path where the playlist was saved
+ */
+function displayPlaylistSummary(playlist, outputPath) {
+    console.log(chalk_1.default.green('\n✅ Playlist created!'));
+    console.log();
+    console.log(chalk_1.default.bold('Next steps:'));
+    console.log(chalk_1.default.gray(` • View it locally: open ./${outputPath}`));
+    console.log(chalk_1.default.gray(` • Send it to your FF1: send last`));
+    console.log(chalk_1.default.gray(` • Publish to feed: publish playlist`));
+    console.log();
+}
+program
+    .name('ff1')
+    .description('CLI to fetch NFT information and build DP1 playlists using AI (Grok, ChatGPT, Gemini)')
+    .version('1.0.0');
+program
+    .command('chat')
+    .description('Start an interactive chat to build playlists using natural language')
+    .argument('[content]', 'Optional: Direct chat content (non-interactive mode)')
+    .option('-o, --output <filename>', 'Output filename for the playlist', 'playlist.json')
+    .option('-m, --model <name>', 'AI model to use (grok, chatgpt, gemini) - defaults to config setting')
+    .option('-v, --verbose', 'Show detailed technical output of function calls', false)
+    .action(async (content, options) => {
+    try {
+        // Load and validate configuration
+        const config = (0, config_1.getConfig)();
+        const availableModels = (0, config_1.listAvailableModels)();
+        // Validate model selection
+        if (options.model && !availableModels.includes(options.model)) {
+            console.error(chalk_1.default.red(`❌ Invalid model: "${options.model}"`));
+            console.log(chalk_1.default.yellow(`\nAvailable models: ${availableModels.join(', ')}`));
+            process.exit(1);
+        }
+        const modelName = options.model || config.defaultModel;
+        const validation = (0, config_1.validateConfig)(modelName);
+        if (!validation.valid) {
+            console.error(chalk_1.default.red('❌ Configuration Error:'));
+            validation.errors.forEach((error) => {
+                console.error(chalk_1.default.red(`  • ${error}`));
+            });
+            console.log(chalk_1.default.yellow('\nRun: node index.js config init\n'));
+            process.exit(1);
+        }
+        // NON-INTERACTIVE MODE: If content is provided as argument
+        if (content) {
+            console.log(chalk_1.default.blue('\n💬 FF1 Playlist Chat (Non-Interactive Mode)\n'));
+            console.log(chalk_1.default.gray(`🤖 Using AI model: ${modelName}\n`));
+            console.log(chalk_1.default.yellow('Request:'), content);
+            console.log(); // Blank line
+            try {
+                const result = await (0, main_1.buildPlaylist)(content, {
+                    verbose: options.verbose,
+                    outputPath: options.output,
+                    modelName: modelName,
+                    interactive: false, // Non-interactive mode
+                });
+                // Print final summary
+                if (result && result.playlist) {
+                    console.log(chalk_1.default.green('\n✅ Playlist Created Successfully!'));
+                    console.log(chalk_1.default.gray(`   Title: ${result.playlist.title}`));
+                    console.log(chalk_1.default.gray(`   Items: ${result.playlist.items?.length || 0}`));
+                    console.log(chalk_1.default.gray(`   Output: ${options.output}\n`));
+                }
+                process.exit(0);
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+                if (options.verbose) {
+                    console.error(chalk_1.default.gray(error.stack));
+                }
+                process.exit(1);
+            }
+        }
+        // INTERACTIVE MODE: Start conversation loop
+        console.log(chalk_1.default.blue('\n💬 Welcome to FF1 Playlist Chat!\n'));
+        console.log(chalk_1.default.gray('Tell me what playlist you want to create.'));
+        console.log(chalk_1.default.gray('Press Ctrl+C to exit.\n'));
+        console.log(chalk_1.default.gray(`🤖 Using AI model: ${modelName}\n`));
+        console.log(chalk_1.default.gray('Examples:'));
+        console.log(chalk_1.default.gray('  - "Get tokens 1,2,3 from Ethereum contract 0xabc"'));
+        console.log(chalk_1.default.gray('  - "Get token 42 from Tezos contract KT1abc"'));
+        console.log(chalk_1.default.gray('  - "Get 3 from Social Codes and 2 from 0xdef"'));
+        console.log(chalk_1.default.gray('  - "Build a playlist of my Tezos works from address tz1... plus 3 from Social Codes"'));
+        console.log(chalk_1.default.gray('  (Tip) Add -v to see tool calls'));
+        console.log();
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            historySize: 100,
+        });
+        let closed = false;
+        rl.on('close', () => {
+            closed = true;
+        });
+        rl.on('SIGINT', () => {
+            rl.close();
+        });
+        const ask = async () => new Promise((resolve) => {
+            if (closed) {
+                resolve('');
+                return;
+            }
+            rl.question(chalk_1.default.yellow('You: '), (answer) => {
+                resolve(answer.trim());
+            });
+        });
+        // Continuous conversation loop
+        while (!closed) {
+            const userInput = await ask();
+            if (closed) {
+                break;
+            }
+            if (!userInput) {
+                continue; // Skip empty input
+            }
+            console.log(); // Blank line before AI response
+            try {
+                const result = await (0, main_1.buildPlaylist)(userInput, {
+                    verbose: options.verbose,
+                    outputPath: options.output,
+                    modelName: modelName,
+                });
+                // Print summary after each response
+                // Only show playlist summary for build operations, not send operations
+                // Skip summary if playlist was already sent to device
+                if (options.verbose) {
+                    console.log(chalk_1.default.gray(`\n[DEBUG] result.sentToDevice: ${result?.sentToDevice}`));
+                    console.log(chalk_1.default.gray(`[DEBUG] result.action: ${result?.action}`));
+                }
+                if (result &&
+                    result.playlist &&
+                    result.action !== 'send_playlist' &&
+                    !result.sentToDevice) {
+                    displayPlaylistSummary(result.playlist, options.output);
+                }
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('❌ Error:'), error.message);
+                if (options.verbose) {
+                    console.error(chalk_1.default.gray(error.stack));
+                }
+                console.log(); // Blank line after error
+            }
+        }
+        if (closed) {
+            throw new Error('readline was closed');
+        }
+    }
+    catch (error) {
+        if (error.message !== 'readline was closed') {
+            console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+            if (process.env.DEBUG) {
+                console.error(chalk_1.default.gray(error.stack));
+            }
+        }
+        console.log(chalk_1.default.blue('\n👋 Goodbye!\n'));
+        process.exit(0);
+    }
+});
+program
+    .command('verify')
+    .description('Verify a DP1 playlist file against DP-1 specification')
+    .argument('<file>', 'Path to the playlist file')
+    .action(async (file) => {
+    try {
+        console.log(chalk_1.default.blue('\n🔍 Verifying playlist...\n'));
+        // Import the verification utility
+        const verifier = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-verifier')));
+        const { verifyPlaylistFile, printVerificationResult } = verifier;
+        // Verify the playlist
+        const result = await verifyPlaylistFile(file);
+        // Print results
+        printVerificationResult(result, file);
+        if (!result.valid) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('validate')
+    .description('Validate a DP1 playlist file (alias for verify)')
+    .argument('<file>', 'Path to the playlist file')
+    .action(async (file) => {
+    try {
+        console.log(chalk_1.default.blue('\n🔍 Verifying playlist...\n'));
+        // Import the verification utility
+        const verifier = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-verifier')));
+        const { verifyPlaylistFile, printVerificationResult } = verifier;
+        // Verify the playlist
+        const result = await verifyPlaylistFile(file);
+        // Print results
+        printVerificationResult(result, file);
+        if (!result.valid) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('sign')
+    .description('Sign a DP1 playlist file with Ed25519 signature')
+    .argument('<file>', 'Path to the playlist file to sign')
+    .option('-k, --key <privateKey>', 'Ed25519 private key in base64 format (overrides config)')
+    .option('-o, --output <file>', 'Output file path (defaults to overwriting input file)')
+    .action(async (file, options) => {
+    try {
+        console.log(chalk_1.default.blue('\n🔏 Signing playlist...\n'));
+        // Import the signing utility
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { signPlaylistFile } = require('./src/utilities/playlist-signer');
+        // Sign the playlist
+        const result = await signPlaylistFile(file, options.key, options.output);
+        if (result.success) {
+            console.log(chalk_1.default.green('\n✅ Playlist signed successfully!'));
+            if (result.playlist?.signature) {
+                console.log(chalk_1.default.gray(`   Signature: ${result.playlist.signature.substring(0, 30)}...`));
+            }
+            console.log();
+        }
+        else {
+            console.error(chalk_1.default.red('\n❌ Failed to sign playlist:'), result.error);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('play')
+    .description('Play a media URL on an FF1 device')
+    .argument('<url>', 'Media URL to play')
+    .option('-d, --device <name>', 'Device name (uses first device if not specified)')
+    .option('--skip-verify', 'Skip playlist verification before sending')
+    .action(async (url, options) => {
+    try {
+        console.log(chalk_1.default.blue('\n▶️  Playing URL on FF1 device...\n'));
+        try {
+            new URL(url);
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('\n❌ Invalid URL:'), error.message);
+            process.exit(1);
+        }
+        const config = (0, config_1.getConfig)();
+        const duration = config.defaultDuration || 10;
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { buildUrlItem, buildDP1Playlist } = require('./src/utilities/playlist-builder');
+        const item = buildUrlItem(url, duration);
+        const playlist = await buildDP1Playlist({ items: [item], title: item.title });
+        if (!options.skipVerify) {
+            const verifier = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-verifier')));
+            const { verifyPlaylist } = verifier;
+            const verifyResult = verifyPlaylist(playlist);
+            if (!verifyResult.valid) {
+                console.error(chalk_1.default.red('\n❌ Playlist verification failed:'), verifyResult.error);
+                if (verifyResult.details && verifyResult.details.length > 0) {
+                    console.log(chalk_1.default.yellow('\n   Validation errors:'));
+                    verifyResult.details.forEach((detail) => {
+                        console.log(chalk_1.default.yellow(`     • ${detail.path}: ${detail.message}`));
+                    });
+                }
+                console.log(chalk_1.default.yellow('\n   Use --skip-verify to send anyway (not recommended)\n'));
+                process.exit(1);
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { sendPlaylistToDevice } = require('./src/utilities/ff1-device');
+        const result = await sendPlaylistToDevice({
+            playlist,
+            deviceName: options.device,
+        });
+        if (result.success) {
+            console.log(chalk_1.default.green('✅ URL sent successfully!'));
+            if (result.deviceName) {
+                console.log(chalk_1.default.gray(`   Device: ${result.deviceName}`));
+            }
+            if (result.device) {
+                console.log(chalk_1.default.gray(`   Host: ${result.device}`));
+            }
+            console.log();
+        }
+        else {
+            console.error(chalk_1.default.red('\n❌ Failed to send URL:'), result.error);
+            if (result.details) {
+                console.error(chalk_1.default.gray(`   Details: ${result.details}`));
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('send')
+    .description('Send a playlist file to an FF1 device')
+    .argument('<file>', 'Path to the playlist file')
+    .option('-d, --device <name>', 'Device name (uses first device if not specified)')
+    .option('--skip-verify', 'Skip playlist verification before sending')
+    .action(async (file, options) => {
+    try {
+        console.log(chalk_1.default.blue('\n📤 Sending playlist to FF1 device...\n'));
+        // Read the playlist file
+        const content = await fs_1.promises.readFile(file, 'utf-8');
+        const playlist = JSON.parse(content);
+        // Verify playlist before sending (unless skipped)
+        if (!options.skipVerify) {
+            console.log(chalk_1.default.cyan('🔍 Verifying playlist...'));
+            const verifier = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-verifier')));
+            const { verifyPlaylist } = verifier;
+            const verifyResult = verifyPlaylist(playlist);
+            if (!verifyResult.valid) {
+                console.error(chalk_1.default.red('\n❌ Playlist verification failed:'), verifyResult.error);
+                if (verifyResult.details && verifyResult.details.length > 0) {
+                    console.log(chalk_1.default.yellow('\n   Validation errors:'));
+                    verifyResult.details.forEach((detail) => {
+                        console.log(chalk_1.default.yellow(`     • ${detail.path}: ${detail.message}`));
+                    });
+                }
+                console.log(chalk_1.default.yellow('\n   Use --skip-verify to send anyway (not recommended)\n'));
+                process.exit(1);
+            }
+            console.log(chalk_1.default.green('✓ Playlist verified successfully\n'));
+        }
+        // Import the sending utility
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { sendPlaylistToDevice } = require('./src/utilities/ff1-device');
+        // Send the playlist
+        const result = await sendPlaylistToDevice({
+            playlist,
+            deviceName: options.device,
+        });
+        if (result.success) {
+            console.log(chalk_1.default.green('✅ Playlist sent successfully!'));
+            if (result.deviceName) {
+                console.log(chalk_1.default.gray(`   Device: ${result.deviceName}`));
+            }
+            if (result.device) {
+                console.log(chalk_1.default.gray(`   Host: ${result.device}`));
+            }
+            console.log();
+        }
+        else {
+            console.error(chalk_1.default.red('\n❌ Failed to send playlist:'), result.error);
+            if (result.details) {
+                console.error(chalk_1.default.gray(`   Details: ${result.details}`));
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('publish')
+    .description('Publish a playlist to a feed server')
+    .argument('<file>', 'Path to the playlist file')
+    .option('-s, --server <index>', 'Feed server index (use this if multiple servers configured)')
+    .action(async (file, options) => {
+    try {
+        console.log(chalk_1.default.blue('\n📡 Publishing playlist to feed server...\n'));
+        const { getFeedConfig } = await Promise.resolve().then(() => __importStar(require('./src/config')));
+        const { publishPlaylist } = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-publisher')));
+        const feedConfig = getFeedConfig();
+        if (!feedConfig.baseURLs || feedConfig.baseURLs.length === 0) {
+            console.error(chalk_1.default.red('\n❌ No feed servers configured'));
+            console.log(chalk_1.default.yellow('   Add feed server URLs to config.json: feed.baseURLs\n'));
+            process.exit(1);
+        }
+        // If multiple servers and no index specified, show options
+        let serverUrl = feedConfig.baseURLs[0];
+        let serverApiKey = feedConfig.apiKey; // Default to legacy apiKey
+        if (feedConfig.baseURLs.length > 1) {
+            if (!options.server) {
+                console.log(chalk_1.default.yellow('Multiple feed servers found. Select one:'));
+                console.log();
+                feedConfig.baseURLs.forEach((url, index) => {
+                    console.log(chalk_1.default.cyan(`  ${index}: ${url}`));
+                });
+                console.log();
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const selection = await new Promise((resolve) => {
+                    rl.question(chalk_1.default.yellow('Select server (0-based index): '), (answer) => {
+                        rl.close();
+                        resolve(answer.trim());
+                    });
+                });
+                console.log();
+                options.server = selection;
+            }
+            const serverIndex = parseInt(options.server || '0', 10);
+            if (isNaN(serverIndex) || serverIndex < 0 || serverIndex >= feedConfig.baseURLs.length) {
+                console.error(chalk_1.default.red('\n❌ Invalid server index'));
+                process.exit(1);
+            }
+            serverUrl = feedConfig.baseURLs[serverIndex];
+            // Use individual server API key if available (new feedServers format)
+            if (feedConfig.servers && feedConfig.servers[serverIndex]) {
+                serverApiKey = feedConfig.servers[serverIndex].apiKey;
+            }
+        }
+        else if (feedConfig.servers && feedConfig.servers[0]) {
+            // Single server with new feedServers format
+            serverApiKey = feedConfig.servers[0].apiKey;
+        }
+        const result = await publishPlaylist(file, serverUrl, serverApiKey);
+        if (result.success) {
+            console.log(chalk_1.default.green('✅ Playlist published successfully!'));
+            if (result.playlistId) {
+                console.log(chalk_1.default.gray(`   Playlist ID: ${result.playlistId}`));
+            }
+            console.log(chalk_1.default.gray(`   Server: ${result.feedServer}`));
+            if (result.message) {
+                console.log(chalk_1.default.gray(`   Status: ${result.message}`));
+            }
+            console.log();
+        }
+        else {
+            console.error(chalk_1.default.red('\n❌ Failed to publish playlist'));
+            if (result.error) {
+                console.error(chalk_1.default.red(`   ${result.error}`));
+            }
+            if (result.message) {
+                console.log(chalk_1.default.yellow(`\n${result.message}`));
+            }
+            console.log();
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('build')
+    .description('Build playlist from structured parameters (JSON file or stdin)')
+    .argument('[params-file]', 'Path to JSON parameters file (or use stdin)')
+    .option('-o, --output <filename>', 'Output filename for the playlist', 'playlist.json')
+    .option('-v, --verbose', 'Show detailed output', false)
+    .action(async (paramsFile, options) => {
+    try {
+        let params;
+        if (paramsFile) {
+            // Read from file
+            const content = await fs_1.promises.readFile(paramsFile, 'utf-8');
+            params = JSON.parse(content);
+        }
+        else {
+            // Read from stdin
+            const stdin = await new Promise((resolve, reject) => {
+                let data = '';
+                process.stdin.setEncoding('utf8');
+                process.stdin.on('data', (chunk) => {
+                    data += chunk;
+                });
+                process.stdin.on('end', () => {
+                    resolve(data);
+                });
+                process.stdin.on('error', reject);
+            });
+            if (!stdin.trim()) {
+                console.error(chalk_1.default.red('❌ No parameters provided'));
+                console.log(chalk_1.default.yellow('\nUsage:'));
+                console.log('  node index.js build params.json');
+                console.log('  cat params.json | node index.js build');
+                console.log('  echo \'{"requirements":[...]}\' | node index.js build');
+                process.exit(1);
+            }
+            params = JSON.parse(stdin);
+        }
+        if (options.verbose) {
+            console.log(chalk_1.default.blue('\n📋 Parameters:'));
+            console.log(chalk_1.default.gray(JSON.stringify(params, null, 2)));
+            console.log();
+        }
+        console.log(chalk_1.default.blue('\n🚀 Building playlist from parameters...\n'));
+        const result = await (0, main_1.buildPlaylistDirect)(params, {
+            verbose: options.verbose,
+            outputPath: options.output,
+        });
+        if (result && result.playlist) {
+            console.log(chalk_1.default.green('\n✅ Playlist Created Successfully!'));
+            console.log(chalk_1.default.gray(`   Title: ${result.playlist.title}`));
+            console.log(chalk_1.default.gray(`   Items: ${result.playlist.items?.length || 0}`));
+            console.log(chalk_1.default.gray(`   Output: ${options.output}\n`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        if (options.verbose) {
+            console.error(chalk_1.default.gray(error.stack));
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('config')
+    .description('Manage configuration')
+    .argument('<action>', 'Action: init, show, or validate')
+    .action(async (action) => {
+    try {
+        if (action === 'init') {
+            console.log(chalk_1.default.blue('\n🔧 Creating config.json...\n'));
+            const configPath = await (0, config_1.createSampleConfig)();
+            console.log(chalk_1.default.green(`✓ Created ${configPath}`));
+            console.log(chalk_1.default.yellow('\nPlease edit config.json and add your API key.\n'));
+        }
+        else if (action === 'show') {
+            const config = (0, config_1.getConfig)();
+            console.log(chalk_1.default.blue('\n⚙️  Current Configuration:\n'));
+            console.log(chalk_1.default.bold('Default Model:'), chalk_1.default.white(config.defaultModel));
+            console.log(chalk_1.default.bold('Default Duration:'), chalk_1.default.white(config.defaultDuration + 's'));
+            console.log(chalk_1.default.bold('\nAvailable Models:\n'));
+            const models = (0, config_1.listAvailableModels)();
+            models.forEach((modelName) => {
+                const modelConfig = config.models[modelName];
+                const isCurrent = modelName === config.defaultModel;
+                console.log(`  ${isCurrent ? chalk_1.default.green('→') : ' '} ${chalk_1.default.bold(modelName)}`);
+                console.log(`    API Key: ${modelConfig.apiKey && modelConfig.apiKey !== 'your_api_key_here' ? chalk_1.default.green('✓ Set') : chalk_1.default.red('✗ Not set')}`);
+                console.log(`    Base URL: ${chalk_1.default.gray(modelConfig.baseURL)}`);
+                console.log(`    Model: ${chalk_1.default.gray(modelConfig.model)}`);
+                console.log(`    Function Calling: ${modelConfig.supportsFunctionCalling ? chalk_1.default.green('✓ Supported') : chalk_1.default.red('✗ Not supported')}`);
+                console.log();
+            });
+        }
+        else if (action === 'validate') {
+            const validation = (0, config_1.validateConfig)();
+            console.log(chalk_1.default.blue('\n🔍 Validating configuration...\n'));
+            if (validation.valid) {
+                console.log(chalk_1.default.green('✓ Configuration is valid!\n'));
+            }
+            else {
+                console.log(chalk_1.default.red('✗ Configuration has errors:\n'));
+                validation.errors.forEach((error) => {
+                    console.log(chalk_1.default.red(`  • ${error}`));
+                });
+                console.log();
+                process.exit(1);
+            }
+        }
+        else {
+            console.error(chalk_1.default.red(`\n❌ Unknown action: ${action}`));
+            console.log(chalk_1.default.yellow('Available actions: init, show, validate\n'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        process.exit(1);
+    }
+});
+program.parse();