pury/dist/cli/commands/init.js

🛡️ AI-powered security scanner with advanced threat detection, dual reporting system (detailed & summary), and comprehensive code analysis

import { Command } from 'commander';
import { resolve } from 'path';
import { ConfigManager } from '../../config/config-manager.js';
import { logger } from '../../utils/logger.js';
import { fileExists } from '../../utils/file-utils.js';
export function createInitCommand() {
    return new Command('init')
        .description('Initialize PuryAI configuration file')
        .option('-f, --force', 'Overwrite existing configuration file')
        .option('--global', 'Create global configuration file')
        .option('--template <type>', 'Configuration template (default, strict, minimal)', 'default')
        .action(async (options) => {
        try {
            await runInit(options);
        }
        catch (error) {
            logger.error(`Initialization failed: ${error.message}`);
            process.exit(1);
        }
    });
}
async function runInit(options) {
    const configManager = new ConfigManager();
    logger.info('Initializing PuryAI configuration...');
    try {
        if (options.global) {
            // Create global configuration
            logger.info('Creating global configuration file...');
            const template = getConfigTemplate(options.template);
            await configManager.saveGlobalConfig(template);
            logger.success('✅ Global configuration created successfully!');
            logger.info('Global config location: ~/.puryai/config.yaml (or %APPDATA%\\puryai\\config.yaml on Windows)');
        }
        else {
            // Create local configuration
            const configPath = resolve(process.cwd(), 'puryai.config.yaml');
            if (!options.force && (await fileExists(configPath))) {
                throw new Error('Configuration file already exists. Use --force to overwrite.');
            }
            logger.info('Creating local configuration file...');
            const template = getConfigTemplate(options.template);
            await configManager.saveConfig(template, configPath);
            logger.success('✅ Configuration file created successfully!');
            logger.info(`Config file: ${configPath}`);
        }
        // Show next steps
        logger.info('\\n📋 Next steps:');
        logger.info('1. Set your Gemini API key:');
        logger.info('   export GEMINI_API_KEY="your-api-key-here"');
        logger.info('   (Get your API key at: https://aistudio.google.com/)');
        logger.info('');
        logger.info('2. Customize the configuration as needed');
        logger.info('');
        logger.info('3. Run your first scan:');
        logger.info('   puryai scan ./src');
        // Show template information
        const templateInfo = getTemplateInfo(options.template);
        if (templateInfo) {
            logger.info(`\\n💡 Template "${options.template}" includes:`);
            for (const feature of templateInfo) {
                logger.info(`   • ${feature}`);
            }
        }
    }
    catch (error) {
        logger.error(`Failed to create configuration: ${error.message}`);
        throw error;
    }
}
function getConfigTemplate(templateType) {
    const baseConfig = {
        scanner: {
            exclude: [
                'node_modules/**',
                'dist/**',
                'build/**',
                '.git/**',
                '*.min.js',
                '*.map',
                'coverage/**'
            ],
            include: ['**/*'],
            maxFileSize: 1048576, // 1MB
            followSymlinks: false
        },
        analyzers: {
            malware: { enabled: true, sensitivity: 'medium' },
            secrets: { enabled: true, sensitivity: 'medium' },
            vulnerabilities: { enabled: true, sensitivity: 'medium' },
            codeQuality: { enabled: false, sensitivity: 'medium' }
        },
        ai: {
            provider: 'gemini',
            gemini: {
                model: 'gemini-2.5-flash',
                temperature: 0.1,
                maxTokens: 2048
            }
        },
        output: {
            format: 'console',
            verbose: false
        }
    };
    switch (templateType) {
        case 'strict':
            return {
                ...baseConfig,
                analyzers: {
                    malware: { enabled: true, sensitivity: 'high' },
                    secrets: { enabled: true, sensitivity: 'high' },
                    vulnerabilities: { enabled: true, sensitivity: 'high' },
                    codeQuality: { enabled: true, sensitivity: 'high' }
                },
                scanner: {
                    ...baseConfig.scanner,
                    maxFileSize: 512000 // 500KB - smaller files for thorough analysis
                }
            };
        case 'minimal':
            return {
                ...baseConfig,
                analyzers: {
                    malware: { enabled: true, sensitivity: 'low' },
                    secrets: { enabled: true, sensitivity: 'medium' },
                    vulnerabilities: { enabled: false, sensitivity: 'low' },
                    codeQuality: { enabled: false, sensitivity: 'low' }
                },
                scanner: {
                    ...baseConfig.scanner,
                    exclude: [
                        ...baseConfig.scanner.exclude,
                        'tests/**',
                        'test/**',
                        '**/*.test.*',
                        '**/*.spec.*'
                    ]
                }
            };
        case 'default':
        default:
            return baseConfig;
    }
}
function getTemplateInfo(templateType) {
    switch (templateType) {
        case 'strict':
            return [
                'High sensitivity for all analyzers',
                'Code quality analysis enabled',
                'Smaller file size limits for thorough scanning',
                'Comprehensive security checks'
            ];
        case 'minimal':
            return [
                'Basic malware and secrets detection only',
                'Lower sensitivity to reduce false positives',
                'Excludes test files from scanning',
                'Faster scanning for large codebases'
            ];
        case 'default':
            return [
                'Balanced security scanning',
                'Medium sensitivity settings',
                'Essential analyzers enabled',
                'Good for most projects'
            ];
        default:
            return null;
    }
}
//# sourceMappingURL=init.js.map