@juspay/neurolink 1.6.0 → 1.9.0

package/dist/cli/utils/complete-setup.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Complete Setup Integration for NeuroLink CLI
+ *
+ * Orchestrates the entire setup process: interactive wizard, environment management,
+ * provider testing, and summary display.
+ */
+import { type SetupResult } from "./interactive-setup.js";
+/**
+ * Run the complete interactive setup process
+ */
+export declare function runCompleteSetup(quiet?: boolean): Promise<SetupResult>;
+/**
+ * Wrapper for config setup command
+ */
+export declare function configSetup(quiet?: boolean): Promise<void>;
+/**
+ * Wrapper for config init command (alias for setup)
+ */
+export declare function configInit(quiet?: boolean): Promise<void>;

package/dist/cli/utils/complete-setup.js

@@ -0,0 +1,81 @@
+/**
+ * Complete Setup Integration for NeuroLink CLI
+ *
+ * Orchestrates the entire setup process: interactive wizard, environment management,
+ * provider testing, and summary display.
+ */
+import { runInteractiveSetup, testProviderConnectivity, displaySetupSummary, } from "./interactive-setup.js";
+import { updateEnvFile, displayEnvUpdateSummary } from "./env-manager.js";
+import chalk from "chalk";
+/**
+ * Run the complete interactive setup process
+ */
+export async function runCompleteSetup(quiet = false) {
+    try {
+        // Step 1: Run interactive setup wizard
+        if (!quiet) {
+            console.log(chalk.blue("🚀 Starting NeuroLink Configuration Setup...\n"));
+        }
+        const setupResult = await runInteractiveSetup(quiet);
+        // If no providers selected, exit early
+        if (setupResult.selectedProviders.length === 0) {
+            if (!quiet) {
+                console.log(chalk.yellow("⚠️  No providers selected. Setup cancelled."));
+            }
+            return setupResult;
+        }
+        // Step 2: Update environment file with credentials
+        if (Object.keys(setupResult.credentials).length > 0) {
+            if (!quiet) {
+                console.log(chalk.blue("\n💾 Updating environment configuration...\n"));
+            }
+            try {
+                const envResult = updateEnvFile(setupResult.credentials, ".env", true);
+                setupResult.envFileBackup = envResult.backup.backupPath;
+                if (!quiet) {
+                    displayEnvUpdateSummary(envResult, false);
+                }
+                // Update process.env for immediate testing
+                for (const [key, value] of Object.entries(setupResult.credentials)) {
+                    process.env[key] = value;
+                }
+            }
+            catch (error) {
+                if (!quiet) {
+                    console.error(chalk.red(`❌ Failed to update environment file: ${error instanceof Error ? error.message : String(error)}`));
+                }
+                throw error;
+            }
+        }
+        // Step 3: Test provider connectivity
+        if (!quiet) {
+            console.log(chalk.blue("\n🧪 Testing configured providers...\n"));
+        }
+        setupResult.testResults = await testProviderConnectivity(setupResult.selectedProviders, quiet);
+        // Step 4: Display summary
+        displaySetupSummary(setupResult, quiet);
+        return setupResult;
+    }
+    catch (error) {
+        if (!quiet) {
+            console.error(chalk.red(`❌ Setup failed: ${error instanceof Error ? error.message : String(error)}`));
+            console.log(chalk.yellow("💡 You can retry setup with: neurolink config setup"));
+        }
+        throw error;
+    }
+}
+/**
+ * Wrapper for config setup command
+ */
+export async function configSetup(quiet = false) {
+    await runCompleteSetup(quiet);
+}
+/**
+ * Wrapper for config init command (alias for setup)
+ */
+export async function configInit(quiet = false) {
+    if (!quiet) {
+        console.log(chalk.gray("📝 config init is an alias for config setup\n"));
+    }
+    await runCompleteSetup(quiet);
+}

package/dist/cli/utils/env-manager.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Environment File Management Utilities for NeuroLink CLI
+ *
+ * Handles .env file operations including backup, update, and validation.
+ */
+export interface EnvBackupResult {
+    backupPath?: string;
+    existed: boolean;
+}
+export interface EnvUpdateResult {
+    backup: EnvBackupResult;
+    updated: string[];
+    added: string[];
+    unchanged: string[];
+}
+/**
+ * Create a timestamped backup of the existing .env file
+ */
+export declare function backupEnvFile(envPath?: string): EnvBackupResult;
+/**
+ * Parse .env file content into key-value pairs
+ */
+export declare function parseEnvFile(content: string): Record<string, string>;
+/**
+ * Generate .env file content from key-value pairs
+ */
+export declare function generateEnvContent(envVars: Record<string, string>, existingContent?: string): string;
+/**
+ * Update .env file with new environment variables
+ */
+export declare function updateEnvFile(newVars: Record<string, string>, envPath?: string, createBackup?: boolean): EnvUpdateResult;
+/**
+ * Display environment file update summary
+ */
+export declare function displayEnvUpdateSummary(result: EnvUpdateResult, quiet?: boolean): void;
+/**
+ * Validate .env file format and required variables
+ */
+export declare function validateEnvFile(envPath?: string, requiredVars?: string[]): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    variables: Record<string, string>;
+};

