jtcsv 2.2.8 → 3.1.0

package/dist/bin/jtcsv.js

@@ -0,0 +1,1940 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const { pipeline } = require('stream/promises');
+const jtcsv = __importStar(require("../index"));
+const transformLoader = require('../src/utils/transform-loader');
+const schemaValidator = require('../src/utils/schema-validator');
+const VERSION = require('../package.json').version;
+async function applyTransform(data, transformFile) {
+    try {
+        const transformPath = path.resolve(process.cwd(), transformFile);
+        const transformModule = require(transformPath);
+        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) {
+        throw new Error(`Failed to apply transform from ${transformFile}: ${error.message}`);
+    }
+}
+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) {
+    return colors[colorName] + text + colors.reset;
+}
+function showHelp() {
+    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() {
+    console.log(`jtcsv v${VERSION}`);
+    console.log(`Node.js ${process.version}`);
+    console.log(`Platform: ${process.platform} ${process.arch}`);
+}
+async function readStdin() {
+    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);
+    });
+}
+async function convertJsonToCsv(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    const useStdin = inputFile === '-';
+    const useStdout = outputFile === '-';
+    const shouldLog = !options.silent && !useStdout;
+    try {
+        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) {
+                console.error(color(`✗ Transform error: ${transformError.message}`, 'red'));
+                if (options.debug) {
+                    console.error(transformError.stack);
+                }
+                process.exit(1);
+            }
+        }
+        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,
+            flatten: options.flatten,
+            flattenSeparator: options.flattenSeparator,
+            flattenMaxDepth: options.flattenMaxDepth,
+            arrayHandling: options.arrayHandling
+        };
+        let transformedData = jsonData;
+        if (options.transform) {
+            transformedData = await applyTransform(jsonData, options.transform);
+        }
+        const csvData = jtcsv.jsonToCsv(transformedData, jtcsvOptions);
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function convertCsvToJson(inputFile, outputFile, options) {
+    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'));
+        }
+        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
+        };
+        let jsonData;
+        if (useStdin) {
+            const csvContent = await readStdin();
+            jsonData = jtcsv.csvToJson(csvContent, jtcsvOptions);
+        }
+        else {
+            jsonData = await jtcsv.readCsvAsJson(inputFile, jtcsvOptions);
+        }
+        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) {
+                console.error(color(`✗ Transform error: ${transformError.message}`, 'red'));
+                if (options.debug) {
+                    console.error(transformError.stack);
+                }
+                process.exit(1);
+            }
+        }
+        const jsonOutput = options.pretty
+            ? JSON.stringify(transformedData, null, 2)
+            : JSON.stringify(transformedData);
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function saveAsCsv(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    try {
+        const inputData = await fs.promises.readFile(inputFile, 'utf8');
+        if (!options.silent) {
+            console.log(color('Saving CSV file...', 'dim'));
+        }
+        let transformedData = inputData;
+        if (options.transform) {
+            if (!options.silent) {
+                console.log(color(`Applying transform from: ${options.transform}`, 'dim'));
+            }
+            try {
+                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);
+                transformedData = jtcsv.jsonToCsv(transformedJson, {
+                    delimiter: options.delimiter,
+                    includeHeaders: options.includeHeaders,
+                    normalizeQuotes: options.normalizeQuotes
+                });
+                if (!options.silent) {
+                    console.log(color('✓ Transform applied', 'green'));
+                }
+            }
+            catch (transformError) {
+                console.error(color(`✗ Transform error: ${transformError.message}`, 'red'));
+                if (options.debug) {
+                    console.error(transformError.stack);
+                }
+                process.exit(1);
+            }
+        }
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function saveAsJson(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    try {
+        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'));
+        }
+        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) {
+                console.error(color(`✗ Transform error: ${transformError.message}`, 'red'));
+                if (options.debug) {
+                    console.error(transformError.stack);
+                }
+                process.exit(1);
+            }
+        }
+        const jtcsvOptions = {
+            prettyPrint: options.pretty
+        };
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function convertNdjsonToCsv(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    try {
+        if (!options.silent) {
+            console.log(color('Converting NDJSON to CSV...', 'dim'));
+        }
+        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'));
+        }
+        const jtcsvOptions = {
+            delimiter: options.delimiter,
+            includeHeaders: options.includeHeaders,
+            renameMap: options.renameMap,
+            template: options.template,
+            preventCsvInjection: options.preventCsvInjection,
+            rfc4180Compliant: options.rfc4180Compliant,
+            normalizeQuotes: options.normalizeQuotes
+        };
+        const csvData = jtcsv.jsonToCsv(jsonData, jtcsvOptions);
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function convertCsvToNdjson(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    try {
+        if (!options.silent) {
+            console.log(color('Converting CSV to NDJSON...', 'dim'));
+        }
+        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
+        };
+        const jsonData = await jtcsv.readCsvAsJson(inputFile, jtcsvOptions);
+        const ndjsonData = jtcsv.jsonToNdjson(jsonData);
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function convertNdjsonToJson(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    try {
+        if (!options.silent) {
+            console.log(color('Converting NDJSON to JSON array...', 'dim'));
+        }
+        const inputData = await fs.promises.readFile(inputFile, 'utf8');
+        const jsonData = jtcsv.ndjsonToJson(inputData);
+        const jsonOutput = options.pretty
+            ? JSON.stringify(jsonData, null, 2)
+            : JSON.stringify(jsonData);
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function convertJsonToNdjson(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    try {
+        if (!options.silent) {
+            console.log(color('Converting JSON array to NDJSON...', 'dim'));
+        }
+        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');
+        }
+        const ndjsonData = jtcsv.jsonToNdjson(jsonData);
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function unwrapJson(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    try {
+        if (!options.silent) {
+            console.log(color('Unwrapping/flattening nested JSON...', 'dim'));
+        }
+        const inputData = await fs.promises.readFile(inputFile, 'utf8');
+        const jsonData = JSON.parse(inputData);
+        const maxDepth = options.maxDepth || 10;
+        const separator = options.flattenPrefix || '_';
+        const flattenObject = (obj, prefix = '', depth = 0) => {
+            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)) {
+                    if (options.unwrapArrays) {
+                        result[newKey] = value.join(', ');
+                    }
+                    else {
+                        result[newKey] = JSON.stringify(value);
+                    }
+                }
+                else {
+                    result[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);
+        }
+        const jsonOutput = options.pretty
+            ? JSON.stringify(unwrappedData, null, 2)
+            : JSON.stringify(unwrappedData);
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function preprocessJson(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    try {
+        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'));
+        }
+        const processedData = jtcsv.preprocessData(jsonData);
+        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) {
+                console.error(color(`✗ Transform error: ${transformError.message}`, 'red'));
+                if (options.debug) {
+                    console.error(transformError.stack);
+                }
+                process.exit(1);
+            }
+        }
+        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]);
+                    }
+                }
+            });
+        }
+        const jsonOutput = options.pretty
+            ? JSON.stringify(transformedData, null, 2)
+            : JSON.stringify(transformedData);
+        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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function streamJsonToCsv(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    let recordCount = 0;
+    try {
+        if (!options.silent) {
+            console.log(color('Streaming JSON to CSV...', 'dim'));
+        }
+        const readStream = fs.createReadStream(inputFile, 'utf8');
+        const writeStream = fs.createWriteStream(outputFile, 'utf8');
+        if (options.addBOM) {
+            writeStream.write('\uFEFF');
+        }
+        let buffer = '';
+        const isFirstChunk = true;
+        let headersWritten = false;
+        readStream.on('data', (chunk) => {
+            buffer += chunk;
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        const obj = JSON.parse(line);
+                        let finalObj = obj;
+                        if (options.renameMap) {
+                            const renameMap = options.renameMap;
+                            finalObj = {};
+                            for (const [oldKey, newKey] of Object.entries(renameMap)) {
+                                if (oldKey in obj) {
+                                    finalObj[newKey] = obj[oldKey];
+                                }
+                            }
+                            for (const [key, value] of Object.entries(obj)) {
+                                if (!(key in renameMap)) {
+                                    finalObj[key] = value;
+                                }
+                            }
+                        }
+                        recordCount++;
+                        if (!headersWritten && options.includeHeaders !== false) {
+                            const headers = Object.keys(finalObj);
+                            writeStream.write(headers.join(options.delimiter || ';') + '\n');
+                            headersWritten = true;
+                        }
+                        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);
+                        if (options.verbose && recordCount % 10000 === 0) {
+                            process.stdout.write(color(`  Processed ${recordCount.toLocaleString()} records\r`, 'dim'));
+                        }
+                    }
+                    catch (error) {
+                        if (options.debug) {
+                            console.warn(color(`  Warning: Skipping invalid JSON line: ${error.message}`, 'yellow'));
+                        }
+                    }
+                }
+            }
+        });
+        readStream.on('end', async () => {
+            if (buffer.trim()) {
+                try {
+                    const obj = JSON.parse(buffer);
+                    let finalObj = obj;
+                    if (options.renameMap) {
+                        const renameMap = options.renameMap;
+                        finalObj = {};
+                        for (const [oldKey, newKey] of Object.entries(renameMap)) {
+                            if (oldKey in obj) {
+                                finalObj[newKey] = obj[oldKey];
+                            }
+                        }
+                        for (const [key, value] of Object.entries(obj)) {
+                            if (!(key in renameMap)) {
+                                finalObj[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) {
+                }
+            }
+            writeStream.end();
+            await new Promise((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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function streamCsvToJson(inputFile, outputFile, options) {
+    const startTime = Date.now();
+    let rowCount = 0;
+    try {
+        if (!options.silent) {
+            console.log(color('Streaming CSV to JSON...', 'dim'));
+        }
+        const readStream = fs.createReadStream(inputFile, 'utf8');
+        const writeStream = fs.createWriteStream(outputFile, 'utf8');
+        writeStream.write('[\n');
+        let buffer = '';
+        let isFirstRow = true;
+        let headers = [];
+        readStream.on('data', (chunk) => {
+            buffer += chunk;
+            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++;
+                const fields = parseCsvLineSimple(line, options.delimiter || ';');
+                if (rowCount === 1 && options.hasHeaders !== false) {
+                    headers = fields;
+                    continue;
+                }
+                const obj = {};
+                const fieldCount = Math.min(fields.length, headers.length);
+                for (let j = 0; j < fieldCount; j++) {
+                    const header = headers[j] || `column${j + 1}`;
+                    let finalHeader = header;
+                    if (options.renameMap && options.renameMap[header]) {
+                        finalHeader = options.renameMap[header];
+                    }
+                    let value = fields[j];
+                    if (options.parseNumbers) {
+                        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;
+                                }
+                            }
+                        }
+                    }
+                    if (options.parseBooleans) {
+                        const lowerValue = value.toLowerCase();
+                        if (lowerValue === 'true') {
+                            value = true;
+                        }
+                        if (lowerValue === 'false') {
+                            value = false;
+                        }
+                    }
+                    obj[finalHeader] = value;
+                }
+                const jsonStr = JSON.stringify(obj);
+                if (!isFirstRow) {
+                    writeStream.write(',\n');
+                }
+                writeStream.write('  ' + jsonStr);
+                isFirstRow = false;
+                if (options.verbose && rowCount % 10000 === 0) {
+                    process.stdout.write(color(`  Processed ${rowCount.toLocaleString()} rows\r`, 'dim'));
+                }
+            }
+        });
+        readStream.on('end', async () => {
+            if (buffer.trim()) {
+                const fields = parseCsvLineSimple(buffer.trim(), options.delimiter || ';');
+                if (fields.length > 0) {
+                    rowCount++;
+                    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}`;
+                            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);
+                    }
+                }
+            }
+            writeStream.write('\n]');
+            writeStream.end();
+            await new Promise((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) {
+        console.error(color(`✗ Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+function parseCsvLineSimple(line, delimiter) {
+    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] === '"') {
+                currentField += '"';
+                i++;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+        }
+        else if (char === delimiter && !inQuotes) {
+            fields.push(currentField);
+            currentField = '';
+        }
+        else {
+            currentField += char;
+        }
+    }
+    fields.push(currentField);
+    return fields;
+}
+async function batchJsonToCsv(inputPattern, outputDir, options) {
+    const startTime = Date.now();
+    try {
+        let glob;
+        try {
+            glob = require('glob');
+        }
+        catch (error) {
+            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 = [];
+        const parallelLimit = options.parallel || 4;
+        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
+                    });
+                    if (!options.silent) {
+                        console.log(color(`  ✓ ${fileName}.json → ${fileName}.csv (${result.records} records)`, 'green'));
+                    }
+                    return { file, success: true, ...result };
+                }
+                catch (error) {
+                    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) {
+        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) {
+    const startTime = Date.now();
+    try {
+        let glob;
+        try {
+            glob = require('glob');
+        }
+        catch (error) {
+            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 = [];
+        const parallelLimit = options.parallel || 4;
+        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
+                    });
+                    if (!options.silent) {
+                        console.log(color(`  ✓ ${fileName}.csv → ${fileName}.json (${result.rows} rows)`, 'green'));
+                    }
+                    return { file, success: true, ...result };
+                }
+                catch (error) {
+                    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) {
+        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) {
+    const startTime = Date.now();
+    try {
+        let glob;
+        try {
+            glob = require('glob');
+        }
+        catch (error) {
+            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 = [];
+        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'));
+        }
+        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) {
+                    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);
+        }
+        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) {
+                    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) {
+        console.error(color(`✗ Batch processing error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+function parseOptions(args) {
+    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 };
+}
+async function launchTUI() {
+    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) {
+        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 = {}) {
+    try {
+        const webServer = require('../src/web-server');
+        webServer.startServer({
+            port: options.port || 3000,
+            host: options.host || 'localhost'
+        });
+    }
+    catch (error) {
+        console.error(color(`Error: ${error.message}`, 'red'));
+        if (options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+async function startBasicTUI() {
+    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) {
+    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) {
+                    console.error(color(`✗ Error: ${error.message}`, 'red'));
+                    rl.close();
+                    process.exit(1);
+                }
+            });
+        });
+    });
+}
+async function runCsvToJsonTUI(rl) {
+    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) {
+                        console.error(color(`✗ Error: ${error.message}`, 'red'));
+                        rl.close();
+                        process.exit(1);
+                    }
+                });
+            });
+        });
+    });
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        showHelp();
+        return;
+    }
+    const command = args[0].toLowerCase();
+    const { options, files } = parseOptions(args.slice(1));
+    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;
+    }
+    if (options.silent) {
+        console.log = () => { };
+        console.info = () => { };
+    }
+    switch (command) {
+        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;
+        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;
+        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;
+        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();
+            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) {
+                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) {
+                    console.error(color(`✗ Streaming error: ${error.message}`, 'red'));
+                    process.exit(1);
+                }
+            }
+            else if (streamCommand === 'file-to-json' && streamFiles.length >= 2) {
+                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) {
+                    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;
+        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();
+            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;
+        case 'tui':
+            await launchTUI();
+            break;
+        case 'web':
+            await launchWebUI(options);
+            break;
+        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);
+    }
+}
+process.on('uncaughtException', (error) => {
+    console.error(color(`\n✗ Uncaught error: ${error.message}`, 'red'));
+    if (process.env.DEBUG) {
+        console.error(error.stack);
+    }
+    process.exit(1);
+});
+process.on('unhandledRejection', (error) => {
+    console.error(color(`\n✗ Unhandled promise rejection: ${error.message}`, 'red'));
+    if (process.env.DEBUG) {
+        console.error(error.stack);
+    }
+    process.exit(1);
+});
+if (require.main === module) {
+    main().catch((error) => {
+        console.error(color(`\n✗ Fatal error: ${error.message}`, 'red'));
+        process.exit(1);
+    });
+}
+module.exports = { main };
+//# sourceMappingURL=jtcsv.js.map