@juspay/neurolink 9.23.0 → 9.25.0

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

@@ -28,11 +28,21 @@ export declare class CLICommandFactory {
      * Auto-configures provider, model, and tools settings for video generation
      */
     private static configureVideoMode;
+    /**
+     * Helper method to configure options for PPT generation mode
+     * Auto-configures provider, model, and tools settings for presentation generation
+     */
+    private static configurePPTMode;
     /**
      * Helper method to handle video file output
      * Saves generated video to file when --videoOutput flag is provided
      */
     private static handleVideoOutput;
+    /**
+     * Helper method to handle PPT file output
+     * Displays PPT generation result info
+     */
+    private static handlePPTOutput;
     private static isValidTokenUsage;
     private static normalizeTokenUsage;
     private static formatAnalyticsForTextMode;
@@ -111,6 +121,30 @@ export declare class CLICommandFactory {
      * Execute provider status command
      */
     private static executeProviderStatus;
+    /**
+     * Handle stdin input for generate command
+     */
+    private static handleGenerateStdinInput;
+    /**
+     * Detect output mode (video, ppt, or text) based on CLI arguments
+     */
+    private static detectGenerateOutputMode;
+    /**
+     * Process context for generation command
+     */
+    private static processGenerateContext;
+    /**
+     * Build multimodal input from CLI arguments
+     */
+    private static buildGenerateMultimodalInput;
+    /**
+     * Build output configuration for generate request
+     */
+    private static buildGenerateOutputConfig;
+    /**
+     * Handle successful generation result
+     */
+    private static handleGenerateSuccess;
     /**
      * Execute the generate command
      */

package/dist/cli/factories/commandFactory.js

@@ -290,9 +290,9 @@ export class CLICommandFactory {
         // Video Generation options (Veo 3.1)
         outputMode: {
             type: "string",
-            choices: ["text", "video"],
+            choices: ["text", "video", "ppt"],
             default: "text",
-            description: "Output mode: 'text' for standard generation, 'video' for video generation",
+            description: "Output mode: 'text' for standard generation, 'video' for video, 'ppt' for presentation",
         },
         videoOutput: {
             type: "string",
@@ -322,6 +322,42 @@ export class CLICommandFactory {
             default: true,
             description: "Enable/disable audio generation in video",
         },
+        // PPT Generation options
+        pptPages: {
+            type: "number",
+            alias: "pages",
+            description: "Number of slides to generate (5-50, default: 10 when PPT mode is enabled)",
+        },
+        pptTheme: {
+            type: "string",
+            choices: ["modern", "corporate", "creative", "minimal", "dark"],
+            description: "Presentation theme/style (default: AI selects based on topic)",
+        },
+        pptAudience: {
+            type: "string",
+            choices: ["business", "students", "technical", "general"],
+            description: "Target audience (default: AI selects based on topic)",
+        },
+        pptTone: {
+            type: "string",
+            choices: ["professional", "casual", "educational", "persuasive"],
+            description: "Presentation tone (default: AI selects based on topic)",
+        },
+        pptOutput: {
+            type: "string",
+            alias: "po",
+            description: "Path to save generated PPTX file (e.g., ./output.pptx)",
+        },
+        pptAspectRatio: {
+            type: "string",
+            choices: ["16:9", "4:3"],
+            description: "Slide aspect ratio (default: 16:9 when PPT mode is enabled)",
+        },
+        pptNoImages: {
+            type: "boolean",
+            default: false,
+            description: "Disable AI image generation for slides",
+        },
         thinking: {
             alias: "think",
             type: "boolean",
@@ -528,6 +564,14 @@ export class CLICommandFactory {
             videoLength: argv.videoLength,
             videoAspectRatio: argv.videoAspectRatio,
             videoAudio: argv.videoAudio,
+            // PPT generation options
+            pptPages: argv.pptPages,
+            pptTheme: argv.pptTheme,
+            pptAudience: argv.pptAudience,
+            pptTone: argv.pptTone,
+            pptOutput: argv.pptOutput,
+            pptAspectRatio: argv.pptAspectRatio,
+            pptNoImages: argv.pptNoImages,
             // Extended thinking options for Claude and Gemini models
             thinking: argv.thinking,
             thinkingBudget: argv.thinkingBudget,
@@ -749,6 +793,50 @@ export class CLICommandFactory {
             });
         }
     }
+    /**
+     * Helper method to configure options for PPT generation mode
+     * Auto-configures provider, model, and tools settings for presentation generation
+     */
+    static configurePPTMode(enhancedOptions, argv, options) {
+        const userEnabledTools = !argv.disableTools; // Tools are enabled by default
+        enhancedOptions.disableTools = true;
+        // Auto-set provider for PPT generation if not explicitly specified
+        // PPT works best with Vertex or Google AI for content planning
+        if (!enhancedOptions.provider) {
+            enhancedOptions.provider = "vertex";
+            if (options.debug) {
+                logger.debug("Auto-setting provider to 'vertex' for PPT generation mode");
+            }
+        }
+        // Auto-set model if not explicitly specified
+        if (!enhancedOptions.model) {
+            // Use gemini-2.5-flash for fast, high-quality content planning
+            const modelAlias = "gemini-2.5-flash";
+            const resolvedModel = ModelResolver.resolveModel(modelAlias);
+            const fullModelId = resolvedModel?.id || "gemini-2.5-flash-001";
+            enhancedOptions.model = fullModelId;
+            if (options.debug) {
+                logger.debug(`Auto-setting model to '${fullModelId}' for PPT generation mode`);
+            }
+        }
+        // Warn user if they explicitly enabled tools
+        if (userEnabledTools && !options.quiet) {
+            logger.always(chalk.yellow("⚠️  Note: MCP tools are not supported in PPT generation mode and have been disabled."));
+        }
+        if (options.debug) {
+            logger.debug("PPT generation mode enabled (tools auto-disabled):", {
+                provider: enhancedOptions.provider,
+                model: enhancedOptions.model,
+                pages: enhancedOptions.pptPages,
+                theme: enhancedOptions.pptTheme,
+                audience: enhancedOptions.pptAudience,
+                tone: enhancedOptions.pptTone,
+                aspectRatio: enhancedOptions.pptAspectRatio,
+                noImages: enhancedOptions.pptNoImages,
+                outputPath: enhancedOptions.pptOutput,
+            });
+        }
+    }
     /**
      * Helper method to handle video file output
      * Saves generated video to file when --videoOutput flag is provided
@@ -775,14 +863,11 @@ export class CLICommandFactory {
             // Save video to file
             const saveResult = await saveVideoToFile(video, videoOutputPath);
             if (saveResult.success) {
-                if (!options.quiet) {
-                    // Format video info output
-                    const sizeInfo = formatVideoFileSize(saveResult.size);
-                    const metadataSummary = getVideoMetadataSummary(video);
-                    logger.always(chalk.green(`🎬 Video saved to: ${saveResult.path} (${sizeInfo})`));
-                    if (metadataSummary) {
-                        logger.always(chalk.gray(`   ${metadataSummary}`));
-                    }
+                const sizeInfo = formatVideoFileSize(saveResult.size);
+                const metadataSummary = getVideoMetadataSummary(video);
+                logger.always(chalk.green(`🎬 Video saved to: ${saveResult.path} (${sizeInfo})`));
+                if (!options.quiet && metadataSummary) {
+                    logger.always(chalk.gray(`   ${metadataSummary}`));
                 }
             }
             else {
@@ -793,6 +878,52 @@ export class CLICommandFactory {
             handleError(error, "Video Output");
         }
     }
+    /**
+     * Helper method to handle PPT file output
+     * Displays PPT generation result info
+     */
+    static async handlePPTOutput(result, options) {
+        // Extract PPT from result with proper type checking
+        if (!result || typeof result !== "object") {
+            return;
+        }
+        const generateResult = result;
+        const ppt = generateResult.ppt;
+        if (!ppt) {
+            // PPT not in result - either not PPT mode or generation failed
+            return;
+        }
+        try {
+            if (options.quiet) {
+                if (ppt.filePath) {
+                    logger.always(chalk.green(`📊 Presentation saved to: ${ppt.filePath}`));
+                }
+                else {
+                    logger.always(chalk.green("📊 Presentation generated successfully."));
+                }
+                if (ppt.totalSlides) {
+                    logger.always(chalk.white(`📄 Slides: ${ppt.totalSlides}`));
+                }
+                return;
+            }
+            logger.always(chalk.green("\n📊 Presentation Generated Successfully!"));
+            logger.always(chalk.gray("─".repeat(50)));
+            if (ppt.filePath) {
+                logger.always(chalk.white(`   📁 File: ${ppt.filePath}`));
+            }
+            if (ppt.totalSlides) {
+                logger.always(chalk.white(`   📄 Slides: ${ppt.totalSlides}`));
+            }
+            if (ppt.format) {
+                logger.always(chalk.white(`   📋 Format: ${ppt.format.toUpperCase()}`));
+            }
+            logger.always(chalk.gray("─".repeat(50)));
+            logger.always(chalk.cyan("💡 Tip: Open the file with PowerPoint or Google Slides to view."));
+        }
+        catch (error) {
+            handleError(error, "PPT Output");
+        }
+    }
     // Helper method to validate token usage data with fallback handling
     static isValidTokenUsage(tokens) {
         if (!tokens || typeof tokens !== "object" || tokens === null) {
@@ -916,8 +1047,9 @@ export class CLICommandFactory {
                     .example('$0 generate "Describe this video" --video path/to/video.mp4', "Analyze video content")
                     .example('$0 generate "Product showcase video" --image ./product.jpg --outputMode video --videoOutput ./output.mp4', "Generate video from image")
                     .example('$0 generate "Smooth camera movement" --image ./input.jpg --provider vertex --model veo-3.1-generate-001 --outputMode video --videoResolution 720p --videoLength 6 --videoAspectRatio 16:9 --videoOutput ./output.mp4', "Video generation with full options")
-                    .example('$0 generate "Explain AI" --provider anthropic --subscription-tier pro', "Use Anthropic with Pro subscription tier")
-                    .example('$0 generate "Deep analysis" --provider anthropic-subscription --subscription-tier max --auth-method oauth', "Use Anthropic with Max subscription and OAuth"));
+                    .example('$0 generate "AI in Healthcare" --pptPages 10', "Generate a PowerPoint presentation")
+                    .example('$0 generate "Company Q4 Results" --pptPages 15 --pptTheme corporate --pptAudience business', "Generate presentation with options")
+                    .example('$0 generate "Machine Learning 101" --pptTheme minimal --pptTone educational --pptNoImages', "Generate educational slides without AI images"));
             },
             handler: async (argv) => await CLICommandFactory.executeGenerate(argv),
         };
@@ -1449,72 +1581,196 @@ export class CLICommandFactory {
         }
     }
     /**
-     * Execute the generate command
+     * Handle stdin input for generate command
      */
-    static async executeGenerate(argv) {
-        // Handle stdin input if no input provided
+    static async handleGenerateStdinInput(argv) {
         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) {
+            const trimmedData = stdinData.trim();
+            if (!trimmedData) {
                 throw new Error("No input received from stdin");
             }
+            return trimmedData;
         }
         else if (!argv.input) {
             throw new Error('Input required. Use: neurolink generate "your prompt" or echo "prompt" | neurolink generate');
         }
-        const options = CLICommandFactory.processOptions(argv);
-        // Validate Anthropic subscription options if using Anthropic provider
-        this.validateAnthropicSubscriptionOptions(options);
-        // Determine if video generation mode is enabled
-        const isVideoMode = options.outputMode === "video";
+        return argv.input;
+    }
+    /**
+     * Detect output mode (video, ppt, or text) based on CLI arguments
+     */
+    static detectGenerateOutputMode(argv, options) {
+        const outputMode = options.outputMode;
+        const isVideoMode = outputMode === "video";
+        const hasPPTFlags = argv.pptPages !== undefined ||
+            argv.pptTheme !== undefined ||
+            argv.pptAudience !== undefined ||
+            argv.pptTone !== undefined ||
+            argv.pptOutput !== undefined ||
+            argv.pptAspectRatio !== undefined ||
+            argv.pptNoImages === true;
+        const hasVideoSignals = outputMode === "video" || argv.videoOutput !== undefined;
+        const hasPPTSignals = outputMode === "ppt" || hasPPTFlags;
+        if (hasVideoSignals && hasPPTSignals) {
+            throw new Error("Conflicting output mode signals detected. Use either video mode (--outputMode video, optionally with --videoOutput) or PPT mode (--outputMode ppt / --ppt* flags), not both.");
+        }
+        const isPPTMode = outputMode === "ppt" || hasPPTFlags;
         const spinnerMessage = isVideoMode
             ? "🎬 Generating video... (this may take 1-2 minutes)"
-            : "🤖 Generating text...";
+            : isPPTMode
+                ? "📊 Generating presentation... (this may take 2-5 minutes)"
+                : "🤖 Generating text...";
+        return { isVideoMode, isPPTMode, spinnerMessage };
+    }
+    /**
+     * Process context for generation command
+     */
+    static processGenerateContext(inputText, options) {
+        let processedInputText = inputText;
+        let contextMetadata;
+        if (options.context && options.contextConfig) {
+            const processedContextResult = ContextFactory.processContext(options.context, options.contextConfig);
+            if (processedContextResult.processedContext) {
+                processedInputText =
+                    processedContextResult.processedContext + processedInputText;
+            }
+            contextMetadata = {
+                ...ContextFactory.extractAnalyticsContext(options.context),
+                contextMode: processedContextResult.config.mode,
+                contextTruncated: processedContextResult.metadata.truncated,
+            };
+            if (options.debug) {
+                logger.debug("Context processed:", {
+                    mode: processedContextResult.config.mode,
+                    truncated: processedContextResult.metadata.truncated,
+                    processingTime: processedContextResult.metadata.processingTime,
+                });
+            }
+        }
+        return { inputText: processedInputText, contextMetadata };
+    }
+    /**
+     * Build multimodal input from CLI arguments
+     */
+    static buildGenerateMultimodalInput(inputText, argv) {
+        const imageBuffers = CLICommandFactory.processCliImages(argv.image);
+        const csvFiles = CLICommandFactory.processCliCSVFiles(argv.csv);
+        const pdfFiles = CLICommandFactory.processCliPDFFiles(argv.pdf);
+        const videoFiles = CLICommandFactory.processCliVideoFiles(argv.video);
+        const files = CLICommandFactory.processCliFiles(argv.file);
+        return {
+            text: inputText,
+            ...(imageBuffers && { images: imageBuffers }),
+            ...(csvFiles && { csvFiles }),
+            ...(pdfFiles && { pdfFiles }),
+            ...(videoFiles && { videoFiles }),
+            ...(files && { files }),
+        };
+    }
+    /**
+     * Build output configuration for generate request
+     */
+    static buildGenerateOutputConfig(isVideoMode, isPPTMode, enhancedOptions) {
+        if (isVideoMode) {
+            return {
+                mode: "video",
+                video: {
+                    resolution: enhancedOptions.videoResolution,
+                    length: enhancedOptions.videoLength,
+                    aspectRatio: enhancedOptions.videoAspectRatio,
+                    audio: enhancedOptions.videoAudio,
+                },
+            };
+        }
+        if (isPPTMode) {
+            return {
+                mode: "ppt",
+                ppt: {
+                    pages: enhancedOptions.pptPages || 10,
+                    theme: enhancedOptions.pptTheme,
+                    audience: enhancedOptions.pptAudience,
+                    tone: enhancedOptions.pptTone,
+                    aspectRatio: enhancedOptions.pptAspectRatio || "16:9",
+                    generateAIImages: !enhancedOptions.pptNoImages,
+                    outputPath: enhancedOptions.pptOutput,
+                },
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Handle successful generation result
+     */
+    static async handleGenerateSuccess(result, options, isVideoMode, isPPTMode, spinner) {
+        const genResult = result;
+        if (spinner) {
+            if (isVideoMode) {
+                spinner.succeed(chalk.green("✅ Video generated successfully!"));
+            }
+            else if (isPPTMode) {
+                spinner.succeed(chalk.green("✅ Presentation generated successfully!"));
+            }
+            else {
+                spinner.succeed(chalk.green("✅ Text generated successfully!"));
+            }
+        }
+        if (!options.quiet) {
+            const providerInfo = genResult.provider || "auto";
+            const modelInfo = genResult.model || "default";
+            logger.always(chalk.gray(`🔧 Provider: ${providerInfo} | Model: ${modelInfo}`));
+        }
+        if (!isVideoMode && !isPPTMode) {
+            CLICommandFactory.handleOutput(genResult, options);
+        }
+        await CLICommandFactory.handleTTSOutput(genResult, options);
+        await CLICommandFactory.handleVideoOutput(genResult, options);
+        await CLICommandFactory.handlePPTOutput(genResult, options);
+        if (options.debug) {
+            logger.debug("\n" + chalk.yellow("Debug Information:"));
+            logger.debug("Provider:", genResult.provider);
+            logger.debug("Model:", genResult.model);
+            if (genResult.analytics) {
+                logger.debug("Analytics:", JSON.stringify(genResult.analytics, null, 2));
+            }
+            if (genResult.evaluation) {
+                logger.debug("Evaluation:", JSON.stringify(genResult.evaluation, null, 2));
+            }
+        }
+        if (!globalSession.getCurrentSessionId()) {
+            await CLICommandFactory.flushLangfuseTraces();
+            process.exit(0);
+        }
+    }
+    /**
+     * Execute the generate command
+     */
+    static async executeGenerate(argv) {
+        // Handle stdin input
+        const rawInput = await CLICommandFactory.handleGenerateStdinInput(argv);
+        argv.input = rawInput;
+        const options = CLICommandFactory.processOptions(argv);
+        // Detect output mode
+        const { isVideoMode, isPPTMode, spinnerMessage } = CLICommandFactory.detectGenerateOutputMode(argv, options);
         const spinner = argv.quiet ? null : ora(spinnerMessage).start();
         try {
             // Add delay if specified
             if (options.delay) {
                 await new Promise((resolve) => setTimeout(resolve, options.delay));
             }
-            // Process context if provided
-            let inputText = argv.input;
-            let contextMetadata;
-            if (options.context && options.contextConfig) {
-                const processedContextResult = ContextFactory.processContext(options.context, options.contextConfig);
-                // Integrate context into prompt if configured
-                if (processedContextResult.processedContext) {
-                    inputText = processedContextResult.processedContext + inputText;
-                }
-                // Add context metadata for analytics
-                contextMetadata = {
-                    ...ContextFactory.extractAnalyticsContext(options.context),
-                    contextMode: processedContextResult.config.mode,
-                    contextTruncated: processedContextResult.metadata.truncated,
-                };
-                if (options.debug) {
-                    logger.debug("Context processed:", {
-                        mode: processedContextResult.config.mode,
-                        truncated: processedContextResult.metadata.truncated,
-                        processingTime: processedContextResult.metadata.processingTime,
-                    });
-                }
-            }
+            // Process context
+            const { inputText, contextMetadata } = CLICommandFactory.processGenerateContext(rawInput, options);
             // Handle dry-run mode for testing
             if (options.dryRun) {
                 const mockResult = {
                     content: "Mock response for testing purposes",
                     provider: options.provider || "auto",
                     model: options.model || "test-model",
-                    usage: {
-                        input: 10,
-                        output: 15,
-                        total: 25,
-                    },
+                    usage: { input: 10, output: 15, total: 25 },
                     responseTime: 150,
                     analytics: options.enableAnalytics
                         ? {
@@ -1552,7 +1808,9 @@ export class CLICommandFactory {
                     await CLICommandFactory.flushLangfuseTraces();
                     process.exit(0);
                 }
+                return;
             }
+            // Initialize SDK and session
             const sdk = globalSession.getOrCreateNeuroLink();
             const sessionVariables = globalSession.getSessionVariables();
             const enhancedOptions = { ...options, ...sessionVariables };
@@ -1566,24 +1824,17 @@ export class CLICommandFactory {
                     toolsEnabled: !options.disableTools,
                 });
             }
-            // Video generation doesn't support tools, so auto-disable them
+            // Configure mode-specific options
             if (isVideoMode) {
                 CLICommandFactory.configureVideoMode(enhancedOptions, argv, options);
             }
-            // Process CLI multimodal inputs
-            const imageBuffers = CLICommandFactory.processCliImages(argv.image);
-            const csvFiles = CLICommandFactory.processCliCSVFiles(argv.csv);
-            const pdfFiles = CLICommandFactory.processCliPDFFiles(argv.pdf);
-            const videoFiles = CLICommandFactory.processCliVideoFiles(argv.video);
-            const files = CLICommandFactory.processCliFiles(argv.file);
-            const generateInput = {
-                text: inputText,
-                ...(imageBuffers && { images: imageBuffers }),
-                ...(csvFiles && { csvFiles }),
-                ...(pdfFiles && { pdfFiles }),
-                ...(videoFiles && { videoFiles }),
-                ...(files && { files }),
-            };
+            if (isPPTMode) {
+                CLICommandFactory.configurePPTMode(enhancedOptions, argv, options);
+            }
+            // Build multimodal input and output configuration
+            const generateInput = CLICommandFactory.buildGenerateMultimodalInput(inputText, argv);
+            const outputConfig = CLICommandFactory.buildGenerateOutputConfig(isVideoMode, isPPTMode, enhancedOptions);
+            // Execute generation
             const result = await sdk.generate({
                 input: generateInput,
                 csvOptions: {
@@ -1596,18 +1847,7 @@ export class CLICommandFactory {
                     format: argv.videoFormat,
                     transcribeAudio: argv.transcribeAudio,
                 },
-                // Video generation output configuration
-                output: isVideoMode
-                    ? {
-                        mode: "video",
-                        video: {
-                            resolution: enhancedOptions.videoResolution,
-                            length: enhancedOptions.videoLength,
-                            aspectRatio: enhancedOptions.videoAspectRatio,
-                            audio: enhancedOptions.videoAudio,
-                        },
-                    }
-                    : undefined,
+                output: outputConfig,
                 provider: enhancedOptions.provider,
                 model: enhancedOptions.model,
                 temperature: enhancedOptions.temperature,
@@ -1656,43 +1896,8 @@ export class CLICommandFactory {
                     }
                     : undefined,
             });
-            if (spinner) {
-                if (isVideoMode) {
-                    spinner.succeed(chalk.green("✅ Video generated successfully!"));
-                }
-                else {
-                    spinner.succeed(chalk.green("✅ Text generated successfully!"));
-                }
-            }
-            // Display provider and model info by default (unless quiet mode)
-            if (!options.quiet) {
-                const providerInfo = result.provider || "auto";
-                const modelInfo = result.model || "default";
-                logger.always(chalk.gray(`🔧 Provider: ${providerInfo} | Model: ${modelInfo}`));
-            }
-            // Handle output with universal formatting (for text mode)
-            if (!isVideoMode) {
-                CLICommandFactory.handleOutput(result, options);
-            }
-            // Handle TTS audio file output if --tts-output is provided
-            await CLICommandFactory.handleTTSOutput(result, options);
-            // Handle video file output if --videoOutput is provided
-            await CLICommandFactory.handleVideoOutput(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));
-                }
-            }
-            if (!globalSession.getCurrentSessionId()) {
-                await CLICommandFactory.flushLangfuseTraces();
-                process.exit(0);
-            }
+            // Handle successful result
+            await CLICommandFactory.handleGenerateSuccess(result, options, isVideoMode, isPPTMode, spinner);
         }
         catch (error) {
             if (spinner) {
@@ -2141,7 +2346,7 @@ export class CLICommandFactory {
         await CLICommandFactory.handleStdinInput(argv);
         const options = CLICommandFactory.processOptions(argv);
         // Validate Anthropic subscription options if using Anthropic provider
-        this.validateAnthropicSubscriptionOptions(options);
+        CLICommandFactory.validateAnthropicSubscriptionOptions(options);
         if (!options.quiet) {
             logger.always(chalk.blue("🔄 Streaming..."));
         }

package/dist/cli/parser.js

@@ -10,9 +10,8 @@ import { SetupCommandFactory } from "./factories/setupCommandFactory.js";
 import { ServerCommandFactory } from "./commands/server.js";
 import { ServeCommandFactory } from "./commands/serve.js";
 import { ragCommand } from "./commands/rag.js";
-import { DocsCommandFactory } from "./commands/docs.js";
-import { AuthCommandFactory } from "./factories/authCommandFactory.js";
-import { WorkflowCommandFactory } from "./commands/workflow.js";
+import { ObservabilityCommandFactory } from "./commands/observability.js";
+import { TelemetryCommandFactory } from "./commands/telemetry.js";
 // Enhanced CLI with Professional UX
 export function initializeCliParser() {
     return (yargs(hideBin(process.argv))
@@ -176,11 +175,9 @@ export function initializeCliParser() {
         .command(ServeCommandFactory.createServeCommands())
         // RAG Document Processing Commands
         .command(ragCommand)
-        // Docs MCP Server Command
-        .command(DocsCommandFactory.createDocsCommand())
-        // Auth Commands - Using AuthCommandFactory
-        .command(AuthCommandFactory.createAuthCommands())
-        // Workflow Commands
-        .command(WorkflowCommandFactory.createWorkflowCommands())); // Close the main return statement
+        // Observability Commands
+        .command(ObservabilityCommandFactory.createObservabilityCommands())
+        // Telemetry Commands
+        .command(TelemetryCommandFactory.createTelemetryCommands())); // Close the main return statement
 }
 //# sourceMappingURL=parser.js.map

package/dist/cli/utils/formatters.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared CLI formatting utilities
+ *
+ * Common formatting functions used across CLI command modules.
+ */
+/**
+ * Format a table row with padding
+ */
+export declare function formatRow(label: string, value: string, width?: number): string;
+/**
+ * Format currency value
+ */
+export declare function formatCost(cost: number, currency?: string): string;