jtcsv 2.2.8 → 3.1.0

package/bin/jtcsv.ts

@@ -0,0 +1,2612 @@
+#!/usr/bin/env node
+
+/**
+ * jtcsv CLI - Complete Command Line Interface
+ *
+ * Full-featured command-line interface for JSON↔CSV conversion
+ * with streaming, batch processing, and all security features.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+const { pipeline } = require('stream/promises');
+import * as jtcsv from '../index';
+const transformLoader = require('../src/utils/transform-loader');
+const schemaValidator = require('../src/utils/schema-validator');
+
+const VERSION = require('../package.json').version;
+
+type ConversionResult = {
+  records?: number;
+  rows?: number;
+  bytes?: number;
+  time?: number;
+};
+
+type BatchFileResult = ConversionResult & {
+  file: string;
+  success: boolean;
+  error?: string;
+};
+
+type BatchSummary = {
+  totalFiles: number;
+  successful: number;
+  totalRecords?: number;
+  totalRows?: number;
+  jsonFiles?: number;
+  csvFiles?: number;
+  otherFiles?: number;
+  time: number;
+  results: BatchFileResult[];
+};
+
+// Function to apply transform from JavaScript file
+async function applyTransform(data, transformFile: any): Promise<any> {
+  try {
+    const transformPath = path.resolve(process.cwd(), transformFile);
+    const transformModule = require(transformPath);
+
+    // Check if module exports a function
+    if (typeof transformModule === 'function') {
+      return transformModule(data);
+    } else if (typeof transformModule.default === 'function') {
+      return transformModule.default(data);
+    } else if (typeof transformModule.transform === 'function') {
+      return transformModule.transform(data);
+    } else {
+      throw new Error(
+        `Transform file must export a function. Found: ${typeof transformModule}`
+      );
+    }
+  } catch (error: any) {
+    throw new Error(
+      `Failed to apply transform from ${transformFile}: ${error.message}`
+    );
+  }
+}
+
+// ANSI colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m'
+};
+
+function color(text, colorName: any): any {
+  return (colors as any)[colorName] + text + colors.reset;
+}
+
+function showHelp(): void {
+  console.log(`
+${color('jtcsv CLI v' + VERSION, 'cyan')}
+${color('The Complete JSON<->CSV Converter for Node.js', 'dim')}
+
+${color('USAGE:', 'bright')}
+  jtcsv [command] [options] [file...]
+
+${color('MAIN COMMANDS:', 'bright')}
+  ${color('json-to-csv', 'green')}     Convert JSON to CSV (alias: json2csv)
+  ${color('csv-to-json', 'green')}     Convert CSV to JSON (alias: csv2json)
+  ${color('ndjson-to-csv', 'green')}   Convert NDJSON to CSV
+  ${color('csv-to-ndjson', 'green')}   Convert CSV to NDJSON
+  ${color('ndjson-to-json', 'green')}  Convert NDJSON to JSON array
+  ${color('json-to-ndjson', 'green')}  Convert JSON array to NDJSON
+  ${color('save-json', 'yellow')}      Save data as JSON file
+  ${color('save-csv', 'yellow')}       Save data as CSV file
+  ${color('stream', 'yellow')}         Streaming conversion for large files
+  ${color('batch', 'yellow')}          Batch process multiple files
+  ${color('preprocess', 'magenta')}    Preprocess JSON with deep unwrapping
+  ${color('unwrap', 'magenta')}        Flatten nested JSON structures (alias: flatten)
+  ${color('tui', 'magenta')}           Launch Terminal User Interface (@jtcsv/tui)
+  ${color('web', 'magenta')}           Launch Web Interface (http://localhost:3000)
+  ${color('help', 'blue')}             Show this help message
+  ${color('version', 'blue')}          Show version information
+
+${color('STREAMING SUBCOMMANDS:', 'bright')}
+  ${color('stream json-to-csv', 'dim')}    Stream JSON to CSV
+  ${color('stream csv-to-json', 'dim')}    Stream CSV to JSON
+  ${color('stream file-to-csv', 'dim')}    Stream file to CSV
+  ${color('stream file-to-json', 'dim')}   Stream file to JSON
+
+${color('BATCH SUBCOMMANDS:', 'bright')}
+  ${color('batch json-to-csv', 'dim')}     Batch convert JSON files to CSV
+  ${color('batch csv-to-json', 'dim')}     Batch convert CSV files to JSON
+  ${color('batch process', 'dim')}         Process mixed file types
+
+${color('EXAMPLES:', 'bright')}
+  ${color('Convert JSON file to CSV:', 'dim')}
+  jtcsv json-to-csv input.json output.csv --delimiter=,
+
+  ${color('Convert CSV file to JSON:', 'dim')}
+  jtcsv csv-to-json input.csv output.json --parse-numbers --auto-detect
+
+  ${color('Save data as JSON file:', 'dim')}
+  jtcsv save-json data.json output.json --pretty
+
+  ${color('Save data as CSV file:', 'dim')}
+  jtcsv save-csv data.csv output.csv --delimiter=, --transform=transform.js
+
+  ${color('Stream large JSON file to CSV:', 'dim')}
+  jtcsv stream json-to-csv large.json output.csv --max-records=1000000
+
+  ${color('Stream CSV file to JSON:', 'dim')}
+  jtcsv stream csv-to-json large.csv output.json --max-rows=500000
+
+  ${color('Preprocess complex JSON:', 'dim')}
+  jtcsv preprocess complex.json simplified.json --max-depth=3
+
+  ${color('Batch convert JSON files:', 'dim')}
+  jtcsv batch json-to-csv "data/*.json" "output/" --delimiter=;
+
+  ${color('Launch TUI interface:', 'dim')}
+  jtcsv tui
+
+  ${color('Launch Web interface:', 'dim')}
+  jtcsv web --port=3000
+
+${color('CONVERSION OPTIONS:', 'bright')}
+  ${color('--delimiter=', 'cyan')}CHAR    CSV delimiter (default: ;)
+  ${color('--auto-detect', 'cyan')}        Auto-detect delimiter (default: true)
+  ${color('--candidates=', 'cyan')}LIST    Delimiter candidates (default: ;,\t|)
+  ${color('--no-headers', 'cyan')}         Exclude headers from CSV output
+  ${color('--parse-numbers', 'cyan')}      Parse numeric values in CSV
+  ${color('--parse-booleans', 'cyan')}     Parse boolean values in CSV
+  ${color('--no-trim', 'cyan')}            Don't trim whitespace from CSV values
+  ${color('--no-fast-path', 'cyan')}       Disable fast-path parser (force quote-aware)
+  ${color('--fast-path-mode=', 'cyan')}MODE  Fast path output mode (objects|compact)
+  ${color('--repair-row-shifts', 'cyan')}  Repair shifted rows with trailing empty fields
+  ${color('--normalize-quotes', 'cyan')}  Normalize excessive quotes in parsed fields
+  ${color('--rename=', 'cyan')}JSON       Rename columns (JSON map)
+  ${color('--template=', 'cyan')}JSON      Column order template (JSON object)
+  ${color('--no-injection-protection', 'cyan')}  Disable CSV injection protection
+  ${color('--no-rfc4180', 'cyan')}         Disable RFC 4180 compliance
+  ${color('--max-records=', 'cyan')}N      Maximum records to process
+  ${color('--max-rows=', 'cyan')}N         Maximum rows to process
+  ${color('--pretty', 'cyan')}             Pretty print JSON output
+  ${color('--schema=', 'cyan')}JSON        JSON schema for validation and formatting
+  ${color('--transform=', 'cyan')}JS       Custom transform function (JavaScript file)
+  ${color('PREPROCESS OPTIONS:', 'bright')}
+  ${color('--max-depth=', 'cyan')}N        Maximum recursion depth (default: 5)
+  ${color('--flatten', 'cyan')}            Flatten nested objects into dot notation
+  ${color('--flatten-separator=', 'cyan')}CHAR  Separator for flattened keys (default: .)
+  ${color('--flatten-max-depth=', 'cyan')}N     Maximum flattening depth (default: 3)
+  ${color('--array-handling=', 'cyan')}MODE     Array handling: stringify|join|expand (default: stringify)
+  ${color('--unwrap-arrays', 'cyan')}      Unwrap arrays to strings
+  ${color('--stringify-objects', 'cyan')}  Stringify complex objects
+  ${color('STREAMING OPTIONS:', 'bright')}
+  ${color('--chunk-size=', 'cyan')}N       Chunk size in bytes (default: 65536)
+  ${color('--buffer-size=', 'cyan')}N      Buffer size in records (default: 1000)
+  ${color('--add-bom', 'cyan')}            Add UTF-8 BOM for Excel compatibility
+  ${color('BATCH OPTIONS:', 'bright')}
+  ${color('--recursive', 'cyan')}          Process directories recursively
+  ${color('--pattern=', 'cyan')}GLOB       File pattern to match
+  ${color('--output-dir=', 'cyan')}DIR     Output directory for batch processing
+  ${color('--overwrite', 'cyan')}          Overwrite existing files
+  ${color('--parallel=', 'cyan')}N         Parallel processing limit (default: 4)
+  ${color('GENERAL OPTIONS:', 'bright')}
+  ${color('--silent', 'cyan')}             Suppress all output except errors
+  ${color('--verbose', 'cyan')}            Show detailed progress information
+  ${color('--debug', 'cyan')}              Show debug information
+  ${color('--dry-run', 'cyan')}            Show what would be done without actually doing it
+  ${color('SECURITY FEATURES:', 'bright')}
+  - CSV injection protection (enabled by default)
+  - Path traversal protection
+  - Input validation and sanitization
+  - Size limits to prevent DoS attacks
+  - Schema validation support
+
+  ${color('PERFORMANCE FEATURES:', 'bright')}
+  - Streaming for files >100MB
+  - Batch processing with parallel execution
+  - Memory-efficient preprocessing
+  - Configurable buffer sizes
+
+  ${color('LEARN MORE:', 'dim')}
+  GitHub: https://github.com/Linol-Hamelton/jtcsv
+  Issues: https://github.com/Linol-Hamelton/jtcsv/issues
+  Documentation: https://github.com/Linol-Hamelton/jtcsv#readme
+  `);
+}
+
+function showVersion(): void {
+  console.log(`jtcsv v${VERSION}`);
+  console.log(`Node.js ${process.version}`);
+  console.log(`Platform: ${process.platform} ${process.arch}`);
+}
+
+async function readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+  });
+}
+
+// ============================================================================
+// CONVERSION FUNCTIONS
+// ============================================================================
+
+async function convertJsonToCsv(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+  const useStdin = inputFile === '-';
+  const useStdout = outputFile === '-';
+  const shouldLog = !options.silent && !useStdout;
+
+  try {
+    // Read input
+    const inputData = useStdin
+      ? await readStdin()
+      : await fs.promises.readFile(inputFile, 'utf8');
+    const jsonData = JSON.parse(inputData);
+
+    if (!Array.isArray(jsonData)) {
+      throw new Error('JSON data must be an array of objects');
+    }
+
+    if (shouldLog) {
+      console.log(
+        color(
+          `Converting ${jsonData.length.toLocaleString()} records...`,
+          'dim'
+        )
+      );
+    }
+
+    if (options.transform) {
+      if (shouldLog) {
+        console.log(
+          color(`Applying transform from: ${options.transform}`, 'dim')
+        );
+      }
+      let transformedData;
+try {
+        transformedData = transformLoader.applyTransform(
+          jsonData,
+          options.transform
+        );
+        if (shouldLog) {
+          console.log(
+            color(
+              `✓ Transform applied to ${transformedData.length} records`,
+              'green'
+            )
+          );
+        }
+      } catch (transformError: any) {
+        console.error(
+          color(`✗ Transform error: ${transformError.message}`, 'red')
+        );
+        if (options.debug) {
+          console.error(transformError.stack);
+        }
+        process.exit(1);
+      }
+    }
+
+    // Prepare options for jtcsv
+    const jtcsvOptions = {
+      delimiter: options.delimiter,
+      includeHeaders: options.includeHeaders,
+      renameMap: options.renameMap,
+      template: options.template,
+      maxRecords: options.maxRecords,
+      preventCsvInjection: options.preventCsvInjection,
+      rfc4180Compliant: options.rfc4180Compliant,
+      normalizeQuotes: options.normalizeQuotes,
+      schema: options.schema, // Add schema option
+      flatten: options.flatten,
+      flattenSeparator: options.flattenSeparator,
+      flattenMaxDepth: options.flattenMaxDepth,
+      arrayHandling: options.arrayHandling
+    };
+
+    // Apply transform function if provided
+    let transformedData = jsonData;
+    if (options.transform) {
+      transformedData = await applyTransform(jsonData, options.transform);
+    }
+
+    // Convert to CSV
+    const csvData = jtcsv.jsonToCsv(transformedData, jtcsvOptions);
+
+    // Write output
+    if (useStdout) {
+      process.stdout.write(csvData);
+    } else {
+      await fs.promises.writeFile(outputFile, csvData, 'utf8');
+    }
+
+    const elapsed = Date.now() - startTime;
+    if (shouldLog) {
+      console.log(
+        color(
+          `✓ Converted ${transformedData.length.toLocaleString()} records in ${elapsed}ms`,
+          'green'
+        )
+      );
+      if (!useStdout) {
+        console.log(
+          color(
+            `  Output: ${outputFile} (${csvData.length.toLocaleString()} bytes)`,
+            'dim'
+          )
+        );
+      }
+    }
+
+    return {
+      records: transformedData.length,
+      bytes: csvData.length,
+      time: elapsed
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function convertCsvToJson(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+  const useStdin = inputFile === '-';
+  const useStdout = outputFile === '-';
+  const shouldLog = !options.silent && !useStdout;
+
+  try {
+    if (shouldLog) {
+      console.log(color('Reading CSV file...', 'dim'));
+    }
+
+    // Prepare options for jtcsv
+    const jtcsvOptions = {
+      delimiter: options.delimiter,
+      autoDetect: options.autoDetect,
+      candidates: options.candidates,
+      hasHeaders: options.hasHeaders,
+      renameMap: options.renameMap,
+      trim: options.trim,
+      parseNumbers: options.parseNumbers,
+      parseBooleans: options.parseBooleans,
+      maxRows: options.maxRows,
+      useFastPath: options.useFastPath,
+      fastPathMode: options.fastPathMode,
+      repairRowShifts: options.repairRowShifts,
+      normalizeQuotes: options.normalizeQuotes,
+      schema: options.schema // Add schema option if supported
+    };
+
+    // Read and convert CSV
+    let jsonData: any;
+    if (useStdin) {
+      const csvContent = await readStdin();
+      jsonData = jtcsv.csvToJson(csvContent, jtcsvOptions);
+    } else {
+      jsonData = await jtcsv.readCsvAsJson(inputFile, jtcsvOptions);
+    }
+
+    // Apply transform if specified
+    let transformedData = jsonData;
+    if (options.transform) {
+      if (shouldLog) {
+        console.log(
+          color(`Applying transform from: ${options.transform}`, 'dim')
+        );
+      }
+      try {
+        transformedData = transformLoader.applyTransform(
+          jsonData,
+          options.transform
+        );
+        if (shouldLog) {
+          console.log(
+            color(
+              `✓ Transform applied to ${transformedData.length} rows`,
+              'green'
+            )
+          );
+        }
+      } catch (transformError: any) {
+        console.error(
+          color(`✗ Transform error: ${transformError.message}`, 'red')
+        );
+        if (options.debug) {
+          console.error(transformError.stack);
+        }
+        process.exit(1);
+      }
+    }
+
+    // Format JSON
+    const jsonOutput = options.pretty
+      ? JSON.stringify(transformedData, null, 2)
+      : JSON.stringify(transformedData);
+
+    // Write output
+    if (useStdout) {
+      process.stdout.write(jsonOutput);
+    } else {
+      await fs.promises.writeFile(outputFile, jsonOutput, 'utf8');
+    }
+
+    const elapsed = Date.now() - startTime;
+    if (shouldLog) {
+      console.log(
+        color(
+          `✓ Converted ${transformedData.length.toLocaleString()} rows in ${elapsed}ms`,
+          'green'
+        )
+      );
+      if (!useStdout) {
+        console.log(
+          color(
+            `  Output: ${outputFile} (${jsonOutput.length.toLocaleString()} bytes)`,
+            'dim'
+          )
+        );
+      }
+    }
+
+    return {
+      rows: transformedData.length,
+      bytes: jsonOutput.length,
+      time: elapsed
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function saveAsCsv(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+
+  try {
+    // Read input file
+    const inputData = await fs.promises.readFile(inputFile, 'utf8');
+
+    if (!options.silent) {
+      console.log(color('Saving CSV file...', 'dim'));
+    }
+
+    // Apply transform if specified
+    let transformedData = inputData;
+    if (options.transform) {
+      if (!options.silent) {
+        console.log(
+          color(`Applying transform from: ${options.transform}`, 'dim')
+        );
+      }
+      try {
+        // Для CSV нужно сначала распарсить, применить трансформацию, затем снова сериализовать
+        const parsedData = jtcsv.csvToJson(inputData, {
+          delimiter: options.delimiter,
+          autoDetect: options.autoDetect,
+          hasHeaders: options.hasHeaders,
+          trim: options.trim,
+          parseNumbers: options.parseNumbers,
+          parseBooleans: options.parseBooleans,
+          repairRowShifts: options.repairRowShifts,
+          normalizeQuotes: options.normalizeQuotes
+        });
+
+        const transformedJson = transformLoader.applyTransform(
+          parsedData,
+          options.transform
+        );
+
+        // Конвертировать обратно в CSV
+        transformedData = jtcsv.jsonToCsv(transformedJson, {
+          delimiter: options.delimiter,
+          includeHeaders: options.includeHeaders,
+          normalizeQuotes: options.normalizeQuotes
+        });
+
+        if (!options.silent) {
+          console.log(color('✓ Transform applied', 'green'));
+        }
+      } catch (transformError: any) {
+        console.error(
+          color(`✗ Transform error: ${transformError.message}`, 'red')
+        );
+        if (options.debug) {
+          console.error(transformError.stack);
+        }
+        process.exit(1);
+      }
+    }
+
+    // Write output file
+    await fs.promises.writeFile(outputFile, transformedData, 'utf8');
+
+    const elapsed = Date.now() - startTime;
+    if (!options.silent) {
+      console.log(color(`✓ Saved CSV in ${elapsed}ms`, 'green'));
+      console.log(color(`  Output: ${outputFile}`, 'dim'));
+    }
+
+    return { time: elapsed };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function saveAsJson(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+
+  try {
+    // Read input file
+    const inputData = await fs.promises.readFile(inputFile, 'utf8');
+    const jsonData = JSON.parse(inputData);
+
+    if (!options.silent) {
+      console.log(
+        color(
+          `Saving ${Array.isArray(jsonData) ? jsonData.length.toLocaleString() + ' records' : 'object'}...`,
+          'dim'
+        )
+      );
+    }
+
+    // Apply transform if specified
+    let transformedData = jsonData;
+    if (options.transform) {
+      if (!options.silent) {
+        console.log(
+          color(`Applying transform from: ${options.transform}`, 'dim')
+        );
+      }
+      try {
+        transformedData = transformLoader.applyTransform(
+          jsonData,
+          options.transform
+        );
+        if (!options.silent) {
+          console.log(color('✓ Transform applied', 'green'));
+        }
+      } catch (transformError: any) {
+        console.error(
+          color(`✗ Transform error: ${transformError.message}`, 'red')
+        );
+        if (options.debug) {
+          console.error(transformError.stack);
+        }
+        process.exit(1);
+      }
+    }
+
+    // Prepare options for jtcsv
+    const jtcsvOptions = {
+      prettyPrint: options.pretty
+    };
+
+    // Save as JSON
+    await jtcsv.saveAsJson(transformedData, outputFile, jtcsvOptions);
+
+    const elapsed = Date.now() - startTime;
+    if (!options.silent) {
+      console.log(color(`✓ Saved JSON in ${elapsed}ms`, 'green'));
+      console.log(color(`  Output: ${outputFile}`, 'dim'));
+    }
+
+    return { time: elapsed };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// NDJSON CONVERSION FUNCTIONS
+// ============================================================================
+
+async function convertNdjsonToCsv(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+
+  try {
+    if (!options.silent) {
+      console.log(color('Converting NDJSON to CSV...', 'dim'));
+    }
+
+    // Read NDJSON file
+    const inputData = await fs.promises.readFile(inputFile, 'utf8');
+    const jsonData = jtcsv.ndjsonToJson(inputData);
+
+    if (!options.silent) {
+      console.log(
+        color(`Parsed ${jsonData.length.toLocaleString()} records from NDJSON`, 'dim')
+      );
+    }
+
+    // Prepare options for jtcsv
+    const jtcsvOptions = {
+      delimiter: options.delimiter,
+      includeHeaders: options.includeHeaders,
+      renameMap: options.renameMap,
+      template: options.template,
+      preventCsvInjection: options.preventCsvInjection,
+      rfc4180Compliant: options.rfc4180Compliant,
+      normalizeQuotes: options.normalizeQuotes
+    };
+
+    // Convert to CSV
+    const csvData = jtcsv.jsonToCsv(jsonData, jtcsvOptions);
+
+    // Write output file
+    await fs.promises.writeFile(outputFile, csvData, 'utf8');
+
+    const elapsed = Date.now() - startTime;
+    if (!options.silent) {
+      console.log(
+        color(
+          `✓ Converted ${jsonData.length.toLocaleString()} records in ${elapsed}ms`,
+          'green'
+        )
+      );
+      console.log(
+        color(
+          `  Output: ${outputFile} (${csvData.length.toLocaleString()} bytes)`,
+          'dim'
+        )
+      );
+    }
+
+    return {
+      records: jsonData.length,
+      bytes: csvData.length,
+      time: elapsed
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function convertCsvToNdjson(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+
+  try {
+    if (!options.silent) {
+      console.log(color('Converting CSV to NDJSON...', 'dim'));
+    }
+
+    // Prepare options for jtcsv
+    const jtcsvOptions = {
+      delimiter: options.delimiter,
+      autoDetect: options.autoDetect,
+      candidates: options.candidates,
+      hasHeaders: options.hasHeaders,
+      renameMap: options.renameMap,
+      trim: options.trim,
+      parseNumbers: options.parseNumbers,
+      parseBooleans: options.parseBooleans
+    };
+
+    // Read and convert CSV
+    const jsonData = await jtcsv.readCsvAsJson(inputFile, jtcsvOptions);
+
+    // Convert to NDJSON
+    const ndjsonData = jtcsv.jsonToNdjson(jsonData);
+
+    // Write output file
+    await fs.promises.writeFile(outputFile, ndjsonData, 'utf8');
+
+    const elapsed = Date.now() - startTime;
+    if (!options.silent) {
+      console.log(
+        color(
+          `✓ Converted ${jsonData.length.toLocaleString()} rows in ${elapsed}ms`,
+          'green'
+        )
+      );
+      console.log(
+        color(
+          `  Output: ${outputFile} (${ndjsonData.length.toLocaleString()} bytes)`,
+          'dim'
+        )
+      );
+    }
+
+    return {
+      rows: jsonData.length,
+      bytes: ndjsonData.length,
+      time: elapsed
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function convertNdjsonToJson(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+
+  try {
+    if (!options.silent) {
+      console.log(color('Converting NDJSON to JSON array...', 'dim'));
+    }
+
+    // Read NDJSON file
+    const inputData = await fs.promises.readFile(inputFile, 'utf8');
+    const jsonData = jtcsv.ndjsonToJson(inputData);
+
+    // Format JSON
+    const jsonOutput = options.pretty
+      ? JSON.stringify(jsonData, null, 2)
+      : JSON.stringify(jsonData);
+
+    // Write output file
+    await fs.promises.writeFile(outputFile, jsonOutput, 'utf8');
+
+    const elapsed = Date.now() - startTime;
+    if (!options.silent) {
+      console.log(
+        color(
+          `✓ Converted ${jsonData.length.toLocaleString()} records in ${elapsed}ms`,
+          'green'
+        )
+      );
+      console.log(
+        color(
+          `  Output: ${outputFile} (${jsonOutput.length.toLocaleString()} bytes)`,
+          'dim'
+        )
+      );
+    }
+
+    return {
+      records: jsonData.length,
+      bytes: jsonOutput.length,
+      time: elapsed
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function convertJsonToNdjson(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+
+  try {
+    if (!options.silent) {
+      console.log(color('Converting JSON array to NDJSON...', 'dim'));
+    }
+
+    // Read JSON file
+    const inputData = await fs.promises.readFile(inputFile, 'utf8');
+    const jsonData = JSON.parse(inputData);
+
+    if (!Array.isArray(jsonData)) {
+      throw new Error('JSON data must be an array of objects');
+    }
+
+    // Convert to NDJSON
+    const ndjsonData = jtcsv.jsonToNdjson(jsonData);
+
+    // Write output file
+    await fs.promises.writeFile(outputFile, ndjsonData, 'utf8');
+
+    const elapsed = Date.now() - startTime;
+    if (!options.silent) {
+      console.log(
+        color(
+          `✓ Converted ${jsonData.length.toLocaleString()} records in ${elapsed}ms`,
+          'green'
+        )
+      );
+      console.log(
+        color(
+          `  Output: ${outputFile} (${ndjsonData.length.toLocaleString()} bytes)`,
+          'dim'
+        )
+      );
+    }
+
+    return {
+      records: jsonData.length,
+      bytes: ndjsonData.length,
+      time: elapsed
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// UNWRAP/FLATTEN FUNCTION
+// ============================================================================
+
+async function unwrapJson(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+
+  try {
+    if (!options.silent) {
+      console.log(color('Unwrapping/flattening nested JSON...', 'dim'));
+    }
+
+    // Read JSON file
+    const inputData = await fs.promises.readFile(inputFile, 'utf8');
+    const jsonData = JSON.parse(inputData);
+
+    const maxDepth = options.maxDepth || 10;
+    const separator = options.flattenPrefix || '_';
+
+    // Flatten function
+    const flattenObject = (obj: any, prefix = '', depth = 0): any => {
+      if (depth >= maxDepth) {
+        return { [prefix.slice(0, -1)]: JSON.stringify(obj) };
+      }
+
+      const result = {};
+
+      for (const [key, value] of Object.entries(obj)) {
+        const newKey = prefix + key;
+
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+          Object.assign(result, flattenObject(value, newKey + separator, depth + 1));
+        } else if (Array.isArray(value)) {
+          // Flatten arrays
+          if (options.unwrapArrays) {
+            (result as any)[newKey] = value.join(', ');
+          } else {
+            (result as any)[newKey] = JSON.stringify(value);
+          }
+        } else {
+          (result as any)[newKey] = value;
+        }
+      }
+
+      return result;
+    }
+
+    let unwrappedData;
+    if (Array.isArray(jsonData)) {
+      unwrappedData = jsonData.map(item => flattenObject(item));
+      if (!options.silent) {
+        console.log(
+          color(`Processing ${jsonData.length.toLocaleString()} records...`, 'dim')
+        );
+      }
+    } else {
+      unwrappedData = flattenObject(jsonData);
+    }
+
+    // Format JSON
+    const jsonOutput = options.pretty
+      ? JSON.stringify(unwrappedData, null, 2)
+      : JSON.stringify(unwrappedData);
+
+    // Write output file
+    await fs.promises.writeFile(outputFile, jsonOutput, 'utf8');
+
+    const elapsed = Date.now() - startTime;
+    const recordCount = Array.isArray(unwrappedData) ? unwrappedData.length : 1;
+    
+    if (!options.silent) {
+      console.log(
+        color(
+          `✓ Unwrapped ${recordCount.toLocaleString()} record(s) in ${elapsed}ms`,
+          'green'
+        )
+      );
+      console.log(
+        color(
+          `  Output: ${outputFile} (${jsonOutput.length.toLocaleString()} bytes)`,
+          'dim'
+        )
+      );
+    }
+
+    return {
+      records: recordCount,
+      bytes: jsonOutput.length,
+      time: elapsed
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function preprocessJson(inputFile, outputFile, options: any): Promise<ConversionResult> {
+  const startTime = Date.now();
+
+  try {
+    // Read input file
+    const inputData = await fs.promises.readFile(inputFile, 'utf8');
+    const jsonData = JSON.parse(inputData);
+
+    if (!Array.isArray(jsonData)) {
+      throw new Error(
+        'JSON data must be an array of objects for preprocessing'
+      );
+    }
+
+    if (!options.silent) {
+      console.log(
+        color(
+          `Preprocessing ${jsonData.length.toLocaleString()} records...`,
+          'dim'
+        )
+      );
+    }
+
+    // Preprocess data
+    const processedData = jtcsv.preprocessData(jsonData);
+
+    // Apply transform if specified
+    let transformedData = processedData;
+    if (options.transform) {
+      if (!options.silent) {
+        console.log(
+          color(`Applying transform from: ${options.transform}`, 'dim')
+        );
+      }
+      try {
+        transformedData = transformLoader.applyTransform(
+          processedData,
+          options.transform
+        );
+        if (!options.silent) {
+          console.log(
+            color(
+              `✓ Transform applied to ${transformedData.length} records`,
+              'green'
+            )
+          );
+        }
+      } catch (transformError: any) {
+        console.error(
+          color(`✗ Transform error: ${transformError.message}`, 'red')
+        );
+        if (options.debug) {
+          console.error(transformError.stack);
+        }
+        process.exit(1);
+      }
+    }
+
+    // Apply deep unwrap if needed
+    if (options.unwrapArrays || options.stringifyObjects) {
+      const maxDepth = options.maxDepth || 5;
+      transformedData.forEach((item) => {
+        for (const key in item) {
+          if (item[key] && typeof item[key] === 'object') {
+            item[key] = jtcsv.deepUnwrap(item[key]); // depth removed for compatibility
+          }
+        }
+      });
+    }
+
+    // Format JSON
+    const jsonOutput = options.pretty
+      ? JSON.stringify(transformedData, null, 2)
+      : JSON.stringify(transformedData);
+
+    // Write output file
+    await fs.promises.writeFile(outputFile, jsonOutput, 'utf8');
+
+    const elapsed = Date.now() - startTime;
+    if (!options.silent) {
+      console.log(
+        color(
+          `✓ Preprocessed ${transformedData.length.toLocaleString()} records in ${elapsed}ms`,
+          'green'
+        )
+      );
+      console.log(
+        color(
+          `  Output: ${outputFile} (${jsonOutput.length.toLocaleString()} bytes)`,
+          'dim'
+        )
+      );
+    }
+
+    return {
+      records: transformedData.length,
+      bytes: jsonOutput.length,
+      time: elapsed
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// STREAMING FUNCTIONS
+// ============================================================================
+
+async function streamJsonToCsv(inputFile, outputFile, options: any): Promise<void> {
+  const startTime = Date.now();
+  let recordCount = 0;
+
+  try {
+    if (!options.silent) {
+      console.log(color('Streaming JSON to CSV...', 'dim'));
+    }
+
+    // Create streams
+    const readStream = fs.createReadStream(inputFile, 'utf8');
+    const writeStream = fs.createWriteStream(outputFile, 'utf8');
+
+    // Add UTF-8 BOM if requested
+    if (options.addBOM) {
+      writeStream.write('\uFEFF');
+    }
+
+    // Parse JSON stream
+    let buffer = '';
+    const isFirstChunk = true;
+    let headersWritten = false;
+
+    readStream.on('data', (chunk) => {
+      buffer += chunk;
+
+      // Try to parse complete JSON objects
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const obj = JSON.parse(line);
+            // Apply renameMap if provided
+            let finalObj = obj;
+            if (options.renameMap) {
+              const renameMap = options.renameMap as Record<string, string>;
+              finalObj = {};
+              for (const [oldKey, newKey] of Object.entries(renameMap)) {
+                if (oldKey in obj) {
+                  (finalObj as any)[newKey] = (obj as any)[oldKey];
+                }
+              }
+              // Copy remaining fields
+              for (const [key, value] of Object.entries(obj)) {
+                if (!(key in renameMap)) {
+                  (finalObj as any)[key] = value;
+                }
+              }
+            }
+            recordCount++;
+
+            // Write headers on first object
+            if (!headersWritten && options.includeHeaders !== false) {
+              const headers = Object.keys(finalObj);
+              writeStream.write(headers.join(options.delimiter || ';') + '\n');
+              headersWritten = true;
+            }
+
+            // Write CSV row
+            const row =
+              Object.values(finalObj)
+                .map((value) => {
+                  const str = String(value);
+                  if (
+                    str.includes(options.delimiter || ';') ||
+                    str.includes('"') ||
+                    str.includes('\n')
+                  ) {
+                    return `"${str.replace(/"/g, '""')}"`;
+                  }
+                  return str;
+                })
+                .join(options.delimiter || ';') + '\n';
+
+            writeStream.write(row);
+
+            // Show progress
+            if (options.verbose && recordCount % 10000 === 0) {
+              process.stdout.write(
+                color(
+                  `  Processed ${recordCount.toLocaleString()} records\r`,
+                  'dim'
+                )
+              );
+            }
+          } catch (error: any) {
+            // Skip invalid JSON lines
+            if (options.debug) {
+              console.warn(
+                color(
+                  `  Warning: Skipping invalid JSON line: ${error.message}`,
+                  'yellow'
+                )
+              );
+            }
+          }
+        }
+      }
+    });
+
+    readStream.on('end', async () => {
+      // Process remaining buffer
+      if (buffer.trim()) {
+        try {
+          const obj = JSON.parse(buffer);
+
+          // Apply renameMap if provided
+          let finalObj = obj;
+          if (options.renameMap) {
+            const renameMap = options.renameMap as Record<string, string>;
+            finalObj = {};
+            for (const [oldKey, newKey] of Object.entries(renameMap)) {
+              if (oldKey in obj) {
+                (finalObj as any)[newKey] = (obj as any)[oldKey];
+              }
+            }
+            // Copy remaining fields
+            for (const [key, value] of Object.entries(obj)) {
+              if (!(key in renameMap)) {
+                (finalObj as any)[key] = value;
+              }
+            }
+          }
+
+          recordCount++;
+
+          if (!headersWritten && options.includeHeaders !== false) {
+            const headers = Object.keys(finalObj);
+            writeStream.write(headers.join(options.delimiter || ';') + '\n');
+          }
+
+          const row =
+            Object.values(finalObj)
+              .map((value) => {
+                const str = String(value);
+                if (
+                  str.includes(options.delimiter || ';') ||
+                  str.includes('"') ||
+                  str.includes('\n')
+                ) {
+                  return `"${str.replace(/"/g, '""')}"`;
+                }
+                return str;
+              })
+              .join(options.delimiter || ';') + '\n';
+
+          writeStream.write(row);
+        } catch (error: any) {
+          // Skip invalid JSON
+        }
+      }
+
+      writeStream.end();
+
+      // Wait for write stream to finish
+      await new Promise<void>((resolve) =>
+        writeStream.on('finish', () => resolve())
+      );
+
+      const elapsed = Date.now() - startTime;
+      if (!options.silent) {
+        console.log(
+          color(
+            `\n✓ Streamed ${recordCount.toLocaleString()} records in ${elapsed}ms`,
+            'green'
+          )
+        );
+        console.log(color(`  Output: ${outputFile}`, 'dim'));
+      }
+    });
+
+    readStream.on('error', (error) => {
+      console.error(color(`✗ Stream error: ${error.message}`, 'red'));
+      process.exit(1);
+    });
+
+    writeStream.on('error', (error) => {
+      console.error(color(`✗ Write error: ${error.message}`, 'red'));
+      process.exit(1);
+    });
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function streamCsvToJson(inputFile, outputFile, options: any): Promise<void> {
+  const startTime = Date.now();
+  let rowCount = 0;
+
+  try {
+    if (!options.silent) {
+      console.log(color('Streaming CSV to JSON...', 'dim'));
+    }
+
+    // Create streams
+    const readStream = fs.createReadStream(inputFile, 'utf8');
+    const writeStream = fs.createWriteStream(outputFile, 'utf8');
+
+    // Write JSON array opening bracket
+    writeStream.write('[\n');
+
+    let buffer = '';
+    let isFirstRow = true;
+    let headers = [];
+
+    readStream.on('data', (chunk) => {
+      buffer += chunk;
+
+      // Process complete lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line) {
+          continue;
+        }
+
+        rowCount++;
+
+        // Parse CSV line
+        const fields = parseCsvLineSimple(line, options.delimiter || ';');
+
+        // First row might be headers
+        if (rowCount === 1 && options.hasHeaders !== false) {
+          headers = fields;
+          continue;
+        }
+
+        // Create JSON object
+        const obj = {};
+        const fieldCount = Math.min(fields.length, headers.length);
+
+        for (let j = 0; j < fieldCount; j++) {
+          const header = headers[j] || `column${j + 1}`;
+          // Apply renameMap if provided
+          let finalHeader = header;
+          if (options.renameMap && options.renameMap[header]) {
+            finalHeader = options.renameMap[header];
+          }
+
+          let value = fields[j];
+
+          // Parse numbers if enabled
+          if (options.parseNumbers) {
+            // Fast numeric detection
+            const trimmed = value.trim();
+            const firstChar = trimmed.charAt(0);
+            if ((firstChar >= '0' && firstChar <= '9') || firstChar === '-' || firstChar === '.') {
+              const num = parseFloat(trimmed);
+              if (!isNaN(num) && isFinite(num)) {
+                if (String(num) === trimmed || (trimmed.includes('.') && !isNaN(Number(trimmed)))) {
+                  value = num;
+                }
+              }
+            }
+          }
+
+          // Parse booleans if enabled
+          if (options.parseBooleans) {
+            const lowerValue = value.toLowerCase();
+            if (lowerValue === 'true') {
+              value = true;
+            }
+            if (lowerValue === 'false') {
+              value = false;
+            }
+          }
+
+          obj[finalHeader] = value;
+        }
+
+        // Write JSON object
+        const jsonStr = JSON.stringify(obj);
+        if (!isFirstRow) {
+          writeStream.write(',\n');
+        }
+        writeStream.write('  ' + jsonStr);
+        isFirstRow = false;
+
+        // Show progress
+        if (options.verbose && rowCount % 10000 === 0) {
+          process.stdout.write(
+            color(`  Processed ${rowCount.toLocaleString()} rows\r`, 'dim')
+          );
+        }
+      }
+    });
+
+    readStream.on('end', async () => {
+      // Process remaining buffer
+      if (buffer.trim()) {
+        const fields = parseCsvLineSimple(
+          buffer.trim(),
+          options.delimiter || ';'
+        );
+
+        if (fields.length > 0) {
+          rowCount++;
+
+          // Skip if it's headers
+          if (!(rowCount === 1 && options.hasHeaders !== false)) {
+            const obj = {};
+            const fieldCount = Math.min(fields.length, headers.length);
+
+            for (let j = 0; j < fieldCount; j++) {
+              const header = headers[j] || `column${j + 1}`;
+              // Apply renameMap if provided
+              let finalHeader = header;
+              if (options.renameMap && options.renameMap[header]) {
+                finalHeader = options.renameMap[header];
+              }
+              obj[finalHeader] = fields[j];
+            }
+
+            const jsonStr = JSON.stringify(obj);
+            if (!isFirstRow) {
+              writeStream.write(',\n');
+            }
+            writeStream.write('  ' + jsonStr);
+          }
+        }
+      }
+
+      // Write JSON array closing bracket
+      writeStream.write('\n]');
+      writeStream.end();
+
+      // Wait for write stream to finish
+      await new Promise<void>((resolve) =>
+        writeStream.on('finish', () => resolve())
+      );
+
+      const elapsed = Date.now() - startTime;
+      if (!options.silent) {
+        console.log(
+          color(
+            `\n✓ Streamed ${(rowCount - (options.hasHeaders !== false ? 1 : 0)).toLocaleString()} rows in ${elapsed}ms`,
+            'green'
+          )
+        );
+        console.log(color(`  Output: ${outputFile}`, 'dim'));
+      }
+    });
+
+    readStream.on('error', (error) => {
+      console.error(color(`✗ Stream error: ${error.message}`, 'red'));
+      process.exit(1);
+    });
+
+    writeStream.on('error', (error) => {
+      console.error(color(`✗ Write error: ${error.message}`, 'red'));
+      process.exit(1);
+    });
+  } catch (error: any) {
+    console.error(color(`✗ Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// Simple CSV line parser for streaming
+function parseCsvLineSimple(line, delimiter: any): any {
+  const fields = [];
+  let currentField = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+
+    if (char === '"') {
+      if (inQuotes && i + 1 < line.length && line[i + 1] === '"') {
+        // Escaped quote
+        currentField += '"';
+        i++;
+      } else {
+        // Toggle quotes
+        inQuotes = !inQuotes;
+      }
+    } else if (char === delimiter && !inQuotes) {
+      fields.push(currentField);
+      currentField = '';
+    } else {
+      currentField += char;
+    }
+  }
+
+  fields.push(currentField);
+  return fields;
+}
+
+// ============================================================================
+// BATCH PROCESSING FUNCTIONS
+// ============================================================================
+
+async function batchJsonToCsv(inputPattern, outputDir, options: any): Promise<BatchSummary> {
+  const startTime = Date.now();
+
+  try {
+    let glob;
+    try {
+      glob = require('glob');
+    } catch (error: any) {
+      console.error(
+        color(
+          '✗ Error: The "glob" module is required for batch processing',
+          'red'
+        )
+      );
+      console.error(color('  Install it with: npm install glob', 'cyan'));
+      console.error(color('  Or update jtcsv: npm update jtcsv', 'cyan'));
+      process.exit(1);
+    }
+    const files = glob.sync(inputPattern, {
+      absolute: true,
+      nodir: true
+    });
+
+    if (files.length === 0) {
+      console.error(
+        color(`✗ No files found matching pattern: ${inputPattern}`, 'red')
+      );
+      process.exit(1);
+    }
+
+    if (!options.silent) {
+      console.log(color(`Found ${files.length} files to process...`, 'dim'));
+    }
+
+    // Create output directory if it doesn't exist
+    await fs.promises.mkdir(outputDir, { recursive: true });
+
+    const results: BatchFileResult[] = [];
+    const parallelLimit = options.parallel || 4;
+
+    // Process files in parallel batches
+    for (let i = 0; i < files.length; i += parallelLimit) {
+      const batch = files.slice(i, i + parallelLimit);
+      const promises = batch.map(async (file) => {
+        const fileName = path.basename(file, '.json');
+        const outputFile = path.join(outputDir, `${fileName}.csv`);
+
+        if (!options.silent && options.verbose) {
+          console.log(color(`  Processing: ${file}`, 'dim'));
+        }
+
+        try {
+          const result = await convertJsonToCsv(file, outputFile, {
+            ...options,
+            silent: true // Suppress individual file output
+          });
+
+          if (!options.silent) {
+            console.log(
+              color(
+                `  ✓ ${fileName}.json → ${fileName}.csv (${result.records} records)`,
+                'green'
+              )
+            );
+          }
+
+          return { file, success: true, ...result };
+        } catch (error: any) {
+          if (!options.silent) {
+            console.log(color(`  ✗ ${fileName}.json: ${error.message}`, 'red'));
+          }
+          return { file, success: false, error: error.message };
+        }
+      });
+
+      const batchResults = await Promise.all(promises);
+      results.push(...batchResults);
+
+      if (!options.silent) {
+        const processed = i + batch.length;
+        const percent = Math.round((processed / files.length) * 100);
+        console.log(
+          color(
+            `  Progress: ${processed}/${files.length} (${percent}%)`,
+            'dim'
+          )
+        );
+      }
+    }
+
+    const elapsed = Date.now() - startTime;
+    const successful = results.filter((r) => r.success).length;
+    const totalRecords = results
+      .filter((r) => r.success)
+      .reduce((sum, r) => sum + (r.records || 0), 0);
+
+    if (!options.silent) {
+      console.log(
+        color(`\n✓ Batch processing completed in ${elapsed}ms`, 'green')
+      );
+      console.log(
+        color(`  Successful: ${successful}/${files.length} files`, 'dim')
+      );
+      console.log(
+        color(`  Total records: ${totalRecords.toLocaleString()}`, 'dim')
+      );
+      console.log(color(`  Output directory: ${outputDir}`, 'dim'));
+    }
+
+    return {
+      totalFiles: files.length,
+      successful,
+      totalRecords,
+      time: elapsed,
+      results
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Batch processing error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function batchCsvToJson(inputPattern, outputDir, options: any): Promise<BatchSummary> {
+  const startTime = Date.now();
+
+  try {
+    let glob;
+    try {
+      glob = require('glob');
+    } catch (error: any) {
+      console.error(
+        color(
+          '✗ Error: The "glob" module is required for batch processing',
+          'red'
+        )
+      );
+      console.error(color('  Install it with: npm install glob', 'cyan'));
+      console.error(color('  Or update jtcsv: npm update jtcsv', 'cyan'));
+      process.exit(1);
+    }
+    const files = glob.sync(inputPattern, {
+      absolute: true,
+      nodir: true
+    });
+
+    if (files.length === 0) {
+      console.error(
+        color(`✗ No files found matching pattern: ${inputPattern}`, 'red')
+      );
+      process.exit(1);
+    }
+
+    if (!options.silent) {
+      console.log(color(`Found ${files.length} files to process...`, 'dim'));
+    }
+
+    // Create output directory if it doesn't exist
+    await fs.promises.mkdir(outputDir, { recursive: true });
+
+    const results: BatchFileResult[] = [];
+    const parallelLimit = options.parallel || 4;
+
+    // Process files in parallel batches
+    for (let i = 0; i < files.length; i += parallelLimit) {
+      const batch = files.slice(i, i + parallelLimit);
+      const promises = batch.map(async (file) => {
+        const fileName = path.basename(file, '.csv');
+        const outputFile = path.join(outputDir, `${fileName}.json`);
+
+        if (!options.silent && options.verbose) {
+          console.log(color(`  Processing: ${file}`, 'dim'));
+        }
+
+        try {
+          const result = await convertCsvToJson(file, outputFile, {
+            ...options,
+            silent: true // Suppress individual file output
+          });
+
+          if (!options.silent) {
+            console.log(
+              color(
+                `  ✓ ${fileName}.csv → ${fileName}.json (${result.rows} rows)`,
+                'green'
+              )
+            );
+          }
+
+          return { file, success: true, ...result };
+        } catch (error: any) {
+          if (!options.silent) {
+            console.log(color(`  ✗ ${fileName}.csv: ${error.message}`, 'red'));
+          }
+          return { file, success: false, error: error.message };
+        }
+      });
+
+      const batchResults = await Promise.all(promises);
+      results.push(...batchResults);
+
+      if (!options.silent) {
+        const processed = i + batch.length;
+        const percent = Math.round((processed / files.length) * 100);
+        console.log(
+          color(
+            `  Progress: ${processed}/${files.length} (${percent}%)`,
+            'dim'
+          )
+        );
+      }
+    }
+
+    const elapsed = Date.now() - startTime;
+    const successful = results.filter((r) => r.success).length;
+    const totalRows = results
+      .filter((r) => r.success)
+      .reduce((sum, r) => sum + (r.rows || 0), 0);
+
+    if (!options.silent) {
+      console.log(
+        color(`\n✓ Batch processing completed in ${elapsed}ms`, 'green')
+      );
+      console.log(
+        color(`  Successful: ${successful}/${files.length} files`, 'dim')
+      );
+      console.log(color(`  Total rows: ${totalRows.toLocaleString()}`, 'dim'));
+      console.log(color(`  Output directory: ${outputDir}`, 'dim'));
+    }
+
+    return {
+      totalFiles: files.length,
+      successful,
+      totalRows,
+      time: elapsed,
+      results
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Batch processing error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function batchProcessMixed(inputPattern, outputDir, options: any): Promise<BatchSummary> {
+  const startTime = Date.now();
+
+  try {
+    let glob;
+    try {
+      glob = require('glob');
+    } catch (error: any) {
+      console.error(
+        color(
+          '✗ Error: The "glob" module is required for batch processing',
+          'red'
+        )
+      );
+      console.error(color('  Install it with: npm install glob', 'cyan'));
+      console.error(color('  Or update jtcsv: npm update jtcsv', 'cyan'));
+      process.exit(1);
+    }
+
+    // Находим все файлы
+    const files = glob.sync(inputPattern, {
+      absolute: true,
+      nodir: true
+    });
+
+    if (files.length === 0) {
+      console.error(
+        color(`✗ No files found matching pattern: ${inputPattern}`, 'red')
+      );
+      process.exit(1);
+    }
+
+    if (!options.silent) {
+      console.log(color(`Found ${files.length} files to process...`, 'dim'));
+    }
+
+    // Создаем выходную директорию
+    await fs.promises.mkdir(outputDir, { recursive: true });
+
+    const results: BatchFileResult[] = [];
+    const parallelLimit = options.parallel || 4;
+
+    // Группируем файлы по типу
+    const jsonFiles = files.filter((file) =>
+      file.toLowerCase().endsWith('.json')
+    );
+    const csvFiles = files.filter((file) =>
+      file.toLowerCase().endsWith('.csv')
+    );
+    const otherFiles = files.filter(
+      (file) =>
+        !file.toLowerCase().endsWith('.json') &&
+        !file.toLowerCase().endsWith('.csv')
+    );
+
+    if (otherFiles.length > 0 && !options.silent) {
+      console.log(
+        color(
+          `  Warning: Skipping ${otherFiles.length} non-JSON/CSV files`,
+          'yellow'
+        )
+      );
+    }
+
+    // Обрабатываем JSON файлы
+    for (let i = 0; i < jsonFiles.length; i += parallelLimit) {
+      const batch = jsonFiles.slice(i, i + parallelLimit);
+      const promises = batch.map(async (file) => {
+        const fileName = path.basename(file, '.json');
+        const outputFile = path.join(outputDir, `${fileName}.csv`);
+
+        if (!options.silent && options.verbose) {
+          console.log(color(`  Processing JSON: ${file}`, 'dim'));
+        }
+
+        try {
+          const result = await convertJsonToCsv(file, outputFile, {
+            ...options,
+            silent: true
+          });
+
+          if (!options.silent) {
+            console.log(
+              color(
+                `  ✓ ${fileName}.json → ${fileName}.csv (${result.records} records)`,
+                'green'
+              )
+            );
+          }
+
+          return { file, type: 'json', success: true, ...result };
+        } catch (error: any) {
+          if (!options.silent) {
+            console.log(color(`  ✗ ${fileName}.json: ${error.message}`, 'red'));
+          }
+          return { file, type: 'json', success: false, error: error.message };
+        }
+      });
+
+      const batchResults = await Promise.all(promises);
+      results.push(...batchResults);
+    }
+
+    // Обрабатываем CSV файлы
+    for (let i = 0; i < csvFiles.length; i += parallelLimit) {
+      const batch = csvFiles.slice(i, i + parallelLimit);
+      const promises = batch.map(async (file) => {
+        const fileName = path.basename(file, '.csv');
+        const outputFile = path.join(outputDir, `${fileName}.json`);
+
+        if (!options.silent && options.verbose) {
+          console.log(color(`  Processing CSV: ${file}`, 'dim'));
+        }
+
+        try {
+          const result = await convertCsvToJson(file, outputFile, {
+            ...options,
+            silent: true
+          });
+
+          if (!options.silent) {
+            console.log(
+              color(
+                `  ✓ ${fileName}.csv → ${fileName}.json (${result.rows} rows)`,
+                'green'
+              )
+            );
+          }
+
+          return { file, type: 'csv', success: true, ...result };
+        } catch (error: any) {
+          if (!options.silent) {
+            console.log(color(`  ✗ ${fileName}.csv: ${error.message}`, 'red'));
+          }
+          return { file, type: 'csv', success: false, error: error.message };
+        }
+      });
+
+      const batchResults = await Promise.all(promises);
+      results.push(...batchResults);
+    }
+
+    const elapsed = Date.now() - startTime;
+    const successful = results.filter((r) => r.success).length;
+    const totalRecords = results
+      .filter((r) => r.success)
+      .reduce((sum, r) => sum + (r.records || r.rows || 0), 0);
+
+    if (!options.silent) {
+      console.log(
+        color(`\n✓ Mixed batch processing completed in ${elapsed}ms`, 'green')
+      );
+      console.log(
+        color(`  Successful: ${successful}/${files.length} files`, 'dim')
+      );
+      console.log(
+        color(
+          `  JSON files: ${jsonFiles.length}, CSV files: ${csvFiles.length}`,
+          'dim'
+        )
+      );
+      console.log(
+        color(`  Total records: ${totalRecords.toLocaleString()}`, 'dim')
+      );
+      console.log(color(`  Output directory: ${outputDir}`, 'dim'));
+    }
+
+    return {
+      totalFiles: files.length,
+      jsonFiles: jsonFiles.length,
+      csvFiles: csvFiles.length,
+      otherFiles: otherFiles.length,
+      successful,
+      totalRecords,
+      time: elapsed,
+      results
+    };
+  } catch (error: any) {
+    console.error(color(`✗ Batch processing error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// OPTIONS PARSING
+// ============================================================================
+
+function parseOptions(args: any): any {
+  const options = {
+    delimiter: ';',
+    autoDetect: true,
+    candidates: [';', ',', '\t', '|'],
+    hasHeaders: true,
+    includeHeaders: true,
+    renameMap: undefined,
+    template: undefined,
+    trim: true,
+    parseNumbers: false,
+    parseBooleans: false,
+    useFastPath: true,
+    fastPathMode: 'objects',
+    repairRowShifts: true,
+    normalizeQuotes: true,
+    preventCsvInjection: true,
+    rfc4180Compliant: true,
+    maxRecords: undefined,
+    maxRows: undefined,
+    maxDepth: 5,
+    pretty: false,
+    silent: false,
+    verbose: false,
+    debug: false,
+    dryRun: false,
+    addBOM: false,
+    unwrapArrays: false,
+    stringifyObjects: false,
+    recursive: false,
+    pattern: '**/*',
+    outputDir: './output',
+    patternProvided: false,
+    outputDirProvided: false,
+    overwrite: false,
+    parallel: 4,
+    chunkSize: 65536,
+    bufferSize: 1000,
+    schema: undefined,
+    transform: undefined,
+    flattenPrefix: '_',
+    flatten: false,
+    flattenSeparator: '.',
+    flattenMaxDepth: 3,
+    arrayHandling: 'stringify',
+    port: 3000,
+    host: 'localhost'
+  };
+
+  const files = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg.startsWith('--')) {
+      const [key, value] = arg.slice(2).split('=');
+
+      switch (key) {
+      case 'delimiter':
+        options.delimiter = value || ',';
+        options.autoDetect = false;
+        break;
+      case 'auto-detect':
+        options.autoDetect = value !== 'false';
+        break;
+      case 'candidates':
+        options.candidates = value ? value.split(',') : [';', ',', '\t', '|'];
+        break;
+      case 'no-headers':
+        options.includeHeaders = false;
+        options.hasHeaders = false;
+        break;
+      case 'parse-numbers':
+        options.parseNumbers = true;
+        break;
+      case 'parse-booleans':
+        options.parseBooleans = true;
+        break;
+      case 'no-trim':
+        options.trim = false;
+        break;
+      case 'no-fast-path':
+        options.useFastPath = false;
+        break;
+      case 'fast-path':
+        options.useFastPath = value !== 'false';
+        break;
+      case 'fast-path-mode':
+        options.fastPathMode = value || 'objects';
+        if (
+          options.fastPathMode !== 'objects' &&
+            options.fastPathMode !== 'compact'
+        ) {
+          throw new Error('Invalid --fast-path-mode value (objects|compact)');
+        }
+        break;
+      case 'repair-row-shifts':
+        options.repairRowShifts = true;
+        break;
+      case 'normalize-quotes':
+        options.normalizeQuotes = true;
+        break;
+      case 'rename':
+        try {
+          const jsonStr = value || '{}';
+          const cleanStr = jsonStr
+            .replace(/^'|'$/g, '')
+            .replace(/^"|"$/g, '');
+          options.renameMap = JSON.parse(cleanStr);
+        } catch (e) {
+          throw new Error(`Invalid JSON in --rename option: ${e.message}`);
+        }
+        break;
+      case 'template':
+        try {
+          const jsonStr = value || '{}';
+          const cleanStr = jsonStr
+            .replace(/^'|'$/g, '')
+            .replace(/^"|"$/g, '');
+          options.template = JSON.parse(cleanStr);
+        } catch (e) {
+          throw new Error(`Invalid JSON in --template option: ${e.message}`);
+        }
+        break;
+      case 'no-injection-protection':
+        options.preventCsvInjection = false;
+        break;
+      case 'no-rfc4180':
+        options.rfc4180Compliant = false;
+        break;
+      case 'max-records':
+        options.maxRecords = parseInt(value, 10);
+        break;
+      case 'max-rows':
+        options.maxRows = parseInt(value, 10);
+        break;
+      case 'max-depth':
+        options.maxDepth = parseInt(value, 10) || 5;
+        break;
+      case 'pretty':
+        options.pretty = true;
+        break;
+      case 'flatten':
+        options.flatten = true;
+        break;
+      case 'flatten-separator':
+        options.flattenSeparator = value || '.';
+        break;
+      case 'flatten-max-depth':
+        options.flattenMaxDepth = parseInt(value, 10) || 3;
+        break;
+      case 'array-handling':
+        options.arrayHandling = value || 'stringify';
+        if (!['stringify', 'join', 'expand'].includes(options.arrayHandling)) {
+          throw new Error('Invalid --array-handling value (stringify|join|expand)');
+        }
+        break;
+      case 'silent':
+        options.silent = true;
+        break;
+      case 'verbose':
+        options.verbose = true;
+        break;
+      case 'debug':
+        options.debug = true;
+        break;
+      case 'dry-run':
+        options.dryRun = true;
+        break;
+      case 'add-bom':
+        options.addBOM = true;
+        break;
+      case 'unwrap-arrays':
+        options.unwrapArrays = true;
+        break;
+      case 'stringify-objects':
+        options.stringifyObjects = true;
+        break;
+      case 'recursive':
+        options.recursive = true;
+        break;
+      case 'pattern':
+        options.pattern = value || '**/*';
+        options.patternProvided = true;
+        break;
+      case 'output-dir':
+        options.outputDir = value || './output';
+        options.outputDirProvided = true;
+        break;
+      case 'overwrite':
+        options.overwrite = true;
+        break;
+      case 'parallel':
+        options.parallel = parseInt(value, 10) || 4;
+        break;
+      case 'chunk-size':
+        options.chunkSize = parseInt(value, 10) || 65536;
+        break;
+      case 'buffer-size':
+        options.bufferSize = parseInt(value, 10) || 1000;
+        break;
+      case 'schema':
+        try {
+          const jsonStr = value || '{}';
+          const cleanStr = jsonStr
+            .replace(/^'|'$/g, '')
+            .replace(/^"|"$/g, '');
+          options.schema = JSON.parse(cleanStr);
+        } catch (e) {
+          throw new Error(`Invalid JSON in --schema option: ${e.message}`);
+        }
+        break;
+      case 'transform':
+        options.transform = value;
+        break;
+      case 'port':
+        options.port = parseInt(value, 10) || 3000;
+        break;
+      case 'host':
+        options.host = value || 'localhost';
+        break;
+      }
+    } else if (arg === '-' || !arg.startsWith('-')) {
+      files.push(arg);
+    }
+  }
+
+  return { options, files };
+}
+
+// ============================================================================
+// TUI LAUNCHER
+// ============================================================================
+
+async function launchTUI(): Promise<void> {
+  try {
+    console.log(color('Launching Terminal User Interface...', 'cyan'));
+    console.log(color('Press Ctrl+Q to exit', 'dim'));
+
+    const JtcsvTUI = require('@jtcsv/tui');
+    const tui = new JtcsvTUI();
+    tui.start();
+  } catch (error: any) {
+    if (error.code === 'MODULE_NOT_FOUND') {
+      console.error(color('Error: @jtcsv/tui is not installed', 'red'));
+      console.log(color('Install it with:', 'dim'));
+      console.log(color('  npm install @jtcsv/tui', 'cyan'));
+      console.log(color('\nOr use the CLI interface instead:', 'dim'));
+      console.log(color('  jtcsv help', 'cyan'));
+    } else {
+      console.error(color(`Error: ${error.message}`, 'red'));
+    }
+    process.exit(1);
+  }
+}
+
+async function launchWebUI(options: any = {}): Promise<void> {
+  try {
+    const webServer = require('../src/web-server');
+    webServer.startServer({
+      port: options.port || 3000,
+      host: options.host || 'localhost'
+    });
+  } catch (error: any) {
+    console.error(color(`Error: ${error.message}`, 'red'));
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+async function startBasicTUI(): Promise<void> {
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.clear();
+  console.log(color('╔══════════════════════════════════════╗', 'cyan'));
+  console.log(color('║        JTCSV Terminal Interface      ║', 'cyan'));
+  console.log(color('╚══════════════════════════════════════╝', 'cyan'));
+  console.log();
+  console.log(color('Select operation:', 'bright'));
+  console.log('  1. JSON → CSV');
+  console.log('  2. CSV → JSON');
+  console.log('  3. Preprocess JSON');
+  console.log('  4. Batch Processing');
+  console.log('  5. Exit');
+  console.log();
+
+  rl.question(color('Enter choice (1-5): ', 'cyan'), async (choice) => {
+    switch (choice) {
+    case '1':
+      await runJsonToCsvTUI(rl);
+      break;
+    case '2':
+      await runCsvToJsonTUI(rl);
+      break;
+    case '3':
+      console.log(color('Preprocess feature coming soon...', 'yellow'));
+      rl.close();
+      break;
+    case '4':
+      console.log(color('Batch processing coming soon...', 'yellow'));
+      rl.close();
+      break;
+    case '5':
+      console.log(color('Goodbye!', 'green'));
+      rl.close();
+      process.exit(0);
+      break;
+    default:
+      console.log(color('Invalid choice', 'red'));
+      rl.close();
+      process.exit(1);
+    }
+  });
+}
+
+async function runJsonToCsvTUI(rl: any): Promise<void> {
+  console.clear();
+  console.log(color('JSON → CSV Conversion', 'cyan'));
+  console.log();
+
+  rl.question('Input JSON file: ', (inputFile) => {
+    rl.question('Output CSV file: ', async (outputFile) => {
+      rl.question('Delimiter (default: ;): ', async (delimiter) => {
+        try {
+          console.log(color('\nConverting...', 'dim'));
+
+          const result = await convertJsonToCsv(inputFile, outputFile, {
+            delimiter: delimiter || ';',
+            silent: false
+          });
+
+          console.log(color('\n✓ Conversion complete!', 'green'));
+          rl.question('\nPress Enter to continue...', () => {
+            rl.close();
+            startBasicTUI();
+          });
+        } catch (error: any) {
+          console.error(color(`✗ Error: ${error.message}`, 'red'));
+          rl.close();
+          process.exit(1);
+        }
+      });
+    });
+  });
+}
+
+async function runCsvToJsonTUI(rl: any): Promise<void> {
+  console.clear();
+  console.log(color('CSV → JSON Conversion', 'cyan'));
+  console.log();
+
+  rl.question('Input CSV file: ', (inputFile) => {
+    rl.question('Output JSON file: ', async (outputFile) => {
+      rl.question('Delimiter (default: ;): ', async (delimiter) => {
+        rl.question('Pretty print? (y/n): ', async (pretty) => {
+          try {
+            console.log(color('\nConverting...', 'dim'));
+
+            const result = await convertCsvToJson(inputFile, outputFile, {
+              delimiter: delimiter || ';',
+              pretty: pretty.toLowerCase() === 'y',
+              silent: false
+            });
+
+            console.log(color('\n✓ Conversion complete!', 'green'));
+            rl.question('\nPress Enter to continue...', () => {
+              rl.close();
+              startBasicTUI();
+            });
+          } catch (error: any) {
+            console.error(color(`✗ Error: ${error.message}`, 'red'));
+            rl.close();
+            process.exit(1);
+          }
+        });
+      });
+    });
+  });
+}
+
+// ============================================================================
+// MAIN FUNCTION
+// ============================================================================
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    showHelp();
+    return;
+  }
+
+  const command = args[0].toLowerCase();
+  const { options, files } = parseOptions(args.slice(1));
+
+  // Handle dry run
+  if (options.dryRun) {
+    console.log(color('DRY RUN - No files will be modified', 'yellow'));
+    console.log(`Command: ${command}`);
+    console.log(`Files: ${files.join(', ')}`);
+    console.log('Options:', options);
+    return;
+  }
+
+  // Suppress output if silent mode
+  if (options.silent) {
+    console.log = () => {};
+    console.info = () => {};
+  }
+
+  switch (command) {
+  // Main conversion commands
+  case 'json-to-csv':
+  case 'json2csv':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv json-to-csv input.json output.csv', 'cyan')
+      );
+      process.exit(1);
+    }
+    await convertJsonToCsv(files[0], files[1], options);
+    break;
+
+  case 'csv-to-json':
+  case 'csv2json':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv csv-to-json input.csv output.json', 'cyan')
+      );
+      process.exit(1);
+    }
+    await convertCsvToJson(files[0], files[1], options);
+    break;
+
+  case 'save-json':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv save-json input.json output.json', 'cyan')
+      );
+      process.exit(1);
+    }
+    await saveAsJson(files[0], files[1], options);
+    break;
+
+  case 'save-csv':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv save-csv input.csv output.csv', 'cyan')
+      );
+      process.exit(1);
+    }
+    await saveAsCsv(files[0], files[1], options);
+    break;
+
+  case 'preprocess':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv preprocess input.json output.json', 'cyan')
+      );
+      process.exit(1);
+    }
+    await preprocessJson(files[0], files[1], options);
+    break;
+
+    // NDJSON commands
+  case 'ndjson-to-csv':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv ndjson-to-csv input.ndjson output.csv', 'cyan')
+      );
+      process.exit(1);
+    }
+    await convertNdjsonToCsv(files[0], files[1], options);
+    break;
+
+  case 'csv-to-ndjson':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv csv-to-ndjson input.csv output.ndjson', 'cyan')
+      );
+      process.exit(1);
+    }
+    await convertCsvToNdjson(files[0], files[1], options);
+    break;
+
+  case 'ndjson-to-json':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv ndjson-to-json input.ndjson output.json', 'cyan')
+      );
+      process.exit(1);
+    }
+    await convertNdjsonToJson(files[0], files[1], options);
+    break;
+
+  case 'json-to-ndjson':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv json-to-ndjson input.json output.ndjson', 'cyan')
+      );
+      process.exit(1);
+    }
+    await convertJsonToNdjson(files[0], files[1], options);
+    break;
+
+    // Unwrap/Flatten command
+  case 'unwrap':
+  case 'flatten':
+    if (files.length < 2) {
+      console.error(color('Error: Input and output files required', 'red'));
+      console.log(
+        color('Usage: jtcsv unwrap input.json output.json', 'cyan')
+      );
+      process.exit(1);
+    }
+    await unwrapJson(files[0], files[1], options);
+    break;
+
+    // Streaming commands
+  case 'stream':
+    if (args.length < 2) {
+      console.error(
+        color('Error: Streaming mode requires subcommand', 'red')
+      );
+      console.log(
+        color(
+          'Usage: jtcsv stream [json-to-csv|csv-to-json|file-to-csv|file-to-json]',
+          'cyan'
+        )
+      );
+      process.exit(1);
+    }
+
+    const streamCommand = args[1].toLowerCase();
+    // Для stream команд нужно парсить опции начиная с 3-го аргумента (после stream и подкоманды)
+    const streamArgs = args.slice(2);
+    const { options: streamOptions, files: streamFiles } =
+        parseOptions(streamArgs);
+
+    if (streamCommand === 'json-to-csv' && streamFiles.length >= 2) {
+      await streamJsonToCsv(streamFiles[0], streamFiles[1], streamOptions);
+    } else if (streamCommand === 'csv-to-json' && streamFiles.length >= 2) {
+      await streamCsvToJson(streamFiles[0], streamFiles[1], streamOptions);
+    } else if (streamCommand === 'file-to-csv' && streamFiles.length >= 2) {
+      // Use jtcsv streaming API if available
+      try {
+        const readStream = fs.createReadStream(streamFiles[0], 'utf8');
+        const writeStream = fs.createWriteStream(streamFiles[1], 'utf8');
+
+        if (streamOptions.addBOM) {
+          writeStream.write('\uFEFF');
+        }
+
+        const transformStream = jtcsv.createJsonToCsvStream(streamOptions);
+        await pipeline(readStream, transformStream, writeStream);
+
+        console.log(color('✓ File streamed successfully', 'green'));
+      } catch (error: any) {
+        console.error(color(`✗ Streaming error: ${error.message}`, 'red'));
+        process.exit(1);
+      }
+    } else if (streamCommand === 'file-to-json' && streamFiles.length >= 2) {
+      // Use jtcsv streaming API if available
+      try {
+        const readStream = fs.createReadStream(streamFiles[0], 'utf8');
+        const writeStream = fs.createWriteStream(streamFiles[1], 'utf8');
+
+        const transformStream = jtcsv.createCsvToJsonStream(streamOptions);
+        await pipeline(readStream, transformStream, writeStream);
+
+        console.log(color('✓ File streamed successfully', 'green'));
+      } catch (error: any) {
+        console.error(color(`✗ Streaming error: ${error.message}`, 'red'));
+        process.exit(1);
+      }
+    } else {
+      console.error(
+        color('Error: Invalid streaming command or missing files', 'red')
+      );
+      process.exit(1);
+    }
+    break;
+
+    // Batch processing commands
+  case 'batch':
+    if (args.length < 2) {
+      console.error(color('Error: Batch mode requires subcommand', 'red'));
+      console.log(
+        color('Usage: jtcsv batch [json-to-csv|csv-to-json|process]', 'cyan')
+      );
+      process.exit(1);
+    }
+
+    const batchCommand = args[1].toLowerCase();
+    // Для batch команд нужно парсить опции начиная с 3-го аргумента (после batch и подкоманды)
+    const batchArgs = args.slice(2);
+    const { options: batchOptions, files: batchFiles } =
+        parseOptions(batchArgs);
+    const inputPattern = batchFiles[0]
+      || (batchOptions.patternProvided ? batchOptions.pattern : undefined);
+    const outputDir = batchFiles[1]
+      || (batchOptions.outputDirProvided ? batchOptions.outputDir : undefined);
+
+    if (!inputPattern || !outputDir) {
+      console.error(
+        color('Error: Batch mode requires input pattern and output directory', 'red')
+      );
+      console.log(
+        color('Usage: jtcsv batch [json-to-csv|csv-to-json|process] "<pattern>" "<outputDir>"', 'cyan')
+      );
+      console.log(
+        color('Or:    jtcsv batch <subcommand> --pattern="<pattern>" --output-dir="<outputDir>"', 'cyan')
+      );
+      process.exit(1);
+    }
+
+    if (batchCommand === 'json-to-csv') {
+      await batchJsonToCsv(inputPattern, outputDir, batchOptions);
+    } else if (batchCommand === 'csv-to-json') {
+      await batchCsvToJson(inputPattern, outputDir, batchOptions);
+    } else if (batchCommand === 'process') {
+      await batchProcessMixed(inputPattern, outputDir, batchOptions);
+    } else {
+      console.error(
+        color('Error: Invalid batch command or missing files', 'red')
+      );
+      process.exit(1);
+    }
+    break;
+
+    // TUI command
+  case 'tui':
+    await launchTUI();
+    break;
+
+    // Web UI command
+  case 'web':
+    await launchWebUI(options);
+    break;
+
+    // Help and version
+  case 'help':
+  case '--help':
+  case '-h':
+    showHelp();
+    break;
+
+  case 'version':
+  case '-v':
+  case '--version':
+    showVersion();
+    break;
+
+  default:
+    console.error(color(`Error: Unknown command '${command}'`, 'red'));
+    console.log(color('Use jtcsv help for available commands', 'cyan'));
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// ERROR HANDLING
+// ============================================================================
+
+process.on('uncaughtException', (error: any) => {
+  console.error(color(`\n✗ Uncaught error: ${error.message}`, 'red'));
+  if (process.env.DEBUG) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (error: any) => {
+  console.error(
+    color(`\n✗ Unhandled promise rejection: ${error.message}`, 'red')
+  );
+  if (process.env.DEBUG) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});
+
+// Run main function
+if (require.main === module) {
+  main().catch((error: any) => {
+    console.error(color(`\n✗ Fatal error: ${error.message}`, 'red'));
+    process.exit(1);
+  });
+}
+
+module.exports = { main };
+
+