package/dist/cli/utils/env-manager.js

@@ -0,0 +1,226 @@
+/**
+ * Environment File Management Utilities for NeuroLink CLI
+ *
+ * Handles .env file operations including backup, update, and validation.
+ */
+import fs from "fs";
+import chalk from "chalk";
+/**
+ * Create a timestamped backup of the existing .env file
+ */
+export function backupEnvFile(envPath = ".env") {
+    const result = {
+        existed: false,
+    };
+    if (fs.existsSync(envPath)) {
+        result.existed = true;
+        const timestamp = new Date()
+            .toISOString()
+            .replace(/[:.]/g, "-")
+            .replace("T", "_")
+            .split(".")[0]; // Remove milliseconds
+        const backupPath = `${envPath}.backup.${timestamp}`;
+        try {
+            fs.copyFileSync(envPath, backupPath);
+            result.backupPath = backupPath;
+        }
+        catch (error) {
+            throw new Error(`Failed to create backup: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return result;
+}
+/**
+ * Parse .env file content into key-value pairs
+ */
+export function parseEnvFile(content) {
+    const result = {};
+    const lines = content.split("\n");
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        // Skip empty lines and comments
+        if (!trimmedLine || trimmedLine.startsWith("#")) {
+            continue;
+        }
+        // Find the first = character
+        const equalIndex = trimmedLine.indexOf("=");
+        if (equalIndex === -1) {
+            continue; // Invalid line format
+        }
+        const key = trimmedLine.substring(0, equalIndex).trim();
+        const value = trimmedLine.substring(equalIndex + 1).trim();
+        // Remove surrounding quotes if present
+        const cleanValue = value.replace(/^["']|["']$/g, "");
+        result[key] = cleanValue;
+    }
+    return result;
+}
+/**
+ * Generate .env file content from key-value pairs
+ */
+export function generateEnvContent(envVars, existingContent) {
+    const lines = [];
+    const existingVars = existingContent ? parseEnvFile(existingContent) : {};
+    const processedKeys = new Set();
+    // If we have existing content, preserve its structure and comments
+    if (existingContent) {
+        const existingLines = existingContent.split("\n");
+        for (const line of existingLines) {
+            const trimmedLine = line.trim();
+            // Preserve comments and empty lines
+            if (!trimmedLine || trimmedLine.startsWith("#")) {
+                lines.push(line);
+                continue;
+            }
+            const equalIndex = trimmedLine.indexOf("=");
+            if (equalIndex === -1) {
+                lines.push(line); // Preserve invalid lines as-is
+                continue;
+            }
+            const key = trimmedLine.substring(0, equalIndex).trim();
+            if (Object.prototype.hasOwnProperty.call(envVars, key)) {
+                // Update existing variable
+                lines.push(`${key}=${envVars[key]}`);
+                processedKeys.add(key);
+            }
+            else {
+                // Preserve existing variable
+                lines.push(line);
+            }
+        }
+    }
+    // Add new variables that weren't in the existing file
+    const newVars = Object.keys(envVars).filter((key) => !processedKeys.has(key));
+    if (newVars.length > 0) {
+        if (lines.length > 0 && lines[lines.length - 1].trim() !== "") {
+            lines.push(""); // Add blank line before new variables
+        }
+        if (!existingContent) {
+            lines.push("# NeuroLink AI Provider Configuration");
+        }
+        for (const key of newVars) {
+            lines.push(`${key}=${envVars[key]}`);
+        }
+    }
+    return lines.join("\n") + (lines.length > 0 ? "\n" : "");
+}
+/**
+ * Update .env file with new environment variables
+ */
+export function updateEnvFile(newVars, envPath = ".env", createBackup = true) {
+    const result = {
+        backup: { existed: false },
+        updated: [],
+        added: [],
+        unchanged: [],
+    };
+    // Create backup if requested and file exists
+    if (createBackup) {
+        result.backup = backupEnvFile(envPath);
+    }
+    // Read existing content
+    let existingContent = "";
+    let existingVars = {};
+    if (fs.existsSync(envPath)) {
+        existingContent = fs.readFileSync(envPath, "utf8");
+        existingVars = parseEnvFile(existingContent);
+    }
+    // Categorize changes
+    for (const [key, value] of Object.entries(newVars)) {
+        if (Object.prototype.hasOwnProperty.call(existingVars, key)) {
+            if (existingVars[key] !== value) {
+                result.updated.push(key);
+            }
+            else {
+                result.unchanged.push(key);
+            }
+        }
+        else {
+            result.added.push(key);
+        }
+    }
+    // Generate new content
+    const newContent = generateEnvContent(newVars, existingContent);
+    // Write updated file
+    try {
+        fs.writeFileSync(envPath, newContent, "utf8");
+    }
+    catch (error) {
+        throw new Error(`Failed to write .env file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+/**
+ * Display environment file update summary
+ */
+export function displayEnvUpdateSummary(result, quiet = false) {
+    if (quiet) {
+        return;
+    }
+    if (result.backup.existed && result.backup.backupPath) {
+        console.log(chalk.gray(`💾 Created backup: ${result.backup.backupPath}`));
+    }
+    if (result.added.length > 0) {
+        console.log(chalk.green(`➕ Added ${result.added.length} new variables: ${result.added.join(", ")}`));
+    }
+    if (result.updated.length > 0) {
+        console.log(chalk.yellow(`🔄 Updated ${result.updated.length} existing variables: ${result.updated.join(", ")}`));
+    }
+    if (result.unchanged.length > 0) {
+        console.log(chalk.gray(`✓ ${result.unchanged.length} variables unchanged: ${result.unchanged.join(", ")}`));
+    }
+    const totalChanges = result.added.length + result.updated.length;
+    if (totalChanges > 0) {
+        console.log(chalk.blue(`📝 Environment file updated with ${totalChanges} changes`));
+    }
+    else {
+        console.log(chalk.gray("📝 No changes needed to environment file"));
+    }
+}
+/**
+ * Validate .env file format and required variables
+ */
+export function validateEnvFile(envPath = ".env", requiredVars = []) {
+    const result = {
+        valid: true,
+        errors: [],
+        warnings: [],
+        variables: {},
+    };
+    if (!fs.existsSync(envPath)) {
+        result.valid = false;
+        result.errors.push(`Environment file not found: ${envPath}`);
+        return result;
+    }
+    try {
+        const content = fs.readFileSync(envPath, "utf8");
+        result.variables = parseEnvFile(content);
+        // Check for required variables
+        for (const requiredVar of requiredVars) {
+            if (!Object.prototype.hasOwnProperty.call(result.variables, requiredVar) ||
+                !result.variables[requiredVar]) {
+                result.valid = false;
+                result.errors.push(`Missing required variable: ${requiredVar}`);
+            }
+        }
+        // Check for common formatting issues
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line || line.startsWith("#")) {
+                continue;
+            }
+            if (!line.includes("=")) {
+                result.warnings.push(`Line ${i + 1}: Invalid format (missing =)`);
+            }
+            else if (line.startsWith("=")) {
+                result.warnings.push(`Line ${i + 1}: Empty variable name`);
+            }
+        }
+    }
+    catch (error) {
+        result.valid = false;
+        result.errors.push(`Failed to read environment file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}

package/dist/cli/utils/interactive-setup.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Interactive Setup Utilities for NeuroLink CLI
+ *
+ * Provides interactive configuration wizard with provider selection,
+ * credential collection, testing, and environment file management.
+ */
+import { AIProviderName } from "../../lib/core/types.js";
+export interface ProviderConfig {
+    id: AIProviderName;
+    name: string;
+    description: string;
+    envVars: Array<{
+        key: string;
+        prompt: string;
+        secure?: boolean;
+        default?: string;
+        optional?: boolean;
+    }>;
+}
+export declare const PROVIDER_CONFIGS: ProviderConfig[];
+export interface SetupResult {
+    selectedProviders: AIProviderName[];
+    credentials: Record<string, string>;
+    envFileBackup?: string;
+    testResults: Array<{
+        provider: AIProviderName;
+        status: "working" | "failed";
+        error?: string;
+        responseTime?: number;
+    }>;
+}
+/**
+ * Run the interactive setup wizard
+ */
+export declare function runInteractiveSetup(quiet?: boolean): Promise<SetupResult>;
+/**
+ * Test provider connectivity using existing logic
+ */
+export declare function testProviderConnectivity(providers: AIProviderName[], quiet?: boolean): Promise<Array<{
+    provider: AIProviderName;
+    status: "working" | "failed";
+    error?: string;
+    responseTime?: number;
+}>>;
+/**
+ * Display setup summary
+ */
+export declare function displaySetupSummary(result: SetupResult, quiet?: boolean): void;