@bramato/openrouter-mock-generator/dist/bin/cli.js

AI-powered mock data generator using OpenRouter API with JSON mode support

#!/usr/bin/env node
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
require("dotenv/config");
const mock_generator_1 = require("../services/mock-generator");
const pattern_analyzer_1 = require("../utils/pattern-analyzer");
const promises_1 = require("fs/promises");
function parseArgs(args) {
    const parsed = {};
    for (let i = 0; i < args.length; i++) {
        const arg = args[i];
        switch (arg) {
            case '--help':
            case '-h':
                parsed.help = true;
                break;
            case '--count':
            case '-c':
                parsed.count = parseInt(args[++i]) || 10;
                break;
            case '--array-path':
            case '-p':
                parsed.arrayPath = args[++i];
                break;
            case '--preferences':
            case '--pref':
                parsed.preferences = args[++i];
                break;
            case '--output':
            case '-o':
                parsed.outputFile = args[++i];
                break;
            case '--analyze':
            case '-a':
                parsed.analyze = true;
                break;
            case '--enable-images':
            case '--images':
                parsed.enableImageProcessing = true;
                break;
            case '--disable-images':
            case '--no-images':
                parsed.disableImageProcessing = true;
                break;
            default:
                if (!arg.startsWith('-') && !parsed.inputFile) {
                    parsed.inputFile = arg;
                }
                break;
        }
    }
    return parsed;
}
function showHelp() {
    console.log(`
AI Mock Data Generator

Usage:
  ai-generate-mock <input.json> --output <output.json> [options]

Options:
  -c, --count <number>      Number of items to generate (default: 10)
  -o, --output <file>       Output file path (required)
  -p, --array-path <path>   Specific array path to use (e.g. 'data.items')
  --preferences, --pref <text>  Custom preferences for data generation
  --images, --enable-images Force enable AI image processing (replaces Picsum URLs)
  --no-images, --disable-images  Disable AI image processing (keep Picsum URLs)
  -a, --analyze             Analyze input file structure without generating
  -h, --help                Show this help message

Examples:
  ai-generate-mock products.json --output products_mock.json --count 50
  ai-generate-mock data.json --output generated_data.json --count 100
  ai-generate-mock users.json --output users_mock.json --array-path "users" --count 25
  ai-generate-mock products.json --output premium_products.json --preferences "Generate only premium brand products with prices above €200"
  ai-generate-mock products.json --output products_with_ai_images.json --images --count 20    # Force AI image generation
  ai-generate-mock products.json --output products_picsum.json --no-images                   # Disable AI images, keep Picsum
  ai-generate-mock input.json --analyze                                                       # Analyze mode doesn't require --output

Environment Variables:
  OPENROUTER_API_KEY        Your OpenRouter API key (required)
`);
}
async function analyzeFile(inputFile) {
    try {
        const content = await (0, promises_1.readFile)(inputFile, 'utf8');
        const data = JSON.parse(content);
        const analyses = pattern_analyzer_1.PatternAnalyzer.analyzeJsonStructure(data);
        console.log(`\\nFile: ${inputFile}`);
        console.log('='.repeat(50));
        console.log('🤖 Note: Mock generation uses JSON-mode compatible models only');
        if (analyses.length === 0) {
            console.log('No arrays found in the input file.');
            return;
        }
        console.log('Found arrays:');
        analyses.forEach((analysis, index) => {
            console.log(`\\n${index + 1}. Path: ${analysis.arrayPath}`);
            console.log(`   Items: ${analysis.itemCount}`);
            console.log(`   Sample structure:`);
            console.log(`   ${JSON.stringify(analysis.sampleItem, null, 2)
                .split('\\n')
                .map(line => '   ' + line)
                .join('\\n')}`);
        });
        const largest = pattern_analyzer_1.PatternAnalyzer.findLargestArray(analyses);
        if (largest) {
            console.log(`\\nLargest array: ${largest.arrayPath} (${largest.itemCount} items)`);
        }
    }
    catch (error) {
        console.error('Error analyzing file:', error instanceof Error ? error.message : 'Unknown error');
        process.exit(1);
    }
}
async function main() {
    const args = parseArgs(process.argv.slice(2));
    if (args.help) {
        showHelp();
        return;
    }
    if (!args.inputFile) {
        console.error('Error: Input file is required\\n');
        showHelp();
        process.exit(1);
    }
    if (!args.outputFile) {
        console.error('Error: Output file is required. Use --output or -o to specify destination\\n');
        showHelp();
        process.exit(1);
    }
    if (args.analyze) {
        await analyzeFile(args.inputFile);
        return;
    }
    if (!process.env.OPENROUTER_API_KEY) {
        console.error('Error: OPENROUTER_API_KEY environment variable is required');
        process.exit(1);
    }
    const outputFile = args.outputFile;
    const count = args.count || 10;
    // Verifica che il file di output sia diverso dal file di input
    if (args.inputFile === outputFile) {
        console.error('Error: Output file cannot be the same as input file. This would overwrite the original data\\n');
        process.exit(1);
    }
    console.log(`Generating ${count} mock items from ${args.inputFile}...`);
    if (args.arrayPath) {
        console.log(`Using array path: ${args.arrayPath}`);
    }
    if (args.preferences) {
        console.log(`Custom preferences: ${args.preferences}`);
    }
    console.log(`Output: ${outputFile}\\n`);
    // Determina se abilitare il post-processing delle immagini
    let enableImageProcessing = undefined; // Default: auto-detect
    if (args.disableImageProcessing) {
        enableImageProcessing = false;
        console.log('🚫 AI image processing explicitly disabled');
    }
    else if (args.enableImageProcessing) {
        enableImageProcessing = true;
        console.log('🎨 AI image processing explicitly enabled');
    }
    const generator = new mock_generator_1.MockGeneratorService(undefined, enableImageProcessing);
    const result = await generator.generateMockData({
        inputFile: args.inputFile,
        outputFile,
        count,
        arrayPath: args.arrayPath,
        preferences: args.preferences,
        enableImageProcessing,
    });
    if (result.success) {
        console.log(`\\n✅ Successfully generated ${result.generatedCount} items`);
        console.log(`📁 Output saved to: ${result.outputFile}`);
    }
    else {
        console.error(`\\n❌ Generation failed: ${result.error}`);
        process.exit(1);
    }
}
main().catch((error) => {
    console.error('Unexpected error:', error);
    process.exit(1);
});
//# sourceMappingURL=cli.js.map