@juspay/neurolink 9.14.0 → 9.16.0

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

@@ -16,6 +16,7 @@ import ora from "ora";
 import { logger } from "../../lib/utils/logger.js";
 import { getTopModelChoices } from "../../lib/utils/modelChoices.js";
 import { AIProviderName } from "../../lib/types/index.js";
+import { maskCredential } from "../utils/maskCredential.js";
 export async function handleAnthropicSetup(argv) {
     try {
         const options = {
@@ -365,20 +366,6 @@ async function updateEnvFile(config) {
         throw error;
     }
 }
-/**
- * Mask API key for display
- */
-function maskCredential(credential) {
-    if (!credential || credential.length < 8) {
-        return "****";
-    }
-    const knownPrefixes = ["sk-ant-"];
-    const prefix = knownPrefixes.find((p) => credential.startsWith(p)) ??
-        credential.slice(0, 3);
-    const end = credential.slice(-4);
-    const stars = "*".repeat(Math.max(4, credential.length - prefix.length - 4));
-    return `${prefix}${stars}${end}`;
-}
 /**
  * Show usage example
  */

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

@@ -16,6 +16,7 @@ import { logger } from "../../lib/utils/logger.js";
 import { updateEnvFile as updateEnvFileShared, displayEnvUpdateSummary, } from "../utils/envManager.js";
 import { getTopModelChoices } from "../../lib/utils/modelChoices.js";
 import { AIProviderName } from "../../lib/types/index.js";
+import { maskCredential } from "../utils/maskCredential.js";
 export async function handleAzureSetup(argv) {
     try {
         const options = {
@@ -372,18 +373,6 @@ async function updateEnvFileWithConfig(config) {
         throw error;
     }
 }
-/**
- * Mask API key for display
- */
-function maskCredential(credential) {
-    if (!credential || credential.length < 8) {
-        return "****";
-    }
-    const start = credential.slice(0, 4);
-    const end = credential.slice(-4);
-    const middle = "*".repeat(Math.max(4, credential.length - 8));
-    return `${start}${middle}${end}`;
-}
 /**
  * Show usage example
  */

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

@@ -15,6 +15,7 @@ import { logger } from "../../lib/utils/logger.js";
 import { updateEnvFile as envUpdate } from "../utils/envManager.js";
 import { getTopModelChoices } from "../../lib/utils/modelChoices.js";
 import { AIProviderName } from "../../lib/types/index.js";
+import { maskCredential } from "../utils/maskCredential.js";
 export async function handleBedrockSetup(argv) {
     try {
         const options = {
@@ -453,13 +454,4 @@ function displayUsageExample() {
     logger.always(chalk.green("🚀 You can now use AWS Bedrock with the NeuroLink CLI:"));
     logger.always(chalk.cyan("   pnpm cli generate 'Hello from Bedrock!' --provider bedrock"));
 }
-function maskCredential(credential) {
-    if (!credential || credential.length < 8) {
-        return "****";
-    }
-    const start = credential.slice(0, 4);
-    const end = credential.slice(-4);
-    const middle = "*".repeat(Math.max(4, credential.length - 8));
-    return `${start}${middle}${end}`;
-}
 //# sourceMappingURL=setup-bedrock.js.map

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

@@ -17,6 +17,7 @@ import { GoogleAIModels } from "../../lib/constants/enums.js";
 import { updateEnvFile as updateEnvFileManager, displayEnvUpdateSummary, } from "../utils/envManager.js";
 import { getTopModelChoices } from "../../lib/utils/modelChoices.js";
 import { AIProviderName } from "../../lib/types/index.js";
+import { maskCredential } from "../utils/maskCredential.js";
 /**
  * Get the runtime default model that matches the provider implementation
  */
@@ -326,18 +327,6 @@ async function updateEnvFile(config) {
         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
  */

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

@@ -16,6 +16,7 @@ import ora from "ora";
 import { logger } from "../../lib/utils/logger.js";
 import { getTopModelChoices } from "../../lib/utils/modelChoices.js";
 import { AIProviderName } from "../../lib/types/index.js";
+import { maskCredential } from "../utils/maskCredential.js";
 export async function handleOpenAISetup(argv) {
     try {
         const options = {
@@ -358,20 +359,6 @@ async function updateEnvFile(config) {
         throw error;
     }
 }
-/**
- * Mask API key for display
- */
-function maskCredential(credential) {
-    if (!credential || credential.length < 8) {
-        return "****";
-    }
-    const knownPrefixes = ["sk-"];
-    const prefix = knownPrefixes.find((p) => credential.startsWith(p)) ??
-        credential.slice(0, 3);
-    const end = credential.slice(-4);
-    const stars = "*".repeat(Math.max(4, credential.length - prefix.length - 4));
-    return `${prefix}${stars}${end}`;
-}
 /**
  * Show usage example
  */

package/dist/cli/commands/workflow.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Workflow CLI Commands for NeuroLink
+ *
+ * Implements commands for workflow management and execution:
+ * - neurolink workflow list     - List available predefined workflows
+ * - neurolink workflow info <name> - Show details of a workflow
+ * - neurolink workflow execute <name> <prompt> - Execute a workflow
+ */
+import type { CommandModule } from "yargs";
+/**
+ * Workflow CLI command factory
+ */
+export declare class WorkflowCommandFactory {
+    static createWorkflowCommands(): CommandModule;
+    /**
+     * List all predefined workflows
+     */
+    private static executeList;
+    /**
+     * Show details of a specific workflow
+     */
+    private static executeInfo;
+    /**
+     * Execute a workflow
+     */
+    private static executeWorkflow;
+}

package/dist/cli/commands/workflow.js

@@ -0,0 +1,216 @@
+/**
+ * Workflow CLI Commands for NeuroLink
+ *
+ * Implements commands for workflow management and execution:
+ * - neurolink workflow list     - List available predefined workflows
+ * - neurolink workflow info <name> - Show details of a workflow
+ * - neurolink workflow execute <name> <prompt> - Execute a workflow
+ */
+import chalk from "chalk";
+import ora from "ora";
+/**
+ * All predefined workflow configs keyed by their id.
+ * Loaded lazily via dynamic import to avoid circular deps.
+ */
+async function loadPredefinedWorkflows() {
+    const [consensus, fallback, adaptive, multiJudge] = await Promise.all([
+        import("../../lib/workflow/workflows/consensusWorkflow.js"),
+        import("../../lib/workflow/workflows/fallbackWorkflow.js"),
+        import("../../lib/workflow/workflows/adaptiveWorkflow.js"),
+        import("../../lib/workflow/workflows/multiJudgeWorkflow.js"),
+    ]);
+    const configs = [
+        consensus.CONSENSUS_3_WORKFLOW,
+        consensus.CONSENSUS_3_FAST_WORKFLOW,
+        fallback.FAST_FALLBACK_WORKFLOW,
+        fallback.AGGRESSIVE_FALLBACK_WORKFLOW,
+        adaptive.QUALITY_MAX_WORKFLOW,
+        adaptive.SPEED_FIRST_WORKFLOW,
+        adaptive.BALANCED_ADAPTIVE_WORKFLOW,
+        multiJudge.MULTI_JUDGE_5_WORKFLOW,
+        multiJudge.MULTI_JUDGE_3_WORKFLOW,
+    ];
+    const map = {};
+    for (const cfg of configs) {
+        map[cfg.id] = cfg;
+    }
+    return map;
+}
+/**
+ * Workflow CLI command factory
+ */
+export class WorkflowCommandFactory {
+    static createWorkflowCommands() {
+        return {
+            command: "workflow <subcommand>",
+            describe: "Manage and execute AI workflows",
+            builder: (yargs) => {
+                return yargs
+                    .command("list", "List available predefined workflows", (y) => y, async () => {
+                    await WorkflowCommandFactory.executeList();
+                })
+                    .command("info <name>", "Show details of a workflow", (y) => y.positional("name", {
+                    type: "string",
+                    description: "Workflow name/id",
+                    demandOption: true,
+                }), async (argv) => {
+                    await WorkflowCommandFactory.executeInfo(argv);
+                })
+                    .command("execute <name> <prompt>", "Execute a workflow with a prompt", (y) => y
+                    .positional("name", {
+                    type: "string",
+                    description: "Workflow name/id",
+                    demandOption: true,
+                })
+                    .positional("prompt", {
+                    type: "string",
+                    description: "Prompt to send to the workflow",
+                    demandOption: true,
+                })
+                    .option("provider", {
+                    type: "string",
+                    description: "Override AI provider",
+                })
+                    .option("model", {
+                    type: "string",
+                    description: "Override model name",
+                })
+                    .option("timeout", {
+                    type: "number",
+                    description: "Execution timeout in milliseconds",
+                })
+                    .option("verbose", {
+                    type: "boolean",
+                    description: "Enable verbose output",
+                    default: false,
+                }), async (argv) => {
+                    await WorkflowCommandFactory.executeWorkflow(argv);
+                })
+                    .demandCommand(1, "Please specify a workflow subcommand");
+            },
+            handler: () => { },
+        };
+    }
+    /**
+     * List all predefined workflows
+     */
+    static async executeList() {
+        const workflows = await loadPredefinedWorkflows();
+        const configs = Object.values(workflows);
+        console.info(chalk.bold("\nAvailable Workflows:\n"));
+        for (const cfg of configs) {
+            const tags = cfg.tags?.join(", ") || "";
+            console.info(`  ${chalk.cyan(cfg.id.padEnd(24))} ${chalk.white(cfg.name)}`);
+            console.info(`  ${"".padEnd(24)} ${chalk.gray(cfg.description || "")}`);
+            if (tags) {
+                console.info(`  ${"".padEnd(24)} ${chalk.gray(`Tags: ${tags}`)}`);
+            }
+            console.info();
+        }
+        console.info(chalk.gray(`Total: ${configs.length} workflows`));
+    }
+    /**
+     * Show details of a specific workflow
+     */
+    static async executeInfo(argv) {
+        const workflows = await loadPredefinedWorkflows();
+        const cfg = workflows[argv.name];
+        if (!cfg) {
+            console.error(chalk.red(`Workflow "${argv.name}" not found.`));
+            console.info(chalk.gray(`Available: ${Object.keys(workflows).join(", ")}`));
+            process.exitCode = 1;
+            return;
+        }
+        console.info(chalk.bold(`\nWorkflow: ${cfg.name}\n`));
+        console.info(`  ID:          ${cfg.id}`);
+        console.info(`  Type:        ${cfg.type}`);
+        console.info(`  Version:     ${cfg.version || "n/a"}`);
+        console.info(`  Description: ${cfg.description || "n/a"}`);
+        if (cfg.models && cfg.models.length > 0) {
+            console.info(`\n  Models:`);
+            for (const m of cfg.models) {
+                console.info(`    - ${chalk.cyan(m.label || m.model)} (${m.provider})`);
+            }
+        }
+        if (cfg.modelGroups && cfg.modelGroups.length > 0) {
+            console.info(`\n  Model Groups:`);
+            for (const group of cfg.modelGroups) {
+                console.info(`    ${chalk.cyan(group.id)}:`);
+                for (const m of group.models) {
+                    console.info(`      - ${m.label || m.model} (${m.provider})`);
+                }
+            }
+        }
+        if (cfg.judge) {
+            console.info(`\n  Judge: ${cfg.judge.model} (${cfg.judge.provider})`);
+            if (cfg.judge.criteria) {
+                console.info(`  Criteria: ${cfg.judge.criteria.join(", ")}`);
+            }
+        }
+        if (cfg.execution) {
+            console.info(`\n  Execution:`);
+            if (cfg.execution.timeout) {
+                console.info(`    Timeout:     ${cfg.execution.timeout}ms`);
+            }
+            if (cfg.execution.parallelism) {
+                console.info(`    Parallelism: ${cfg.execution.parallelism}`);
+            }
+            if (cfg.execution.minResponses) {
+                console.info(`    Min Responses: ${cfg.execution.minResponses}`);
+            }
+        }
+        if (cfg.tags && cfg.tags.length > 0) {
+            console.info(`\n  Tags: ${cfg.tags.join(", ")}`);
+        }
+    }
+    /**
+     * Execute a workflow
+     */
+    static async executeWorkflow(argv) {
+        const workflows = await loadPredefinedWorkflows();
+        let cfg = workflows[argv.name];
+        if (!cfg) {
+            console.error(chalk.red(`Workflow "${argv.name}" not found.`));
+            console.info(chalk.gray(`Available: ${Object.keys(workflows).join(", ")}`));
+            process.exitCode = 1;
+            return;
+        }
+        // Apply provider/model overrides if specified
+        if (argv.provider || argv.model) {
+            cfg = {
+                ...cfg,
+                models: cfg.models?.map((m) => ({
+                    ...m,
+                    provider: argv.provider || m.provider,
+                    model: argv.model || m.model,
+                })),
+            };
+        }
+        const spinner = ora("Executing workflow...").start();
+        try {
+            const { runWorkflow } = await import("../../lib/workflow/core/workflowRunner.js");
+            const result = await runWorkflow(cfg, {
+                prompt: argv.prompt,
+                timeout: argv.timeout,
+                verbose: argv.verbose,
+            });
+            spinner.stop();
+            if (result.content) {
+                console.info(result.content);
+            }
+            else {
+                console.info(chalk.yellow("Workflow completed but produced no content."));
+                if (result.reasoning) {
+                    console.info(chalk.gray(`Reasoning: ${result.reasoning}`));
+                }
+            }
+        }
+        catch (error) {
+            spinner.stop();
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`Workflow execution failed: ${msg}`));
+            process.exitCode = 1;
+        }
+    }
+}
+//# sourceMappingURL=workflow.js.map

package/dist/cli/factories/authCommandFactory.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Auth Command Factory for NeuroLink
+ *
+ * Creates the unified authentication command with subcommands for AI providers.
+ * Follows the MCP command pattern with subcommands: login, logout, status, refresh.
+ *
+ * Supported providers:
+ * - Anthropic (API key + OAuth for Claude subscription plans)
+ */
+import type { CommandModule } from "yargs";
+/**
+ * Auth command arguments interface
+ */
+export interface AuthCommandArgs {
+    provider?: string;
+    method?: "api-key" | "oauth" | "create-api-key";
+    format?: "text" | "json";
+    quiet?: boolean;
+    debug?: boolean;
+    nonInteractive?: boolean;
+}
+/**
+ * Auth Command Factory
+ *
+ * Creates the main auth command with subcommands:
+ * - login: Authenticate with a provider
+ * - logout: Clear stored credentials
+ * - status: Show authentication status
+ * - refresh: Manually refresh OAuth tokens
+ */
+export declare class AuthCommandFactory {
+    /**
+     * Create the main auth command with subcommands
+     */
+    static createAuthCommands(): CommandModule;
+    /**
+     * Build options for login subcommand
+     */
+    private static buildLoginOptions;
+    /**
+     * Build options for logout subcommand
+     */
+    private static buildLogoutOptions;
+    /**
+     * Build options for status subcommand
+     */
+    private static buildStatusOptions;
+    /**
+     * Build options for refresh subcommand
+     */
+    private static buildRefreshOptions;
+}

package/dist/cli/factories/authCommandFactory.js

@@ -0,0 +1,146 @@
+/**
+ * Auth Command Factory for NeuroLink
+ *
+ * Creates the unified authentication command with subcommands for AI providers.
+ * Follows the MCP command pattern with subcommands: login, logout, status, refresh.
+ *
+ * Supported providers:
+ * - Anthropic (API key + OAuth for Claude subscription plans)
+ */
+/**
+ * Supported providers for authentication
+ */
+const SUPPORTED_PROVIDERS = ["anthropic"];
+/**
+ * Auth Command Factory
+ *
+ * Creates the main auth command with subcommands:
+ * - login: Authenticate with a provider
+ * - logout: Clear stored credentials
+ * - status: Show authentication status
+ * - refresh: Manually refresh OAuth tokens
+ */
+export class AuthCommandFactory {
+    /**
+     * Create the main auth command with subcommands
+     */
+    static createAuthCommands() {
+        return {
+            command: "auth <subcommand>",
+            describe: "Manage authentication with AI providers (API key or OAuth)",
+            builder: (yargs) => {
+                return yargs
+                    .command("login <provider>", "Authenticate with an AI provider", (yargs) => this.buildLoginOptions(yargs), async (argv) => {
+                    const { handleLogin } = await import("../commands/auth.js");
+                    await handleLogin(argv);
+                })
+                    .command("logout <provider>", "Clear stored credentials for a provider", (yargs) => this.buildLogoutOptions(yargs), async (argv) => {
+                    const { handleLogout } = await import("../commands/auth.js");
+                    await handleLogout(argv);
+                })
+                    .command("status [provider]", "Show authentication status for provider(s)", (yargs) => this.buildStatusOptions(yargs), async (argv) => {
+                    const { handleStatus } = await import("../commands/auth.js");
+                    await handleStatus(argv);
+                })
+                    .command("refresh <provider>", "Manually refresh OAuth tokens for a provider", (yargs) => this.buildRefreshOptions(yargs), async (argv) => {
+                    const { handleRefresh } = await import("../commands/auth.js");
+                    await handleRefresh(argv);
+                })
+                    .option("format", {
+                    choices: ["text", "json"],
+                    default: "text",
+                    description: "Output format",
+                })
+                    .option("quiet", {
+                    type: "boolean",
+                    alias: "q",
+                    default: false,
+                    description: "Suppress non-essential output",
+                })
+                    .option("debug", {
+                    type: "boolean",
+                    default: false,
+                    description: "Enable debug output",
+                })
+                    .demandCommand(1, "Please specify an auth subcommand")
+                    .example("$0 auth login anthropic", "Authenticate with Anthropic")
+                    .example("$0 auth login anthropic --method create-api-key", "Create API key via OAuth (Claude Pro/Max - Recommended)")
+                    .example("$0 auth status", "Show authentication status for all providers")
+                    .example("$0 auth logout anthropic", "Clear Anthropic stored credentials")
+                    .example("$0 auth refresh anthropic", "Refresh Anthropic OAuth tokens")
+                    .help();
+            },
+            handler: () => {
+                // No-op handler as subcommands handle everything
+            },
+        };
+    }
+    /**
+     * Build options for login subcommand
+     */
+    static buildLoginOptions(yargs) {
+        return yargs
+            .positional("provider", {
+            type: "string",
+            description: "AI provider to authenticate with",
+            choices: SUPPORTED_PROVIDERS,
+            demandOption: true,
+        })
+            .option("method", {
+            type: "string",
+            alias: "m",
+            description: "Authentication method",
+            choices: ["api-key", "oauth", "create-api-key"],
+        })
+            .option("non-interactive", {
+            type: "boolean",
+            description: "Skip interactive prompts (requires environment variables)",
+            default: false,
+        })
+            .example("$0 auth login anthropic", "Interactive authentication (choose method)")
+            .example("$0 auth login anthropic --method api-key", "API key authentication")
+            .example("$0 auth login anthropic --method create-api-key", "Create API key via OAuth (Claude Pro/Max)")
+            .example("$0 auth login anthropic --method oauth", "Direct OAuth (experimental)");
+    }
+    /**
+     * Build options for logout subcommand
+     */
+    static buildLogoutOptions(yargs) {
+        return yargs
+            .positional("provider", {
+            type: "string",
+            description: "AI provider to log out from",
+            choices: SUPPORTED_PROVIDERS,
+            demandOption: true,
+        })
+            .example("$0 auth logout anthropic", "Clear all Anthropic credentials");
+    }
+    /**
+     * Build options for status subcommand
+     */
+    static buildStatusOptions(yargs) {
+        return yargs
+            .positional("provider", {
+            type: "string",
+            description: "AI provider to check (optional, shows all if not specified)",
+            choices: SUPPORTED_PROVIDERS,
+        })
+            .example("$0 auth status", "Show status for all configured providers")
+            .example("$0 auth status anthropic", "Show Anthropic authentication status")
+            .example("$0 auth status --format json", "Show status in JSON format");
+    }
+    /**
+     * Build options for refresh subcommand
+     */
+    static buildRefreshOptions(yargs) {
+        return yargs
+            .positional("provider", {
+            type: "string",
+            description: "AI provider to refresh tokens for",
+            choices: SUPPORTED_PROVIDERS,
+            demandOption: true,
+        })
+            .example("$0 auth refresh anthropic", "Refresh Anthropic OAuth tokens");
+    }
+}
+//# sourceMappingURL=authCommandFactory.js.map

package/dist/cli/factories/commandFactory.d.ts

@@ -11,6 +11,12 @@ export declare class CLICommandFactory {
     private static processCliFiles;
     private static processCliVideoFiles;
     private static processOptions;
+    /**
+     * Validate Anthropic subscription options
+     * Ensures subscription tier is provided when using anthropic-subscription provider
+     * or when oauth auth method is selected
+     */
+    private static validateAnthropicSubscriptionOptions;
     private static handleOutput;
     /**
      * Helper method to handle TTS audio file output