@juspay/neurolink 7.34.0 → 7.36.0

package/dist/cli/commands/setup-google-ai.js

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+/**
+ * Google AI Studio Setup Command
+ *
+ * Simple setup for Google AI Studio (Google AI) integration:
+ * - GOOGLE_AI_API_KEY (required)
+ * - GOOGLE_AI_MODEL (optional, with recommended choices)
+ *
+ * Follows the same UX patterns as setup-openai and setup-gcp
+ */
+import path from "path";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import ora from "ora";
+import { logger } from "../../lib/utils/logger.js";
+import { GoogleAIModels } from "../../lib/types/providers.js";
+import { updateEnvFile as updateEnvFileManager, displayEnvUpdateSummary, } from "../utils/envManager.js";
+/**
+ * Get the runtime default model that matches the provider implementation
+ */
+function getRuntimeDefaultModel() {
+    return process.env.GOOGLE_AI_MODEL || GoogleAIModels.GEMINI_2_5_FLASH;
+}
+export async function handleGoogleAISetup(argv) {
+    try {
+        const options = {
+            checkOnly: argv.check || false,
+            interactive: !argv.nonInteractive,
+        };
+        logger.always(chalk.blue("🔍 Checking Google AI Studio configuration..."));
+        // Step 1: Check for existing configuration
+        const hasApiKey = !!(process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY);
+        const hasModel = !!process.env.GOOGLE_AI_MODEL;
+        const currentApiKey = process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+        // Display current status
+        displayCurrentStatus(hasApiKey, hasModel);
+        // Check-only mode - show status and exit
+        if (options.checkOnly) {
+            if (hasApiKey && currentApiKey) {
+                logger.always(chalk.green("✅ Google AI Studio setup complete"));
+                logger.always(`   API Key: ${maskCredential(currentApiKey)}`);
+                if (hasModel) {
+                    logger.always(`   Model: ${process.env.GOOGLE_AI_MODEL}`);
+                }
+                else {
+                    logger.always(`   Model: ${getRuntimeDefaultModel()} (default)`);
+                }
+            }
+            else {
+                logger.always(chalk.yellow("⚠️  Google AI Studio setup incomplete"));
+            }
+            return;
+        }
+        const config = {};
+        // Step 2: Handle existing configuration
+        if (hasApiKey && currentApiKey) {
+            logger.always(chalk.green("✅ Google AI Studio API key found in environment"));
+            logger.always(`   API Key: ${maskCredential(currentApiKey)}`);
+            if (hasModel) {
+                logger.always(`   Model: ${process.env.GOOGLE_AI_MODEL}`);
+            }
+            else {
+                logger.always(`   Model: ${getRuntimeDefaultModel()} (default)`);
+            }
+            if (options.interactive) {
+                const { reconfigure } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "reconfigure",
+                        message: "Google AI Studio is already configured. Do you want to reconfigure?",
+                        default: false,
+                    },
+                ]);
+                if (!reconfigure) {
+                    // Still offer model selection if no model is set
+                    if (!hasModel) {
+                        const { wantsCustomModel } = await inquirer.prompt([
+                            {
+                                type: "confirm",
+                                name: "wantsCustomModel",
+                                message: "Do you want to specify a Google AI model? (optional)",
+                                default: false,
+                            },
+                        ]);
+                        if (wantsCustomModel) {
+                            config.model = await promptForModel();
+                        }
+                    }
+                    else {
+                        // Offer to change existing model
+                        const { wantsChangeModel } = await inquirer.prompt([
+                            {
+                                type: "confirm",
+                                name: "wantsChangeModel",
+                                message: `Do you want to change the Google AI model? (current: ${process.env.GOOGLE_AI_MODEL})`,
+                                default: false,
+                            },
+                        ]);
+                        if (wantsChangeModel) {
+                            config.model = await promptForModel();
+                        }
+                    }
+                    if (config.model) {
+                        await updateEnvFile(config);
+                        logger.always(chalk.green("✅ Model configuration updated!"));
+                        logger.always(`   GOOGLE_AI_MODEL=${config.model}`);
+                    }
+                    else {
+                        logger.always(chalk.blue("👍 Keeping existing configuration."));
+                    }
+                    // Show usage example
+                    showUsageExample();
+                    return;
+                }
+                else {
+                    // User chose to reconfigure - mark this for proper handling
+                    logger.always(chalk.blue("📝 Reconfiguring Google AI Studio setup..."));
+                    config.isReconfiguring = true;
+                }
+            }
+            else {
+                // Non-interactive mode - just use existing credentials
+                logger.always(chalk.green("✅ Setup complete! Using existing Google AI Studio configuration."));
+                return;
+            }
+        }
+        // Step 3: Interactive setup for missing or reconfiguring credentials
+        if (options.interactive) {
+            const isReconfiguring = config.isReconfiguring === true;
+            // Handle API key setup/reconfiguration
+            if (!hasApiKey) {
+                // No API key exists - prompt for it
+                logger.always("");
+                logger.always(chalk.yellow("📋 To get your Google AI Studio API key:"));
+                logger.always("1. Visit: https://aistudio.google.com/app/apikey");
+                logger.always("2. Sign in with your Google account");
+                logger.always("3. Click 'Create API key' (free tier available)");
+                logger.always("4. Copy the API key (starts with AIza...)");
+                logger.always("");
+                const { apiKey } = await inquirer.prompt([
+                    {
+                        type: "password",
+                        name: "apiKey",
+                        message: "Enter your Google AI Studio API key:",
+                        validate: validateApiKey,
+                    },
+                ]);
+                config.apiKey = apiKey.trim();
+            }
+            else if (isReconfiguring) {
+                // API key exists and user is reconfiguring - ask if they want to change it
+                const { wantsChangeApiKey } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "wantsChangeApiKey",
+                        message: `Do you want to change the Google AI Studio API key? (current: ${currentApiKey ? maskCredential(currentApiKey) : "****"})`,
+                        default: false,
+                    },
+                ]);
+                if (wantsChangeApiKey) {
+                    logger.always("");
+                    logger.always(chalk.yellow("📋 To get your Google AI Studio API key:"));
+                    logger.always("1. Visit: https://aistudio.google.com/app/apikey");
+                    logger.always("2. Sign in with your Google account");
+                    logger.always("3. Click 'Create API key' (free tier available)");
+                    logger.always("4. Copy the API key (starts with AIza...)");
+                    logger.always("");
+                    const { apiKey } = await inquirer.prompt([
+                        {
+                            type: "password",
+                            name: "apiKey",
+                            message: "Enter your new Google AI Studio API key (replacing existing):",
+                            validate: validateApiKey,
+                        },
+                    ]);
+                    config.apiKey = apiKey.trim();
+                }
+            }
+            // Prompt for model selection
+            const { wantsCustomModel } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "wantsCustomModel",
+                    message: hasModel
+                        ? `Do you want to change the Google AI model? (current: ${process.env.GOOGLE_AI_MODEL})`
+                        : "Do you want to specify a Google AI model? (optional)",
+                    default: false,
+                },
+            ]);
+            if (wantsCustomModel) {
+                config.model = await promptForModel();
+            }
+        }
+        else {
+            // Non-interactive mode
+            logger.always(chalk.yellow("⚠️  Non-interactive mode: setup incomplete"));
+            logger.always(chalk.yellow("💡 Run without --non-interactive to configure Google AI Studio"));
+            return;
+        }
+        // Step 4: Update .env file
+        if (config.apiKey || config.model) {
+            await updateEnvFile(config);
+            logger.always(chalk.green("✅ Google AI Studio setup complete!"));
+            if (config.apiKey) {
+                logger.always(`   API Key: ${maskCredential(config.apiKey)}`);
+            }
+            if (config.model) {
+                logger.always(`   Model: ${config.model}`);
+            }
+            // Show usage example
+            showUsageExample();
+        }
+        else if (options.interactive && !options.checkOnly) {
+            logger.always(chalk.green("✅ Setup complete!"));
+            showUsageExample();
+        }
+    }
+    catch (error) {
+        logger.error(chalk.red("❌ Google AI Studio setup failed:"));
+        logger.error(chalk.red(error instanceof Error ? error.message : "Unknown error"));
+        process.exit(1);
+    }
+}
+/**
+ * Display current configuration status
+ */
+function displayCurrentStatus(hasApiKey, hasModel) {
+    if (hasApiKey) {
+        logger.always(chalk.green("✔ Google AI Studio API key found in environment"));
+    }
+    else {
+        logger.always(chalk.red("✘ Google AI Studio API key not found"));
+    }
+    if (hasModel) {
+        logger.always(chalk.green(`✔ GOOGLE_AI_MODEL found: ${process.env.GOOGLE_AI_MODEL}`));
+    }
+    else {
+        logger.always(chalk.yellow(`⚠ GOOGLE_AI_MODEL not set (will use ${getRuntimeDefaultModel()} default)`));
+    }
+}
+/**
+ * Validate Google AI Studio API key format
+ */
+function validateApiKey(input) {
+    if (!input.trim()) {
+        return "Google AI Studio API key is required";
+    }
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("AIza")) {
+        return "Google AI Studio API key should start with 'AIza'";
+    }
+    if (trimmed.length < 20) {
+        return "Google AI Studio API key seems too short";
+    }
+    // Basic format check: AIza[32+ char random string]
+    if (!/^AIza[a-zA-Z0-9_-]{20,}$/.test(trimmed)) {
+        return "Invalid Google AI Studio API key format";
+    }
+    return true;
+}
+/**
+ * Prompt user for model selection
+ */
+async function promptForModel() {
+    const { modelChoice } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "modelChoice",
+            message: "Select a Google AI model:",
+            choices: [
+                {
+                    name: "gemini-2.5-pro (Recommended - Latest high-capability model)",
+                    value: "gemini-2.5-pro",
+                },
+                {
+                    name: "gemini-2.5-flash (Fast and efficient)",
+                    value: "gemini-2.5-flash",
+                },
+                {
+                    name: "gemini-pro-vision (Multimodal - text and images)",
+                    value: "gemini-pro-vision",
+                },
+                {
+                    name: "gemini-pro (Previous generation)",
+                    value: "gemini-pro",
+                },
+                {
+                    name: "Custom model (enter manually)",
+                    value: "custom",
+                },
+            ],
+        },
+    ]);
+    if (modelChoice === "custom") {
+        const { customModel } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "customModel",
+                message: "Enter your custom Google AI model name:",
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return "Model name is required";
+                    }
+                    // Basic validation - Google AI models typically follow certain patterns
+                    const trimmed = input.trim();
+                    if (!/^[a-z0-9-._]+$/i.test(trimmed)) {
+                        return "Model name should contain only letters, numbers, hyphens, dots, and underscores";
+                    }
+                    return true;
+                },
+            },
+        ]);
+        return customModel.trim();
+    }
+    return modelChoice;
+}
+/**
+ * Update .env file with Google AI Studio configuration
+ */
+async function updateEnvFile(config) {
+    const envPath = path.join(process.cwd(), ".env");
+    const spinner = ora("💾 Updating .env file...").start();
+    try {
+        // Prepare environment variables to update
+        const envVars = {};
+        const keysToDelete = [];
+        if (config.apiKey) {
+            // Use GOOGLE_AI_API_KEY as the primary key
+            envVars.GOOGLE_AI_API_KEY = config.apiKey;
+            // Remove alternative key if it exists
+            keysToDelete.push("GOOGLE_GENERATIVE_AI_API_KEY");
+        }
+        if (config.model) {
+            envVars.GOOGLE_AI_MODEL = config.model;
+        }
+        // Update .env file using centralized envManager
+        const result = updateEnvFileManager(envVars, envPath, true, keysToDelete);
+        spinner.succeed(chalk.green("✔ .env file updated successfully"));
+        // Display summary of changes (quietly, since we have our own success message)
+        displayEnvUpdateSummary(result, true);
+    }
+    catch (error) {
+        spinner.fail(chalk.red("❌ Failed to update .env file"));
+        logger.error(chalk.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+        throw error;
+    }
+}
+/**
+ * Mask API key for display
+ */
+function maskCredential(credential) {
+    if (!credential || credential.length < 8) {
+        return "****";
+    }
+    const start = credential.slice(0, 7); // Show 'AIza' plus a few chars
+    const end = credential.slice(-4);
+    const middle = "*".repeat(Math.max(4, credential.length - 11));
+    return `${start}${middle}${end}`;
+}
+/**
+ * Show usage example
+ */
+function showUsageExample() {
+    logger.always("");
+    logger.always(chalk.green("🚀 You can now use Google AI Studio with the NeuroLink CLI:"));
+    logger.always(chalk.cyan("   pnpm cli generate 'Hello from Google AI!' --provider google-ai"));
+    logger.always(chalk.cyan("   pnpm cli generate 'Explain quantum computing' --provider google-ai"));
+    logger.always(chalk.cyan("   pnpm cli generate 'Analyze this data' --provider google-ai --enable-analytics"));
+}

package/dist/cli/commands/setup-huggingface.d.ts

@@ -0,0 +1,8 @@
+import type { Arguments, CommandBuilder } from "yargs";
+interface SetupHuggingFaceArgs {
+    check?: boolean;
+    "non-interactive"?: boolean;
+}
+export declare const handleHuggingFaceSetup: (argv: Arguments<SetupHuggingFaceArgs>) => Promise<void>;
+export declare const setupHuggingFaceBuilder: CommandBuilder;
+export {};

package/dist/cli/commands/setup-huggingface.js

@@ -0,0 +1,200 @@
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { logger } from "../../lib/utils/logger.js";
+import { updateEnvFile as writeEnvFile, displayEnvUpdateSummary, } from "../utils/envManager.js";
+/**
+ * Validates Hugging Face API key format
+ * Must start with "hf_" prefix
+ */
+function validateHuggingFaceApiKey(apiKey) {
+    return (typeof apiKey === "string" && apiKey.startsWith("hf_") && apiKey.length > 10);
+}
+/**
+ * Check current Hugging Face configuration
+ */
+function checkHuggingFaceConfig() {
+    const apiKey = process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN;
+    const model = process.env.HUGGINGFACE_MODEL;
+    const hasApiKey = !!apiKey;
+    const hasModel = !!model;
+    const isValid = hasApiKey && validateHuggingFaceApiKey(apiKey);
+    return {
+        hasApiKey,
+        hasModel,
+        apiKey: apiKey ? `hf_${"*".repeat(6)}` : undefined,
+        model,
+        isValid,
+    };
+}
+export const handleHuggingFaceSetup = async (argv) => {
+    const spinner = ora();
+    try {
+        spinner.start("Checking Hugging Face configuration...");
+        const config = checkHuggingFaceConfig();
+        spinner.stop();
+        // Display current status
+        logger.always(chalk.bold.blue("\n🤗 Hugging Face Configuration Status\n"));
+        logger.always(`${config.hasApiKey ? "✅" : "❌"} API Key: ${config.apiKey || "Not set"}`);
+        logger.always(`${config.hasModel ? "✅" : "⚠️"} Model: ${config.model || "Not set (will use default)"}`);
+        if (config.isValid) {
+            logger.always(chalk.green("\n✅ Hugging Face is properly configured!"));
+            if (argv.check) {
+                return;
+            }
+            const { shouldReconfigure } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "shouldReconfigure",
+                    message: "Configuration looks good. Do you want to reconfigure anyway?",
+                    default: false,
+                },
+            ]);
+            if (!shouldReconfigure) {
+                logger.always(chalk.green("✅ Keeping existing configuration."));
+                return;
+            }
+        }
+        else {
+            logger.always(chalk.yellow("\n⚠️ Hugging Face configuration needs setup."));
+            if (argv.check) {
+                throw new Error("Hugging Face configuration is incomplete");
+            }
+        }
+        if (argv["non-interactive"]) {
+            logger.always(chalk.yellow("Non-interactive mode: Skipping configuration setup."));
+            logger.always(chalk.blue("Please set HUGGINGFACE_API_KEY manually."));
+            return;
+        }
+        // Interactive setup
+        logger.always(chalk.blue("\n🛠️ Let's configure Hugging Face!\n"));
+        // Step 1: API Key
+        const { apiKey } = await inquirer.prompt([
+            {
+                type: "password",
+                name: "apiKey",
+                message: "Enter your Hugging Face API token:",
+                mask: "*",
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return "API token is required";
+                    }
+                    if (!validateHuggingFaceApiKey(input.trim())) {
+                        return "Invalid API token format. Must start with 'hf_'";
+                    }
+                    return true;
+                },
+            },
+        ]);
+        // Step 2: Model Selection
+        const { modelChoice } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "modelChoice",
+                message: "Select a Hugging Face model:",
+                choices: [
+                    {
+                        name: "Skip - use default (microsoft/DialoGPT-large)",
+                        value: "default",
+                    },
+                    {
+                        name: "microsoft/DialoGPT-large (Conversational AI - Recommended)",
+                        value: "microsoft/DialoGPT-large",
+                    },
+                    {
+                        name: "microsoft/DialoGPT-medium (Faster, smaller)",
+                        value: "microsoft/DialoGPT-medium",
+                    },
+                    {
+                        name: "facebook/blenderbot-400M-distill (General purpose)",
+                        value: "facebook/blenderbot-400M-distill",
+                    },
+                    {
+                        name: "microsoft/DialoGPT-small (Fastest)",
+                        value: "microsoft/DialoGPT-small",
+                    },
+                    {
+                        name: "Custom model name",
+                        value: "custom",
+                    },
+                ],
+                default: "default",
+            },
+        ]);
+        let selectedModel;
+        if (modelChoice === "custom") {
+            const { customModel } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "customModel",
+                    message: "Enter custom model name:",
+                    validate: (input) => {
+                        const trimmed = input.trim();
+                        if (!trimmed) {
+                            return "Model name is required";
+                        }
+                        if (!trimmed.includes("/")) {
+                            return "Model name should include organization (e.g., 'microsoft/DialoGPT-large')";
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            selectedModel = customModel.trim();
+        }
+        else if (modelChoice !== "default") {
+            selectedModel = modelChoice;
+        }
+        // If modelChoice === "default", selectedModel remains undefined
+        // Save configuration
+        spinner.start("Saving configuration...");
+        const updates = {
+            HUGGINGFACE_API_KEY: apiKey.trim(),
+        };
+        // Only set model if user didn't choose default
+        if (selectedModel) {
+            updates.HUGGINGFACE_MODEL = selectedModel;
+        }
+        try {
+            const result = writeEnvFile(updates);
+            spinner.stop();
+            // Display update summary
+            displayEnvUpdateSummary(result, false);
+            logger.always(chalk.green("\n✅ Hugging Face configuration saved successfully!"));
+        }
+        catch (envError) {
+            spinner.stop();
+            throw new Error(`Failed to save configuration: ${envError instanceof Error ? envError.message : String(envError)}`);
+        }
+        logger.always(chalk.blue("\n📖 Usage examples:"));
+        logger.always(chalk.gray('   neurolink generate "Hello, how are you?" --provider huggingface'));
+        if (selectedModel) {
+            logger.always(chalk.gray(`   neurolink generate "Tell me a story" --provider huggingface --model ${selectedModel}`));
+        }
+        else {
+            logger.always(chalk.gray('   neurolink generate "Tell me a story" --provider huggingface'));
+            logger.always(chalk.gray('   neurolink generate "Explain AI" --provider huggingface --model microsoft/DialoGPT-medium'));
+        }
+        logger.always(chalk.blue("\n🔗 Resources:"));
+        logger.always(chalk.gray("   • Hugging Face Models: https://huggingface.co/models"));
+        logger.always(chalk.gray("   • API Documentation: https://huggingface.co/docs/api-inference"));
+        logger.always(chalk.gray("   • Get API Token: https://huggingface.co/settings/tokens"));
+    }
+    catch (error) {
+        spinner.stop();
+        logger.error("Hugging Face setup failed", error);
+        throw error;
+    }
+};
+export const setupHuggingFaceBuilder = {
+    check: {
+        type: "boolean",
+        describe: "Only check existing configuration without prompting",
+        default: false,
+    },
+    "non-interactive": {
+        type: "boolean",
+        describe: "Skip interactive prompts",
+        default: false,
+    },
+};

package/dist/cli/commands/setup-mistral.d.ts

@@ -0,0 +1,8 @@
+import type { Arguments, CommandBuilder } from "yargs";
+interface SetupMistralArgs {
+    check?: boolean;
+    "non-interactive"?: boolean;
+}
+export declare const handleMistralSetup: (argv: Arguments<SetupMistralArgs>) => Promise<void>;
+export declare const setupMistralBuilder: CommandBuilder;
+export {};