@juspay/neurolink 8.31.2 → 8.32.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [8.32.0](https://github.com/juspay/neurolink/compare/v8.31.3...v8.32.0) (2026-01-05)
+
+### Features
+
+- **(cli):** Add video generation to CLI ([8e7f0cf](https://github.com/juspay/neurolink/commit/8e7f0cfd983f6c09aa3eaf3bdb09d9c22c0d5b02))
+
+## [8.31.3](https://github.com/juspay/neurolink/compare/v8.31.2...v8.31.3) (2026-01-05)
+
+### Bug Fixes
+
+- **(csv):** standardize rowCount to exclude empty lines across all formats (CSV-025) ([c898521](https://github.com/juspay/neurolink/commit/c8985212ff6bb43a6cefbf7a5551ed603b32bc55)), closes [#390](https://github.com/juspay/neurolink/issues/390)
+
 ## [8.31.2](https://github.com/juspay/neurolink/compare/v8.31.1...v8.31.2) (2026-01-05)
 
 ### Bug Fixes

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

@@ -17,6 +17,16 @@ export declare class CLICommandFactory {
      * Saves audio to file when --tts-output flag is provided
      */
     private static handleTTSOutput;
+    /**
+     * Helper method to configure options for video generation mode
+     * Auto-configures provider, model, and tools settings for video generation
+     */
+    private static configureVideoMode;
+    /**
+     * Helper method to handle video file output
+     * Saves generated video to file when --videoOutput flag is provided
+     */
+    private static handleVideoOutput;
     private static isValidTokenUsage;
     private static normalizeTokenUsage;
     private static formatAnalyticsForTextMode;

package/dist/cli/factories/commandFactory.js

@@ -14,12 +14,14 @@ import { ModelsCommandFactory } from "../commands/models.js";
 import { MCPCommandFactory } from "../commands/mcp.js";
 import { OllamaCommandFactory } from "./ollamaCommandFactory.js";
 import { SageMakerCommandFactory } from "./sagemakerCommandFactory.js";
+import { ModelResolver } from "../../lib/models/modelResolver.js";
 import ora from "ora";
 import chalk from "chalk";
 import { logger } from "../../lib/utils/logger.js";
 import { handleSetup } from "../commands/setup.js";
 import { checkRedisAvailability } from "../../lib/utils/conversationMemoryUtils.js";
 import { saveAudioToFile, formatFileSize } from "../utils/audioFileUtils.js";
+import { saveVideoToFile, formatVideoFileSize, getVideoMetadataSummary, } from "../utils/videoFileUtils.js";
 /**
  * CLI Command Factory for generate commands
  */
@@ -266,6 +268,41 @@ export class CLICommandFactory {
             default: false,
             description: "Auto-play generated audio",
         },
+        // Video Generation options (Veo 3.1)
+        outputMode: {
+            type: "string",
+            choices: ["text", "video"],
+            default: "text",
+            description: "Output mode: 'text' for standard generation, 'video' for video generation",
+        },
+        videoOutput: {
+            type: "string",
+            alias: "vo",
+            description: "Path to save generated video file (e.g., ./output.mp4)",
+        },
+        videoResolution: {
+            type: "string",
+            choices: ["720p", "1080p"],
+            default: "720p",
+            description: "Video output resolution (720p or 1080p)",
+        },
+        videoLength: {
+            type: "number",
+            choices: [4, 6, 8],
+            default: 4,
+            description: "Video duration in seconds (4, 6, or 8)",
+        },
+        videoAspectRatio: {
+            type: "string",
+            choices: ["9:16", "16:9"],
+            default: "16:9",
+            description: "Video aspect ratio (9:16 for portrait, 16:9 for landscape)",
+        },
+        videoAudio: {
+            type: "boolean",
+            default: true,
+            description: "Enable/disable audio generation in video",
+        },
         thinking: {
             alias: "think",
             type: "boolean",
@@ -423,6 +460,13 @@ export class CLICommandFactory {
             ttsQuality: argv.ttsQuality,
             ttsOutput: argv.ttsOutput,
             ttsPlay: argv.ttsPlay,
+            // Video generation options (Veo 3.1)
+            outputMode: argv.outputMode,
+            videoOutput: argv.videoOutput,
+            videoResolution: argv.videoResolution,
+            videoLength: argv.videoLength,
+            videoAspectRatio: argv.videoAspectRatio,
+            videoAudio: argv.videoAudio,
             // Extended thinking options for Claude and Gemini models
             thinking: argv.thinking,
             thinkingBudget: argv.thinkingBudget,
@@ -552,6 +596,98 @@ export class CLICommandFactory {
             handleError(error, "TTS Output");
         }
     }
+    /**
+     * Helper method to configure options for video generation mode
+     * Auto-configures provider, model, and tools settings for video generation
+     */
+    static configureVideoMode(enhancedOptions, argv, options) {
+        const userEnabledTools = !argv.disableTools; // Tools are enabled by default
+        enhancedOptions.disableTools = true;
+        // Auto-set provider to vertex for video generation if not explicitly specified
+        if (!enhancedOptions.provider) {
+            enhancedOptions.provider = "vertex";
+            if (options.debug) {
+                logger.debug("Auto-setting provider to 'vertex' for video generation mode");
+            }
+        }
+        else if (enhancedOptions.provider !== "vertex") {
+            // Warn if user specified a non-vertex provider
+            if (!options.quiet) {
+                logger.always(chalk.yellow(`⚠️  Warning: Video generation only supports Vertex AI. Overriding provider '${enhancedOptions.provider}' to 'vertex'.`));
+            }
+            enhancedOptions.provider = "vertex";
+        }
+        // Auto-set model to veo-3.1 if not explicitly specified
+        if (!enhancedOptions.model) {
+            // Resolve the alias to the full model ID for Vertex AI
+            const modelAlias = "veo-3.1";
+            const resolvedModel = ModelResolver.resolveModel(modelAlias);
+            const fullModelId = resolvedModel?.id || "veo-3.1-generate-001";
+            enhancedOptions.model = fullModelId;
+            if (options.debug) {
+                logger.debug(`Auto-setting model to '${fullModelId}' for video generation mode`);
+            }
+        }
+        // Warn user if they explicitly enabled tools
+        if (userEnabledTools && !options.quiet) {
+            logger.always(chalk.yellow("⚠️  Note: MCP tools are not supported in video generation mode and have been disabled."));
+        }
+        if (options.debug) {
+            logger.debug("Video generation mode enabled (tools auto-disabled):", {
+                provider: enhancedOptions.provider,
+                model: enhancedOptions.model,
+                resolution: enhancedOptions.videoResolution,
+                length: enhancedOptions.videoLength,
+                aspectRatio: enhancedOptions.videoAspectRatio,
+                audio: enhancedOptions.videoAudio,
+                outputPath: enhancedOptions.videoOutput,
+            });
+        }
+    }
+    /**
+     * Helper method to handle video file output
+     * Saves generated video to file when --videoOutput flag is provided
+     */
+    static async handleVideoOutput(result, options) {
+        // Check if --videoOutput flag is provided
+        const videoOutputPath = options.videoOutput;
+        if (!videoOutputPath) {
+            return;
+        }
+        // Extract video from result with proper type checking
+        if (!result || typeof result !== "object") {
+            return;
+        }
+        const generateResult = result;
+        const video = generateResult.video;
+        if (!video) {
+            if (!options.quiet) {
+                logger.always(chalk.yellow("⚠️  No video available in result. Video generation may not be enabled or the request failed."));
+            }
+            return;
+        }
+        try {
+            // 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}`));
+                    }
+                }
+            }
+            else {
+                handleError(new Error(saveResult.error || "Failed to save video file"), "Video Output");
+            }
+        }
+        catch (error) {
+            handleError(error, "Video Output");
+        }
+    }
     // Helper method to validate token usage data with fallback handling
     static isValidTokenUsage(tokens) {
         if (!tokens || typeof tokens !== "object" || tokens === null) {
@@ -672,7 +808,9 @@ export class CLICommandFactory {
                     .example('$0 generate "Analyze data" --enable-analytics', "Enable usage analytics")
                     .example('$0 generate "Futuristic city" --model gemini-2.5-flash-image', "Generate an image")
                     .example('$0 generate "Mountain landscape" --model gemini-2.5-flash-image --imageOutput ./my-images/mountain.png', "Generate image with custom path")
-                    .example('$0 generate "Describe this video" --video path/to/video.mp4', "Analyze video content"));
+                    .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"));
             },
             handler: async (argv) => await this.executeGenerate(argv),
         };
@@ -1196,7 +1334,12 @@ export class CLICommandFactory {
             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();
+        // Determine if video generation mode is enabled
+        const isVideoMode = options.outputMode === "video";
+        const spinnerMessage = isVideoMode
+            ? "🎬 Generating video... (this may take 1-2 minutes)"
+            : "🤖 Generating text...";
+        const spinner = argv.quiet ? null : ora(spinnerMessage).start();
         try {
             // Add delay if specified
             if (options.delay) {
@@ -1287,6 +1430,10 @@ export class CLICommandFactory {
                     toolsEnabled: !options.disableTools,
                 });
             }
+            // Video generation doesn't support tools, so auto-disable them
+            if (isVideoMode) {
+                this.configureVideoMode(enhancedOptions, argv, options);
+            }
             // Process CLI multimodal inputs
             const imageBuffers = CLICommandFactory.processCliImages(argv.image);
             const csvFiles = CLICommandFactory.processCliCSVFiles(argv.csv);
@@ -1313,6 +1460,18 @@ 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,
                 provider: enhancedOptions.provider,
                 model: enhancedOptions.model,
                 temperature: enhancedOptions.temperature,
@@ -1338,7 +1497,12 @@ export class CLICommandFactory {
                     : undefined,
             });
             if (spinner) {
-                spinner.succeed(chalk.green("✅ Text generated successfully!"));
+                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) {
@@ -1346,10 +1510,14 @@ export class CLICommandFactory {
                 const modelInfo = result.model || "default";
                 logger.always(chalk.gray(`🔧 Provider: ${providerInfo} | Model: ${modelInfo}`));
             }
-            // Handle output with universal formatting
-            this.handleOutput(result, options);
+            // Handle output with universal formatting (for text mode)
+            if (!isVideoMode) {
+                this.handleOutput(result, options);
+            }
             // Handle TTS audio file output if --tts-output is provided
             await this.handleTTSOutput(result, options);
+            // Handle video file output if --videoOutput is provided
+            await this.handleVideoOutput(result, options);
             if (options.debug) {
                 logger.debug("\n" + chalk.yellow("Debug Information:"));
                 logger.debug("Provider:", result.provider);

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

@@ -0,0 +1,111 @@
+/**
+ * Video file utilities for CLI
+ *
+ * Provides functionality for saving generated video to files with proper
+ * error handling and directory creation. Follows the pattern established
+ * by audioFileUtils.ts for TTS output handling.
+ *
+ * @module cli/utils/videoFileUtils
+ */
+import type { VideoGenerationResult } from "../../lib/types/multimodal.js";
+/**
+ * Result of saving video to file
+ */
+export type VideoSaveResult = {
+    /** Whether the save was successful */
+    success: boolean;
+    /** Full path to the saved file */
+    path: string;
+    /** File size in bytes */
+    size: number;
+    /** Error message if failed */
+    error?: string;
+};
+/**
+ * Format file size in human-readable format
+ *
+ * @param bytes - Size in bytes
+ * @returns Formatted string (e.g., "32 KB", "1.5 MB")
+ */
+export declare function formatVideoFileSize(bytes: number): string;
+/**
+ * Resolve the output path, handling both absolute and relative paths
+ *
+ * @param outputPath - User-specified output path
+ * @returns Resolved absolute path
+ */
+export declare function resolveVideoOutputPath(outputPath: string): string;
+/**
+ * Ensure parent directories exist, creating them if necessary
+ *
+ * @param filePath - Full path to the file
+ */
+export declare function ensureVideoDirectoryExists(filePath: string): Promise<void>;
+/**
+ * Get appropriate file extension for video media type
+ *
+ * @param mediaType - Video media type
+ * @returns File extension (including dot)
+ */
+export declare function getVideoExtension(mediaType: "video/mp4" | "video/webm"): string;
+/**
+ * Validate and normalize output path, adding extension if needed
+ *
+ * If the specified path has no extension or an invalid extension, the appropriate
+ * extension (.mp4 or .webm) will be added based on the mediaType.
+ * If the extension doesn't match the mediaType (e.g., .webm specified but mediaType
+ * is video/mp4), the extension will be replaced to match the actual format.
+ *
+ * @param outputPath - User-specified output path
+ * @param mediaType - Video media type for extension
+ * @returns Normalized output path with correct extension
+ */
+export declare function normalizeVideoOutputPath(outputPath: string, mediaType?: "video/mp4" | "video/webm"): string;
+/**
+ * Format video duration in human-readable format
+ *
+ * @param seconds - Duration in seconds
+ * @returns Formatted string (e.g., "4s", "1m 30s")
+ */
+export declare function formatVideoDuration(seconds: number): string;
+/**
+ * Format video dimensions in human-readable format
+ *
+ * @param width - Video width in pixels
+ * @param height - Video height in pixels
+ * @returns Formatted string (e.g., "1920x1080")
+ */
+export declare function formatVideoDimensions(width: number, height: number): string;
+/**
+ * Save generated video result to a file
+ *
+ * Creates parent directories if they don't exist and handles both
+ * absolute and relative paths.
+ *
+ * @param video - Video generation result containing video buffer
+ * @param outputPath - Path where the video should be saved
+ * @returns Save result with success status, path, and size
+ *
+ * @example
+ * ```typescript
+ * const result = await saveVideoToFile(videoResult, "./output/video.mp4");
+ * if (result.success) {
+ *   console.log(`Saved to ${result.path} (${formatVideoFileSize(result.size)})`);
+ * }
+ * ```
+ */
+export declare function saveVideoToFile(video: VideoGenerationResult, outputPath: string): Promise<VideoSaveResult>;
+/**
+ * Type guard to check if an object is a valid VideoGenerationResult
+ *
+ * @param obj - Object to check
+ * @returns True if object is a valid VideoGenerationResult
+ */
+export declare function isVideoGenerationResult(obj: unknown): obj is VideoGenerationResult;
+/**
+ * Get video metadata summary for display
+ *
+ * @param video - Video generation result
+ * @returns Formatted metadata summary string
+ */
+export declare function getVideoMetadataSummary(video: VideoGenerationResult): string;

package/dist/cli/utils/videoFileUtils.js

@@ -0,0 +1,222 @@
+/**
+ * Video file utilities for CLI
+ *
+ * Provides functionality for saving generated video to files with proper
+ * error handling and directory creation. Follows the pattern established
+ * by audioFileUtils.ts for TTS output handling.
+ *
+ * @module cli/utils/videoFileUtils
+ */
+import fs from "fs";
+import path from "path";
+/**
+ * Format file size in human-readable format
+ *
+ * @param bytes - Size in bytes
+ * @returns Formatted string (e.g., "32 KB", "1.5 MB")
+ */
+export function formatVideoFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    else if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+    else if (bytes < 1024 * 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    else {
+        return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+    }
+}
+/**
+ * Resolve the output path, handling both absolute and relative paths
+ *
+ * @param outputPath - User-specified output path
+ * @returns Resolved absolute path
+ */
+export function resolveVideoOutputPath(outputPath) {
+    if (path.isAbsolute(outputPath)) {
+        return outputPath;
+    }
+    return path.resolve(process.cwd(), outputPath);
+}
+/**
+ * Ensure parent directories exist, creating them if necessary
+ *
+ * @param filePath - Full path to the file
+ */
+export async function ensureVideoDirectoryExists(filePath) {
+    const directory = path.dirname(filePath);
+    try {
+        await fs.promises.access(directory, fs.constants.F_OK);
+    }
+    catch {
+        // Directory doesn't exist, create it recursively
+        await fs.promises.mkdir(directory, { recursive: true });
+    }
+}
+/**
+ * Get appropriate file extension for video media type
+ *
+ * @param mediaType - Video media type
+ * @returns File extension (including dot)
+ */
+export function getVideoExtension(mediaType) {
+    switch (mediaType) {
+        case "video/mp4":
+            return ".mp4";
+        case "video/webm":
+            return ".webm";
+        default:
+            // Unreachable but kept for runtime safety
+            return ".mp4";
+    }
+}
+/**
+ * Validate and normalize output path, adding extension if needed
+ *
+ * If the specified path has no extension or an invalid extension, the appropriate
+ * extension (.mp4 or .webm) will be added based on the mediaType.
+ * If the extension doesn't match the mediaType (e.g., .webm specified but mediaType
+ * is video/mp4), the extension will be replaced to match the actual format.
+ *
+ * @param outputPath - User-specified output path
+ * @param mediaType - Video media type for extension
+ * @returns Normalized output path with correct extension
+ */
+export function normalizeVideoOutputPath(outputPath, mediaType = "video/mp4") {
+    const resolvedPath = resolveVideoOutputPath(outputPath);
+    const ext = path.extname(resolvedPath).toLowerCase();
+    const expectedExt = getVideoExtension(mediaType);
+    const validExtensions = [".mp4", ".webm"];
+    if (!ext || !validExtensions.includes(ext)) {
+        return resolvedPath + expectedExt;
+    }
+    // If extension doesn't match mediaType, replace it
+    if (ext !== expectedExt) {
+        const basePath = resolvedPath.slice(0, -ext.length);
+        return basePath + expectedExt;
+    }
+    return resolvedPath;
+}
+/**
+ * Format video duration in human-readable format
+ *
+ * @param seconds - Duration in seconds
+ * @returns Formatted string (e.g., "4s", "1m 30s")
+ */
+export function formatVideoDuration(seconds) {
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (remainingSeconds === 0) {
+        return `${minutes}m`;
+    }
+    return `${minutes}m ${remainingSeconds}s`;
+}
+/**
+ * Format video dimensions in human-readable format
+ *
+ * @param width - Video width in pixels
+ * @param height - Video height in pixels
+ * @returns Formatted string (e.g., "1920x1080")
+ */
+export function formatVideoDimensions(width, height) {
+    return `${width}x${height}`;
+}
+/**
+ * Save generated video result to a file
+ *
+ * Creates parent directories if they don't exist and handles both
+ * absolute and relative paths.
+ *
+ * @param video - Video generation result containing video buffer
+ * @param outputPath - Path where the video should be saved
+ * @returns Save result with success status, path, and size
+ *
+ * @example
+ * ```typescript
+ * const result = await saveVideoToFile(videoResult, "./output/video.mp4");
+ * if (result.success) {
+ *   console.log(`Saved to ${result.path} (${formatVideoFileSize(result.size)})`);
+ * }
+ * ```
+ */
+export async function saveVideoToFile(video, outputPath) {
+    let normalizedPath = outputPath;
+    try {
+        // Normalize the output path
+        normalizedPath = normalizeVideoOutputPath(outputPath, video.mediaType);
+        // Ensure parent directories exist
+        await ensureVideoDirectoryExists(normalizedPath);
+        // Write the video buffer to file
+        await fs.promises.writeFile(normalizedPath, video.data);
+        // Get the actual file size
+        const stats = await fs.promises.stat(normalizedPath);
+        return {
+            success: true,
+            path: normalizedPath,
+            size: stats.size,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+        return {
+            success: false,
+            path: normalizedPath,
+            size: 0,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Type guard to check if an object is a valid VideoGenerationResult
+ *
+ * @param obj - Object to check
+ * @returns True if object is a valid VideoGenerationResult
+ */
+export function isVideoGenerationResult(obj) {
+    if (!obj || typeof obj !== "object") {
+        return false;
+    }
+    const video = obj;
+    // Check required fields
+    if (!(video.data instanceof Buffer)) {
+        return false;
+    }
+    // Check mediaType is valid
+    if (video.mediaType !== "video/mp4" && video.mediaType !== "video/webm") {
+        return false;
+    }
+    return true;
+}
+/**
+ * Get video metadata summary for display
+ *
+ * @param video - Video generation result
+ * @returns Formatted metadata summary string
+ */
+export function getVideoMetadataSummary(video) {
+    const parts = [];
+    if (video.metadata?.duration) {
+        parts.push(`Duration: ${formatVideoDuration(video.metadata.duration)}`);
+    }
+    if (video.metadata?.dimensions) {
+        parts.push(`Resolution: ${formatVideoDimensions(video.metadata.dimensions.width, video.metadata.dimensions.height)}`);
+    }
+    if (video.metadata?.aspectRatio) {
+        parts.push(`Aspect: ${video.metadata.aspectRatio}`);
+    }
+    if (video.metadata?.audioEnabled !== undefined) {
+        parts.push(`Audio: ${video.metadata.audioEnabled ? "Yes" : "No"}`);
+    }
+    if (video.metadata?.processingTime) {
+        const seconds = (video.metadata.processingTime / 1000).toFixed(1);
+        parts.push(`Processing: ${seconds}s`);
+    }
+    return parts.join(" | ");
+}
+//# sourceMappingURL=videoFileUtils.js.map

package/dist/lib/types/cli.d.ts

@@ -68,6 +68,18 @@ export type GenerateCommandArgs = BaseCommandArgs & {
     thinkingLevel?: "minimal" | "low" | "medium" | "high";
     /** Vertex AI region */
     region?: string;
+    /** Output mode - 'text' for standard generation, 'video' for video generation */
+    outputMode?: "text" | "video";
+    /** Path to save generated video file */
+    videoOutput?: string;
+    /** Video output resolution (720p or 1080p) */
+    videoResolution?: "720p" | "1080p";
+    /** Video duration in seconds (4, 6, or 8) */
+    videoLength?: 4 | 6 | 8;
+    /** Video aspect ratio (9:16 for portrait, 16:9 for landscape) */
+    videoAspectRatio?: "9:16" | "16:9";
+    /** Enable/disable audio generation in video */
+    videoAudio?: boolean;
     /** Custom path for generated image output */
     imageOutput?: string;
 };
@@ -357,6 +369,8 @@ export type GenerateResult = CommandResult & {
     }>;
     /** TTS audio result when TTS is enabled */
     audio?: import("./index.js").TTSResult;
+    /** Video generation result when video mode is enabled */
+    video?: import("./multimodal.js").VideoGenerationResult;
     imageOutput?: {
         base64: string;
         savedPath?: string;

package/dist/lib/types/fileTypes.d.ts

@@ -44,6 +44,7 @@ export type FileProcessingResult = {
         filename?: string;
         extension?: string | null;
         rowCount?: number;
+        totalLines?: number;
         columnCount?: number;
         columnNames?: string[];
         sampleData?: string | unknown[];

package/dist/lib/utils/csvProcessor.js

@@ -85,8 +85,12 @@ export class CSVProcessor {
                 : lines;
             const limitedLines = csvLines.slice(0, 1 + maxRows); // header + data rows
             const limitedCSV = limitedLines.join("\n");
-            const rowCount = limitedLines.length - 1; // Subtract header
-            const originalRowCount = csvLines.length - 1; // Subtract header from original
+            const rowCount = limitedLines
+                .slice(1)
+                .filter((line) => line.trim() !== "").length;
+            const originalRowCount = csvLines
+                .slice(1)
+                .filter((line) => line.trim() !== "").length;
             const wasTruncated = rowCount < originalRowCount;
             if (wasTruncated) {
                 logger.warn(`[CSVProcessor] CSV data truncated: showing ${rowCount} of ${originalRowCount} rows (limit: ${maxRows})`);
@@ -110,6 +114,7 @@ export class CSVProcessor {
                     confidence: 100,
                     size: content.length,
                     rowCount,
+                    totalLines: limitedLines.length,
                     columnCount: (limitedLines[0] || "").split(",").length,
                     extension,
                 },
@@ -121,12 +126,26 @@ export class CSVProcessor {
             maxRows,
         });
         const rows = await this.parseCSVString(csvString, maxRows);
+        // Filter out empty rows (empty objects or rows with only whitespace values from blank lines)
+        const nonEmptyRows = rows.filter((row) => {
+            if (!row || typeof row !== "object") {
+                return false;
+            }
+            const keys = Object.keys(row);
+            if (keys.length === 0) {
+                return false;
+            }
+            // Check if all values are empty or whitespace-only
+            return !Object.values(row).every((val) => val === "" || (typeof val === "string" && val.trim() === ""));
+        });
         // Extract metadata from parsed results
-        const rowCount = rows.length;
-        const columnNames = rows.length > 0 ? Object.keys(rows[0]) : [];
+        const rowCount = nonEmptyRows.length;
+        const columnNames = nonEmptyRows.length > 0
+            ? Object.keys(nonEmptyRows[0])
+            : [];
         const columnCount = columnNames.length;
         const hasEmptyColumns = columnNames.some((col) => !col || col.trim() === "");
-        const sampleRows = rows.slice(0, 3);
+        const sampleRows = nonEmptyRows.slice(0, 3);
         const sampleData = this.formatSampleData(sampleRows, sampleDataFormat, includeHeaders);
         if (hasEmptyColumns) {
             logger.warn("[CSVProcessor] CSV contains empty or blank column headers", {
@@ -138,7 +157,7 @@ export class CSVProcessor {
         }
         // Format parsed data
         logger.debug(`[CSVProcessor] Converting ${rowCount} rows to ${formatStyle} format`);
-        const formatted = this.formatForLLM(rows, formatStyle, includeHeaders);
+        const formatted = this.formatForLLM(nonEmptyRows, formatStyle, includeHeaders);
         logger.info("[CSVProcessor] ✅ Processed CSV file", {
             formatStyle,
             rowCount,

package/dist/lib/utils/pdfProcessor.d.ts

@@ -16,8 +16,8 @@ export type PDFImageConversionOptions = {
     scale?: number;
     /** Maximum number of pages to convert (default: 20 from PDF_LIMITS.DEFAULT_MAX_PAGES) */
     maxPages?: number;
-    /** Output format hint (currently only PNG supported by pdf-to-img) */
-    format?: "png";
+    /** Output format (png or jpeg, default: png). Note: pdf-to-img outputs PNG, JPEG conversion would require additional processing */
+    format?: "png" | "jpeg";
 };
 /**
  * Result of PDF to image conversion

package/dist/lib/utils/pdfProcessor.js

@@ -249,12 +249,17 @@ export class PDFProcessor {
      */
     static async convertToImages(pdfBuffer, options) {
         const startTime = Date.now();
-        const { scale = 2, maxPages = PDF_LIMITS.DEFAULT_MAX_PAGES } = options || {};
+        const { scale = 2, maxPages = PDF_LIMITS.DEFAULT_MAX_PAGES, format = "png", } = options || {};
         const images = [];
         const warnings = [];
         // ============================================================================
         // INPUT VALIDATION (Security: Prevent malformed/malicious PDF processing)
         // ============================================================================
+        // 0. Validate format is supported and case-sensitive
+        const SUPPORTED_FORMATS = ["png", "jpeg"];
+        if (!SUPPORTED_FORMATS.includes(format)) {
+            throw new Error(`Invalid format: "${format}". Supported formats: "png", "jpeg".`);
+        }
         // 1. Validate buffer is not empty or too small
         if (!pdfBuffer || pdfBuffer.length < 5) {
             throw new Error("Invalid PDF: Buffer is too small or empty. " +

package/dist/types/cli.d.ts

@@ -68,6 +68,18 @@ export type GenerateCommandArgs = BaseCommandArgs & {
     thinkingLevel?: "minimal" | "low" | "medium" | "high";
     /** Vertex AI region */
     region?: string;
+    /** Output mode - 'text' for standard generation, 'video' for video generation */
+    outputMode?: "text" | "video";
+    /** Path to save generated video file */
+    videoOutput?: string;
+    /** Video output resolution (720p or 1080p) */
+    videoResolution?: "720p" | "1080p";
+    /** Video duration in seconds (4, 6, or 8) */
+    videoLength?: 4 | 6 | 8;
+    /** Video aspect ratio (9:16 for portrait, 16:9 for landscape) */
+    videoAspectRatio?: "9:16" | "16:9";
+    /** Enable/disable audio generation in video */
+    videoAudio?: boolean;
     /** Custom path for generated image output */
     imageOutput?: string;
 };
@@ -357,6 +369,8 @@ export type GenerateResult = CommandResult & {
     }>;
     /** TTS audio result when TTS is enabled */
     audio?: import("./index.js").TTSResult;
+    /** Video generation result when video mode is enabled */
+    video?: import("./multimodal.js").VideoGenerationResult;
     imageOutput?: {
         base64: string;
         savedPath?: string;

package/dist/types/fileTypes.d.ts

@@ -44,6 +44,7 @@ export type FileProcessingResult = {
         filename?: string;
         extension?: string | null;
         rowCount?: number;
+        totalLines?: number;
         columnCount?: number;
         columnNames?: string[];
         sampleData?: string | unknown[];

package/dist/utils/csvProcessor.js

@@ -85,8 +85,12 @@ export class CSVProcessor {
                 : lines;
             const limitedLines = csvLines.slice(0, 1 + maxRows); // header + data rows
             const limitedCSV = limitedLines.join("\n");
-            const rowCount = limitedLines.length - 1; // Subtract header
-            const originalRowCount = csvLines.length - 1; // Subtract header from original
+            const rowCount = limitedLines
+                .slice(1)
+                .filter((line) => line.trim() !== "").length;
+            const originalRowCount = csvLines
+                .slice(1)
+                .filter((line) => line.trim() !== "").length;
             const wasTruncated = rowCount < originalRowCount;
             if (wasTruncated) {
                 logger.warn(`[CSVProcessor] CSV data truncated: showing ${rowCount} of ${originalRowCount} rows (limit: ${maxRows})`);
@@ -110,6 +114,7 @@ export class CSVProcessor {
                     confidence: 100,
                     size: content.length,
                     rowCount,
+                    totalLines: limitedLines.length,
                     columnCount: (limitedLines[0] || "").split(",").length,
                     extension,
                 },
@@ -121,12 +126,26 @@ export class CSVProcessor {
             maxRows,
         });
         const rows = await this.parseCSVString(csvString, maxRows);
+        // Filter out empty rows (empty objects or rows with only whitespace values from blank lines)
+        const nonEmptyRows = rows.filter((row) => {
+            if (!row || typeof row !== "object") {
+                return false;
+            }
+            const keys = Object.keys(row);
+            if (keys.length === 0) {
+                return false;
+            }
+            // Check if all values are empty or whitespace-only
+            return !Object.values(row).every((val) => val === "" || (typeof val === "string" && val.trim() === ""));
+        });
         // Extract metadata from parsed results
-        const rowCount = rows.length;
-        const columnNames = rows.length > 0 ? Object.keys(rows[0]) : [];
+        const rowCount = nonEmptyRows.length;
+        const columnNames = nonEmptyRows.length > 0
+            ? Object.keys(nonEmptyRows[0])
+            : [];
         const columnCount = columnNames.length;
         const hasEmptyColumns = columnNames.some((col) => !col || col.trim() === "");
-        const sampleRows = rows.slice(0, 3);
+        const sampleRows = nonEmptyRows.slice(0, 3);
         const sampleData = this.formatSampleData(sampleRows, sampleDataFormat, includeHeaders);
         if (hasEmptyColumns) {
             logger.warn("[CSVProcessor] CSV contains empty or blank column headers", {
@@ -138,7 +157,7 @@ export class CSVProcessor {
         }
         // Format parsed data
         logger.debug(`[CSVProcessor] Converting ${rowCount} rows to ${formatStyle} format`);
-        const formatted = this.formatForLLM(rows, formatStyle, includeHeaders);
+        const formatted = this.formatForLLM(nonEmptyRows, formatStyle, includeHeaders);
         logger.info("[CSVProcessor] ✅ Processed CSV file", {
             formatStyle,
             rowCount,

package/dist/utils/pdfProcessor.d.ts

@@ -16,8 +16,8 @@ export type PDFImageConversionOptions = {
     scale?: number;
     /** Maximum number of pages to convert (default: 20 from PDF_LIMITS.DEFAULT_MAX_PAGES) */
     maxPages?: number;
-    /** Output format hint (currently only PNG supported by pdf-to-img) */
-    format?: "png";
+    /** Output format (png or jpeg, default: png). Note: pdf-to-img outputs PNG, JPEG conversion would require additional processing */
+    format?: "png" | "jpeg";
 };
 /**
  * Result of PDF to image conversion

package/dist/utils/pdfProcessor.js

@@ -249,12 +249,17 @@ export class PDFProcessor {
      */
     static async convertToImages(pdfBuffer, options) {
         const startTime = Date.now();
-        const { scale = 2, maxPages = PDF_LIMITS.DEFAULT_MAX_PAGES } = options || {};
+        const { scale = 2, maxPages = PDF_LIMITS.DEFAULT_MAX_PAGES, format = "png", } = options || {};
         const images = [];
         const warnings = [];
         // ============================================================================
         // INPUT VALIDATION (Security: Prevent malformed/malicious PDF processing)
         // ============================================================================
+        // 0. Validate format is supported and case-sensitive
+        const SUPPORTED_FORMATS = ["png", "jpeg"];
+        if (!SUPPORTED_FORMATS.includes(format)) {
+            throw new Error(`Invalid format: "${format}". Supported formats: "png", "jpeg".`);
+        }
         // 1. Validate buffer is not empty or too small
         if (!pdfBuffer || pdfBuffer.length < 5) {
             throw new Error("Invalid PDF: Buffer is too small or empty. " +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "8.31.2",
+  "version": "8.32.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",