@juspay/neurolink 6.2.1 → 7.1.0

package/dist/cli/factories/commandFactory.js

@@ -0,0 +1,633 @@
+import { NeuroLink } from "../../lib/neurolink.js";
+import ora from "ora";
+import chalk from "chalk";
+import { logger } from "../../lib/utils/logger.js";
+import fs from "fs";
+/**
+ * CLI Command Factory for generate commands
+ */
+export class CLICommandFactory {
+    // Common options available on all commands
+    static commonOptions = {
+        // Core generation options
+        provider: {
+            choices: [
+                "auto",
+                "openai",
+                "bedrock",
+                "vertex",
+                "googleVertex",
+                "anthropic",
+                "azure",
+                "google-ai",
+                "huggingface",
+                "ollama",
+                "mistral",
+            ],
+            default: "auto",
+            description: "AI provider to use (auto-selects best available)",
+        },
+        model: {
+            type: "string",
+            description: "Specific model to use (e.g. gemini-2.5-pro, gemini-2.5-flash)",
+        },
+        temperature: {
+            type: "number",
+            default: 0.7,
+            description: "Creativity level (0.0 = focused, 1.0 = creative)",
+        },
+        maxTokens: {
+            type: "number",
+            default: 1000,
+            description: "Maximum tokens to generate",
+        },
+        system: {
+            type: "string",
+            description: "System prompt to guide AI behavior",
+        },
+        // Output control options
+        format: {
+            choices: ["text", "json", "table"],
+            default: "text",
+            alias: ["f", "output-format"],
+            description: "Output format",
+        },
+        output: {
+            type: "string",
+            description: "Save output to file",
+        },
+        // Behavior control options
+        timeout: {
+            type: "number",
+            default: 120,
+            description: "Maximum execution time in seconds",
+        },
+        delay: {
+            type: "number",
+            description: "Delay between operations (ms)",
+        },
+        // Tools & features options
+        disableTools: {
+            type: "boolean",
+            default: false,
+            description: "Disable MCP tool integration (tools enabled by default)",
+        },
+        enableAnalytics: {
+            type: "boolean",
+            default: false,
+            description: "Enable usage analytics collection",
+        },
+        enableEvaluation: {
+            type: "boolean",
+            default: false,
+            description: "Enable AI response quality evaluation",
+        },
+        evaluationDomain: {
+            type: "string",
+            description: "Domain expertise for evaluation (e.g., 'AI coding assistant', 'Customer service expert')",
+        },
+        toolUsageContext: {
+            type: "string",
+            description: "Tool usage context for evaluation (e.g., 'Used sales-data MCP tools')",
+        },
+        lighthouseStyle: {
+            type: "boolean",
+            default: false,
+            description: "Use Lighthouse-compatible domain-aware evaluation",
+        },
+        context: {
+            type: "string",
+            description: "JSON context object for custom data",
+        },
+        // Debug & output options
+        debug: {
+            type: "boolean",
+            alias: ["v", "verbose"],
+            default: false,
+            description: "Enable debug mode with verbose output",
+        },
+        quiet: {
+            type: "boolean",
+            alias: "q",
+            default: false,
+            description: "Suppress non-essential output",
+        },
+    };
+    // Helper method to build options for commands
+    static buildOptions(yargs, additionalOptions = {}) {
+        return yargs.options({
+            ...this.commonOptions,
+            ...additionalOptions,
+        });
+    }
+    // Helper method to process common options
+    static processOptions(argv) {
+        return {
+            provider: argv.provider === "auto" ? undefined : argv.provider,
+            model: argv.model,
+            temperature: argv.temperature,
+            maxTokens: argv.maxTokens,
+            systemPrompt: argv.system,
+            timeout: argv.timeout,
+            disableTools: argv.disableTools,
+            enableAnalytics: argv.enableAnalytics,
+            enableEvaluation: argv.enableEvaluation,
+            evaluationDomain: argv.evaluationDomain,
+            toolUsageContext: argv.toolUsageContext,
+            lighthouseStyle: argv.lighthouseStyle,
+            context: argv.context
+                ? typeof argv.context === "string"
+                    ? JSON.parse(argv.context)
+                    : argv.context
+                : undefined,
+            debug: argv.debug,
+            quiet: argv.quiet,
+            format: argv.format,
+            output: argv.output,
+            delay: argv.delay,
+        };
+    }
+    // Helper method to handle output
+    static handleOutput(result, options) {
+        let output;
+        if (options.format === "json") {
+            output = JSON.stringify(result, null, 2);
+        }
+        else if (options.format === "table" && Array.isArray(result)) {
+            console.table(result);
+            return;
+        }
+        else {
+            if (typeof result === "string") {
+                output = result;
+            }
+            else if (result && typeof result === "object" && "content" in result) {
+                output = result.content;
+            }
+            else if (result && typeof result === "object" && "text" in result) {
+                output = result.text;
+            }
+            else {
+                output = JSON.stringify(result);
+            }
+        }
+        if (options.output) {
+            fs.writeFileSync(options.output, output);
+            if (!options.quiet) {
+                console.log(`Output saved to ${options.output}`);
+            }
+        }
+        else {
+            console.log(output);
+        }
+    }
+    /**
+     * Create the new primary 'generate' command
+     */
+    static createGenerateCommand() {
+        return {
+            command: ["generate <input>", "gen <input>"],
+            describe: "Generate content using AI providers",
+            builder: (yargs) => {
+                return this.buildOptions(yargs.positional("input", {
+                    type: "string",
+                    description: "Text prompt for AI generation (or read from stdin)",
+                }));
+            },
+            handler: async (argv) => await this.executeGenerate(argv),
+        };
+    }
+    /**
+     * Create stream command
+     */
+    static createStreamCommand() {
+        return {
+            command: "stream <input>",
+            describe: "Stream generation in real-time",
+            builder: (yargs) => {
+                return this.buildOptions(yargs.positional("input", {
+                    type: "string",
+                    description: "Text prompt for streaming (or read from stdin)",
+                }));
+            },
+            handler: async (argv) => await this.executeStream(argv),
+        };
+    }
+    /**
+     * Create batch command
+     */
+    static createBatchCommand() {
+        return {
+            command: "batch <file>",
+            describe: "Process multiple prompts from a file",
+            builder: (yargs) => {
+                return this.buildOptions(yargs.positional("file", {
+                    type: "string",
+                    description: "File with prompts (one per line)",
+                    demandOption: true,
+                }));
+            },
+            handler: async (argv) => await this.executeBatch(argv),
+        };
+    }
+    /**
+     * Create provider commands
+     */
+    static createProviderCommands() {
+        return {
+            command: "provider <subcommand>",
+            describe: "Manage AI provider configurations and status",
+            builder: (yargs) => {
+                return yargs
+                    .command("status", "Check status of all configured AI providers", (y) => this.buildOptions(y), (argv) => CLICommandFactory.executeProviderStatus(argv))
+                    .demandCommand(1, "");
+            },
+            handler: () => { }, // No-op handler as subcommands handle everything
+        };
+    }
+    /**
+     * Create status command (alias for provider status)
+     */
+    static createStatusCommand() {
+        return {
+            command: "status",
+            describe: "Check AI provider connectivity and performance (alias for provider status)",
+            builder: (yargs) => this.buildOptions(yargs),
+            handler: async (argv) => await CLICommandFactory.executeProviderStatus(argv),
+        };
+    }
+    /**
+     * Create config commands
+     */
+    static createConfigCommands() {
+        return {
+            command: "config <subcommand>",
+            describe: "Manage NeuroLink configuration",
+            builder: (yargs) => {
+                return yargs
+                    .command("export", "Export current configuration", (y) => this.buildOptions(y), (argv) => this.executeConfigExport(argv))
+                    .demandCommand(1, "");
+            },
+            handler: () => { }, // No-op handler as subcommands handle everything
+        };
+    }
+    /**
+     * Create get-best-provider command
+     */
+    static createBestProviderCommand() {
+        return {
+            command: "get-best-provider",
+            describe: "Show the best available AI provider",
+            builder: (yargs) => this.buildOptions(yargs),
+            handler: async (argv) => await this.executeGetBestProvider(argv),
+        };
+    }
+    /**
+     * Create completion command
+     */
+    static createCompletionCommand() {
+        return {
+            command: "completion",
+            describe: "Generate shell completion script",
+            builder: (yargs) => this.buildOptions(yargs),
+            handler: async (argv) => await this.executeCompletion(argv),
+        };
+    }
+    /**
+     * Execute provider status command
+     */
+    static async executeProviderStatus(argv) {
+        if (argv.verbose && !argv.quiet) {
+            console.log(chalk.yellow("ℹ️ Verbose mode enabled. Displaying detailed status.\n"));
+        }
+        const spinner = argv.quiet
+            ? null
+            : ora("🔍 Checking AI provider status...\n").start();
+        try {
+            // Use SDK's provider diagnostic method instead of manual testing
+            const sdk = new NeuroLink();
+            const results = await sdk.getProviderStatus();
+            if (spinner) {
+                const working = results.filter((r) => r.status === "working").length;
+                const configured = results.filter((r) => r.configured).length;
+                spinner.succeed(`Provider check complete: ${working}/${configured} providers working`);
+            }
+            // Display results
+            for (const result of results) {
+                const status = result.status === "working"
+                    ? chalk.green("✅ Working")
+                    : result.status === "failed"
+                        ? chalk.red("❌ Failed")
+                        : chalk.gray("⚪ Not configured");
+                const time = result.responseTime ? ` (${result.responseTime}ms)` : "";
+                const model = result.model ? ` [${result.model}]` : "";
+                console.log(`${result.provider}: ${status}${time}${model}`);
+                if (argv.verbose && result.error) {
+                    console.log(`  Error: ${chalk.red(result.error)}`);
+                }
+            }
+            if (argv.verbose && !argv.quiet) {
+                console.log(chalk.blue("\n📋 Detailed Results:"));
+                console.log(JSON.stringify(results, null, 2));
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail("Provider status check failed");
+            }
+            console.error(chalk.red("Error checking provider status:"), error);
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute the generate command
+     */
+    static async executeGenerate(argv) {
+        // Handle stdin input if no input provided
+        if (!argv.input && !process.stdin.isTTY) {
+            let stdinData = "";
+            process.stdin.setEncoding("utf8");
+            for await (const chunk of process.stdin) {
+                stdinData += chunk;
+            }
+            argv.input = stdinData.trim();
+            if (!argv.input) {
+                throw new Error("No input received from stdin");
+            }
+        }
+        else if (!argv.input) {
+            throw new Error('Input required. Use: neurolink generate "your prompt" or echo "prompt" | neurolink generate');
+        }
+        const options = this.processOptions(argv);
+        const spinner = argv.quiet ? null : ora("🤖 Generating text...").start();
+        try {
+            // Add delay if specified
+            if (options.delay) {
+                await new Promise((resolve) => setTimeout(resolve, options.delay));
+            }
+            const sdk = new NeuroLink();
+            const result = await sdk.generate({
+                input: { text: argv.input },
+                provider: options.provider,
+                model: options.model,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt,
+                timeout: options.timeout,
+                disableTools: options.disableTools,
+                enableAnalytics: options.enableAnalytics,
+                enableEvaluation: options.enableEvaluation,
+                evaluationDomain: options.evaluationDomain,
+                toolUsageContext: options.toolUsageContext,
+                context: options.context,
+            });
+            if (spinner) {
+                spinner.succeed(chalk.green("✅ Text generated successfully!"));
+            }
+            // Handle output with universal formatting
+            this.handleOutput(result, options);
+            if (options.debug) {
+                logger.debug("\n" + chalk.yellow("Debug Information:"));
+                logger.debug("Provider:", result.provider);
+                logger.debug("Model:", result.model);
+                if (result.analytics) {
+                    logger.debug("Analytics:", JSON.stringify(result.analytics, null, 2));
+                }
+                if (result.evaluation) {
+                    logger.debug("Evaluation:", JSON.stringify(result.evaluation, null, 2));
+                }
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail();
+            }
+            console.error(chalk.red(`❌ Generation failed: ${error.message}`));
+            if (options.debug) {
+                console.error(chalk.gray(error.stack));
+            }
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute the stream command
+     */
+    static async executeStream(argv) {
+        // Handle stdin input if no input provided
+        if (!argv.input && !process.stdin.isTTY) {
+            let stdinData = "";
+            process.stdin.setEncoding("utf8");
+            for await (const chunk of process.stdin) {
+                stdinData += chunk;
+            }
+            argv.input = stdinData.trim();
+            if (!argv.input) {
+                throw new Error("No input received from stdin");
+            }
+        }
+        else if (!argv.input) {
+            throw new Error('Input required. Use: neurolink stream "your prompt" or echo "prompt" | neurolink stream');
+        }
+        const options = this.processOptions(argv);
+        if (!options.quiet) {
+            console.log(chalk.blue("🔄 Streaming..."));
+        }
+        try {
+            // Add delay if specified
+            if (options.delay) {
+                await new Promise((resolve) => setTimeout(resolve, options.delay));
+            }
+            const sdk = new NeuroLink();
+            const stream = await sdk.stream({
+                input: { text: argv.input },
+                provider: options.provider,
+                model: options.model,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt,
+                timeout: options.timeout,
+                disableTools: options.disableTools,
+                enableAnalytics: options.enableAnalytics,
+                enableEvaluation: options.enableEvaluation,
+                context: options.context,
+            });
+            let fullContent = "";
+            // Process the stream
+            for await (const chunk of stream.stream) {
+                if (options.delay && options.delay > 0) {
+                    // Demo mode - add delay between chunks
+                    await new Promise((resolve) => setTimeout(resolve, options.delay));
+                }
+                process.stdout.write(chunk.content);
+                fullContent += chunk.content;
+            }
+            if (!options.quiet) {
+                process.stdout.write("\n");
+            }
+            // Handle output file if specified
+            if (options.output) {
+                fs.writeFileSync(options.output, fullContent);
+                if (!options.quiet) {
+                    console.log(`\nOutput saved to ${options.output}`);
+                }
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            console.error(chalk.red(`❌ Streaming failed: ${error.message}`));
+            if (options.debug) {
+                console.error(chalk.gray(error.stack));
+            }
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute the batch command
+     */
+    static async executeBatch(argv) {
+        const options = this.processOptions(argv);
+        const spinner = options.quiet ? null : ora().start();
+        try {
+            if (!argv.file) {
+                throw new Error("No file specified");
+            }
+            if (!fs.existsSync(argv.file)) {
+                throw new Error(`File not found: ${argv.file}`);
+            }
+            const buffer = fs.readFileSync(argv.file);
+            const prompts = buffer
+                .toString("utf8")
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean);
+            if (prompts.length === 0) {
+                throw new Error("No prompts found in file");
+            }
+            if (spinner) {
+                spinner.text = `📦 Processing ${prompts.length} prompts...`;
+            }
+            else if (!options.quiet) {
+                console.log(chalk.blue(`📦 Processing ${prompts.length} prompts...\n`));
+            }
+            const results = [];
+            const sdk = new NeuroLink();
+            for (let i = 0; i < prompts.length; i++) {
+                if (spinner) {
+                    spinner.text = `Processing ${i + 1}/${prompts.length}: ${prompts[i].substring(0, 30)}...`;
+                }
+                try {
+                    const result = await sdk.generate({
+                        input: { text: prompts[i] },
+                        provider: options.provider,
+                        model: options.model,
+                        temperature: options.temperature,
+                        maxTokens: options.maxTokens,
+                        systemPrompt: options.systemPrompt,
+                        timeout: options.timeout,
+                        disableTools: options.disableTools,
+                        enableAnalytics: options.enableAnalytics,
+                        enableEvaluation: options.enableEvaluation,
+                        context: options.context,
+                    });
+                    results.push({ prompt: prompts[i], response: result.content });
+                    if (spinner) {
+                        spinner.render();
+                    }
+                }
+                catch (error) {
+                    results.push({
+                        prompt: prompts[i],
+                        error: error.message,
+                    });
+                    if (spinner) {
+                        spinner.render();
+                    }
+                }
+                // Add delay between requests
+                if (i < prompts.length - 1) {
+                    await new Promise((resolve) => setTimeout(resolve, options.delay || 1000));
+                }
+            }
+            if (spinner) {
+                spinner.succeed(chalk.green("✅ Batch processing complete!"));
+            }
+            // Handle output with universal formatting
+            this.handleOutput(results, options);
+            process.exit(0);
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail();
+            }
+            console.error(chalk.red(`❌ Batch processing failed: ${error.message}`));
+            if (options.debug) {
+                console.error(chalk.gray(error.stack));
+            }
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute config export command
+     */
+    static async executeConfigExport(argv) {
+        const options = this.processOptions(argv);
+        try {
+            const config = {
+                providers: {
+                    openai: !!process.env.OPENAI_API_KEY,
+                    bedrock: !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY),
+                    vertex: !!(process.env.GOOGLE_APPLICATION_CREDENTIALS ||
+                        process.env.GOOGLE_SERVICE_ACCOUNT_KEY),
+                    anthropic: !!process.env.ANTHROPIC_API_KEY,
+                    azure: !!(process.env.AZURE_OPENAI_API_KEY &&
+                        process.env.AZURE_OPENAI_ENDPOINT),
+                    "google-ai": !!process.env.GOOGLE_AI_API_KEY,
+                },
+                defaults: {
+                    temperature: 0.7,
+                    maxTokens: 500,
+                },
+                timestamp: new Date().toISOString(),
+            };
+            this.handleOutput(config, options);
+        }
+        catch (error) {
+            console.error(chalk.red(`❌ Configuration export failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute get best provider command
+     */
+    static async executeGetBestProvider(argv) {
+        const options = this.processOptions(argv);
+        try {
+            const { getBestProvider } = await import("../../lib/utils/providerUtils.js");
+            const bestProvider = await getBestProvider();
+            if (options.format === "json") {
+                this.handleOutput({ provider: bestProvider }, options);
+            }
+            else {
+                if (!options.quiet) {
+                    console.log(chalk.green(`🎯 Best available provider: ${bestProvider}`));
+                }
+                else {
+                    this.handleOutput(bestProvider, options);
+                }
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`❌ Provider selection failed: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    /**
+     * Execute completion command
+     */
+    static async executeCompletion(argv) {
+        // This would need to be implemented with the actual CLI instance
+        console.log("# Completion script would be generated here");
+        console.log("# This requires access to the yargs CLI instance");
+    }
+}

package/dist/cli/index.d.ts

@@ -1,2 +1,8 @@
 #!/usr/bin/env node
+/**
+ * NeuroLink CLI
+ *
+ * Professional CLI experience with minimal maintenance overhead.
+ * Features: Spinners, colors, batch processing, provider testing, rich help
+ */
 export {};