@vee-stack/delta-cli 2.0.9 → 2.0.10

package/dist/commands/analyze.js

@@ -1,393 +0,0 @@
-/**
- * Analyze Command - Run local analysis with optional upload to cloud
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as crypto from 'crypto';
-import { loadConfig } from './auth.js';
-import { SecureTokenStore } from '../auth/secure-auth.js';
-import chalk from 'chalk';
-import { icons, startSpinner, stopSpinner, printSuccess, printInfo, printWarning, createTable, printDivider, } from '../ui.js';
-function extractApiErrorPayload(payload) {
-    if (!payload || typeof payload !== 'object')
-        return {};
-    const maybeError = payload.error;
-    if (!maybeError || typeof maybeError !== 'object')
-        return {};
-    const e = maybeError;
-    return {
-        message: typeof e.message === 'string' ? e.message : undefined,
-        details: e.details,
-    };
-}
-export async function analyzeCommand(projectPath, options) {
-    const targetPath = path.resolve(projectPath);
-    // Check authentication FIRST for all operations
-    printInfo('🔐 Checking authentication...');
-    await loadConfig();
-    const pat = await SecureTokenStore.getAccessToken();
-    if (!pat) {
-        console.error();
-        console.error(chalk.red('❌ Error: You must be logged in to use Delta CLI.'));
-        console.error();
-        console.error(chalk.yellow('Please authenticate first:'));
-        console.error(chalk.cyan('  delta login'));
-        console.error();
-        console.error(chalk.dim('Or use a valid PAT:'));
-        console.error(chalk.cyan('  delta login --token <your-pat>'));
-        console.error();
-        process.exit(1);
-    }
-    printSuccess('✓ Authenticated');
-    console.log();
-    // Additional check for upload permission
-    if (options.upload) {
-        printInfo('📤 Upload mode enabled');
-        console.log();
-    }
-    printInfo('🔍 Starting Delta Analysis Engine...');
-    printDivider();
-    console.log(`${icons.folder}  Project: ${chalk.cyan(targetPath)}`);
-    console.log();
-    // Phase 1: File Discovery
-    startSpinner('Scanning project files...');
-    const files = await discoverFiles(targetPath, {
-        include: options.include ? [options.include] : ['**/*.{ts,tsx,js,jsx}'],
-        exclude: options.exclude
-            ? [options.exclude].concat(['node_modules', 'dist', '.git'])
-            : ['node_modules', 'dist', '.git'],
-        maxSize: parseInt(options.maxSize, 10),
-    });
-    stopSpinner(true, `Found ${files.length} files to analyze`);
-    console.log();
-    if (files.length === 0) {
-        printWarning('No files found matching the criteria');
-        printInfo('Try adjusting --include or --exclude patterns');
-        process.exit(0);
-    }
-    // Phase 2: Analysis with Progress
-    console.log(`${icons.loading} Analyzing ${files.length} files...`);
-    console.log();
-    const startTime = Date.now();
-    const summary = {
-        totalFiles: files.length,
-        successfulParses: 0,
-        failedParses: 0,
-        totalLines: 0,
-        totalFunctions: 0,
-        totalClasses: 0,
-        totalDuration: 0,
-        errors: [],
-    };
-    const findings = [];
-    // Process files with progress indication
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        const progress = Math.round(((i + 1) / files.length) * 100);
-        const bar = renderProgressBar(progress);
-        // Clear line and print progress
-        process.stdout.write(`\r${bar} ${chalk.cyan(`${i + 1}/${files.length}`)} ${chalk.dim(file.split(/[/\\]/).pop() || '')}`);
-        try {
-            const content = await fs.readFile(file, 'utf-8');
-            const lines = content.split('\n');
-            summary.totalLines += lines.length;
-            summary.successfulParses++;
-            // Simple heuristics for demo
-            if (content.includes('function '))
-                summary.totalFunctions++;
-            if (content.includes('class '))
-                summary.totalClasses++;
-            // Find potential issues
-            if (content.includes('eval(')) {
-                findings.push({
-                    file: path.relative(targetPath, file),
-                    type: 'security',
-                    severity: 'high',
-                    message: 'Use of eval() detected',
-                });
-            }
-            if (content.includes('console.log')) {
-                findings.push({
-                    file: path.relative(targetPath, file),
-                    type: 'maintainability',
-                    severity: 'low',
-                    message: 'Console.log statement found',
-                });
-            }
-        }
-        catch (error) {
-            summary.failedParses++;
-            summary.errors.push({
-                file: path.relative(targetPath, file),
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    // Clear progress line
-    process.stdout.write('\r' + ' '.repeat(80) + '\r');
-    console.log(`${icons.check} Analysis complete: ${chalk.green(`${summary.successfulParses} successful`)}, ${summary.failedParses > 0 ? chalk.red(`${summary.failedParses} failed`) : ''}`);
-    console.log();
-    summary.totalDuration = Date.now() - startTime;
-    // Build report
-    const report = {
-        schema_version: '1.0',
-        engine_version: '0.5.0',
-        created_at: new Date().toISOString(),
-        project: {
-            name: options.projectName || path.basename(targetPath),
-            root_fingerprint: '',
-            path: targetPath,
-        },
-        tools_used: [{ id: 'delta-core', version: '0.5.0', adapter_version: '0.5.0' }],
-        summary: {
-            total: findings.length,
-            high: findings.filter(f => f.severity === 'high').length,
-            medium: findings.filter(f => f.severity === 'medium').length,
-            low: findings.filter(f => f.severity === 'low').length,
-        },
-        findings,
-        metadata: summary,
-    };
-    // Phase 3: Results Display
-    printDivider();
-    printSuccess('Analysis Complete');
-    console.log();
-    // Summary table
-    const summaryTable = createTable(['Metric', 'Value']);
-    summaryTable.push([icons.folder + ' Files Analyzed', summary.totalFiles.toString()], [icons.chart + ' Total Lines', summary.totalLines.toLocaleString()], [icons.gear + ' Functions Found', summary.totalFunctions.toString()], [icons.package + ' Classes Found', summary.totalClasses.toString()], [icons.loading + ' Duration', formatDuration(summary.totalDuration)]);
-    console.log(summaryTable.toString());
-    console.log();
-    // Findings summary
-    if (findings.length > 0) {
-        printWarning(`Found ${findings.length} issues:`);
-        const issuesTable = createTable(['Severity', 'Count']);
-        const highCount = findings.filter(f => f.severity === 'high').length;
-        const mediumCount = findings.filter(f => f.severity === 'medium').length;
-        const lowCount = findings.filter(f => f.severity === 'low').length;
-        if (highCount > 0)
-            issuesTable.push([chalk.red('🔴 High'), highCount.toString()]);
-        if (mediumCount > 0)
-            issuesTable.push([chalk.yellow('🟡 Medium'), mediumCount.toString()]);
-        if (lowCount > 0)
-            issuesTable.push([chalk.blue('🔵 Low'), lowCount.toString()]);
-        console.log(issuesTable.toString());
-    }
-    else {
-        printSuccess('✨ No issues found! Great job!');
-    }
-    console.log();
-    // Save report to file ONLY if not uploading
-    if (!options.upload) {
-        const outputDir = path.resolve(options.output);
-        await fs.mkdir(outputDir, { recursive: true });
-        const reportFile = path.join(outputDir, `report-${Date.now()}.json`);
-        await fs.writeFile(reportFile, JSON.stringify(report, null, 2));
-        printInfo(`${icons.chart} Report saved: ${chalk.cyan(reportFile)}`);
-        console.log();
-    }
-    else {
-        printInfo(`${icons.chart} Report will be available on Delta Cloud Dashboard`);
-        console.log();
-    }
-    // Upload to cloud if requested
-    if (options.upload) {
-        console.log(`${icons.rocket} Uploading to Delta Cloud...`);
-        await uploadReport(report);
-    }
-    process.exit(0);
-}
-async function uploadReport(report) {
-    const config = await loadConfig();
-    // Get PAT from secure keychain storage, NOT from config file
-    const pat = await SecureTokenStore.getAccessToken();
-    if (!pat) {
-        console.error('❌ Error: Not authenticated. Run: delta login --token <pat>');
-        process.exit(1);
-    }
-    const apiUrl = process.env.DELTA_API_URL || config.apiUrl || 'http://localhost:3000';
-    const reportJson = JSON.stringify(report);
-    const reportHash = crypto.createHash('sha256').update(reportJson).digest('hex');
-    try {
-        // Step 1: Init upload session
-        const initResponse = await fetch(`${apiUrl}/api/upload/init`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${pat}`,
-                'Content-Type': 'application/json',
-                'Idempotency-Key': crypto.randomUUID(),
-            },
-            body: JSON.stringify({
-                schemaVersion: '1.0',
-                engineVersion: '0.5.0',
-                reportHash: reportHash,
-                reportSizeBytes: Buffer.byteLength(reportJson),
-                toolsUsed: [{ id: 'delta-core', version: '0.5.0', adapterVersion: '0.5.0' }],
-            }),
-        });
-        if (!initResponse.ok) {
-            let payload = undefined;
-            try {
-                payload = await initResponse.json();
-            }
-            catch {
-                payload = await initResponse.text().catch(() => undefined);
-            }
-            const apiError = extractApiErrorPayload(payload);
-            const details = apiError.details ? `\nDetails: ${JSON.stringify(apiError.details)}` : '';
-            const message = apiError.message || `Init failed: ${initResponse.status}`;
-            throw new Error(message + details);
-        }
-        const initData = (await initResponse.json());
-        if (!initData.success) {
-            throw new Error(initData.error?.message || 'Upload init failed');
-        }
-        const uploadId = initData.data.uploadId;
-        const secret = initData.data.signing.secret;
-        console.log(`   Upload session: ${uploadId}`);
-        // Step 2: Sign and upload report
-        const signature = crypto.createHmac('sha256', secret).update(reportJson).digest('hex');
-        const uploadResponse = await fetch(`${apiUrl}/api/upload/${uploadId}`, {
-            method: 'PUT',
-            headers: {
-                Authorization: `Bearer ${pat}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                report: Object.assign({}, report, {
-                    integrity: {
-                        report_hash: reportHash,
-                        signature: signature,
-                        algorithm: 'HMAC-SHA256',
-                    },
-                }),
-            }),
-        });
-        if (!uploadResponse.ok) {
-            let payload = undefined;
-            try {
-                payload = await uploadResponse.json();
-            }
-            catch {
-                payload = await uploadResponse.text().catch(() => undefined);
-            }
-            const apiError = extractApiErrorPayload(payload);
-            const details = apiError.details ? `\nDetails: ${JSON.stringify(apiError.details)}` : '';
-            const message = apiError.message || `Upload failed: ${uploadResponse.status}`;
-            throw new Error(message + details);
-        }
-        console.log('   Report uploaded');
-        // Step 3: Finalize
-        const finalizeResponse = await fetch(`${apiUrl}/api/upload/${uploadId}/finalize`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${pat}`,
-                'Content-Type': 'application/json',
-                'Idempotency-Key': crypto.randomUUID(),
-            },
-            body: '{}',
-        });
-        if (!finalizeResponse.ok) {
-            let payload = undefined;
-            try {
-                payload = await finalizeResponse.json();
-            }
-            catch {
-                payload = await finalizeResponse.text().catch(() => undefined);
-            }
-            const apiError = extractApiErrorPayload(payload);
-            const details = apiError.details ? `\nDetails: ${JSON.stringify(apiError.details)}` : '';
-            const message = apiError.message || `Finalize failed: ${finalizeResponse.status}`;
-            throw new Error(message + details);
-        }
-        const finalizeData = (await finalizeResponse.json());
-        if (!finalizeData.success) {
-            throw new Error(finalizeData.error?.message || 'Upload finalize failed');
-        }
-        console.log(`✅ Report finalized: ${finalizeData.data.reportId}`);
-        console.log(`   Quota updated`);
-    }
-    catch (error) {
-        console.error('❌ Upload failed:', error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-}
-async function discoverFiles(rootPath, options) {
-    const files = [];
-    async function walk(dir) {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                // Skip excluded directories
-                if (options.exclude.some(e => entry.name.includes(e)))
-                    continue;
-                await walk(fullPath);
-            }
-            else if (entry.isFile()) {
-                // Check include patterns - support glob patterns like **/*.{ts,tsx}
-                const shouldInclude = options.include.some(pattern => {
-                    // Handle brace expansion: **/*.{ts,tsx} → match **/*.ts or **/*.tsx
-                    if (pattern.includes('{') && pattern.includes('}')) {
-                        const braceMatch = pattern.match(/\{([^}]+)\}/);
-                        if (braceMatch) {
-                            const extensions = braceMatch[1].split(',');
-                            const basePattern = pattern.replace(/\{[^}]+\}/, '');
-                            return extensions.some(ext => {
-                                const fullPattern = basePattern + ext;
-                                return matchGlob(fullPath, fullPattern);
-                            });
-                        }
-                    }
-                    return matchGlob(fullPath, pattern);
-                });
-                if (shouldInclude) {
-                    // Check file size
-                    try {
-                        const stats = await fs.stat(fullPath);
-                        if (stats.size <= options.maxSize) {
-                            files.push(fullPath);
-                        }
-                    }
-                    catch {
-                        // Skip files we can't stat
-                    }
-                }
-            }
-        }
-    }
-    await walk(rootPath);
-    return files;
-}
-function matchGlob(filePath, pattern) {
-    // Convert glob pattern to regex
-    // **/*.ts → matches any .ts file in any directory
-    // *.ts → matches .ts files in current directory
-    const fileName = filePath.split(/[/\\]/).pop() || '';
-    if (pattern.includes('**')) {
-        // Match any directory depth
-        const ext = pattern.replace('**/*', '');
-        return fileName.endsWith(ext);
-    }
-    else if (pattern.includes('*')) {
-        // Simple wildcard
-        const ext = pattern.replace('*', '');
-        return fileName.endsWith(ext);
-    }
-    // Exact match
-    return filePath.includes(pattern);
-}
-function renderProgressBar(percentage) {
-    const width = 20;
-    const filled = Math.round((percentage / 100) * width);
-    const empty = width - filled;
-    const filledBar = chalk.cyan('█'.repeat(filled));
-    const emptyBar = chalk.gray('░'.repeat(empty));
-    return `${filledBar}${emptyBar} ${chalk.bold(`${percentage}%`)}`;
-}
-// Helper to format duration
-function formatDuration(ms) {
-    if (ms < 1000)
-        return `${ms}ms`;
-    return `${(ms / 1000).toFixed(2)}s`;
-}
-//# sourceMappingURL=analyze.js.map

package/dist/commands/auth-new.js

@@ -1,37 +0,0 @@
-import chalk from 'chalk';
-import { startOAuthFlow, authenticateWithPAT, SecureTokenStore } from '../auth/secure-auth.js';
-import { printSuccess, printInfo } from '../ui.js';
-import prompts from 'prompts';
-export async function loginCommand(options) {
-    // Check if already authenticated
-    if (await SecureTokenStore.hasTokens()) {
-        const overwrite = await prompts({
-            type: 'confirm',
-            name: 'value',
-            message: chalk.yellow('Already authenticated. Overwrite existing credentials?'),
-            initial: false,
-        });
-        if (!overwrite.value) {
-            printInfo('Login cancelled');
-            return;
-        }
-    }
-    if (options.token) {
-        // PAT authentication
-        await authenticateWithPAT(options.token);
-    }
-    else {
-        // OAuth2 flow
-        const method = options.method || 'oauth';
-        const success = await startOAuthFlow(method);
-        if (success) {
-            printSuccess('You are now logged in!');
-            printInfo('Run "delta whoami" to see your account info');
-        }
-    }
-}
-export async function logoutCommand() {
-    const { logout } = await import('../auth/secure-auth.js');
-    await logout();
-}
-//# sourceMappingURL=auth-new.js.map

package/dist/commands/auth.js

@@ -1,131 +0,0 @@
-/**
- * Enhanced Auth Commands - Professional CLI with interactive prompts
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import { icons, startSpinner, stopSpinner, printHeader, printSection, printSuccess, printError, printInfo, printKeyValue, printCommandHint, createTable, printWelcome, } from '../ui.js';
-import { SecureTokenStore } from '../auth/secure-auth.js';
-import { startDeviceFlow } from '../auth/device-auth.js';
-const CONFIG_DIR = path.join(os.homedir(), '.delta');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-async function loadConfig() {
-    try {
-        const data = await fs.readFile(CONFIG_FILE, 'utf-8');
-        return JSON.parse(data);
-    }
-    catch {
-        return {};
-    }
-}
-async function saveConfig(config) {
-    await fs.mkdir(CONFIG_DIR, { recursive: true });
-    await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-export const authCommands = {
-    async login(options) {
-        printWelcome();
-        printHeader('Authentication');
-        const token = options.token ?? process.env.DELTA_PAT;
-        // Load existing config to get custom apiUrl if set
-        const existingConfig = await loadConfig();
-        const apiUrl = process.env.DELTA_API_URL || existingConfig.apiUrl || 'http://localhost:3000';
-        // If no token provided, use Device Authorization Flow
-        if (!token) {
-            printInfo('No token provided. Starting Device Authorization Flow...');
-            printInfo('This will open your browser for secure authentication.');
-            console.log();
-            const success = await startDeviceFlow(apiUrl);
-            if (!success) {
-                printError('Device authorization failed');
-                console.log();
-                printInfo('You can also authenticate using a Personal Access Token:');
-                printCommandHint('delta login --token <your-token>', '');
-                process.exit(1);
-            }
-            // Device flow already saved the token and showed success
-            process.exit(0);
-        }
-        // PAT Token flow (when token is provided)
-        // Validate token format
-        if (!token.startsWith('delta_pat_')) {
-            printError('Invalid PAT token format', 'Token should start with "delta_pat_"');
-            console.log();
-            printInfo('You can get your PAT from:');
-            printCommandHint('http://localhost:3000/dashboard/cli-tokens', '');
-            process.exit(1);
-        }
-        printSection('Connecting to Platform');
-        printKeyValue('API Endpoint', apiUrl);
-        console.log();
-        startSpinner('Verifying credentials...');
-        try {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 10000);
-            const response = await fetch(`${apiUrl}/api/me/entitlements`, {
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                    'Content-Type': 'application/json',
-                },
-                signal: controller.signal,
-            });
-            clearTimeout(timeout);
-            if (!response.ok) {
-                const errorText = await response.text().catch(() => response.statusText);
-                throw new Error(`HTTP ${response.status}: ${errorText}`);
-            }
-            const data = (await response.json());
-            if (!data.success) {
-                throw new Error(data.error?.message || 'Authentication failed');
-            }
-            // Save config - store PAT securely in keychain, NOT in config file
-            await SecureTokenStore.saveAccessToken(token);
-            // Save only non-sensitive config
-            await saveConfig({
-                apiUrl,
-                lastUsedAt: new Date().toISOString(),
-            });
-            stopSpinner(true, 'Authentication successful!');
-            console.log();
-            const user = data.data.user;
-            const quota = data.data.quota;
-            printHeader('Account Overview');
-            // User info table
-            const userTable = createTable(['Property', 'Value']);
-            userTable.push([icons.user + ' Email', user.email], [icons.package + ' Plan', user.plan], [icons.chart + ' Quota Used', `${quota.used}/${quota.limit} reports`], [icons.lock + ' Config', CONFIG_FILE]);
-            console.log(userTable.toString());
-            console.log();
-            printSuccess(`Welcome back, ${user.email.split('@')[0]}! 🎉`);
-            console.log();
-            printCommandHint('delta whoami', 'to see full account details');
-            printCommandHint('delta analyze', 'to start analyzing code');
-            process.exit(0);
-        }
-        catch (error) {
-            stopSpinner(false, 'Authentication failed');
-            console.log();
-            if (error instanceof Error && error.name === 'AbortError') {
-                printError('Request timeout (10s)', 'Check if the server is running and accessible');
-            }
-            else {
-                const message = error instanceof Error ? error.message : String(error);
-                if (message.includes('401')) {
-                    printError('Invalid or expired token', 'Generate a new token from the web app');
-                }
-                else if (message.includes('ENOTFOUND') || message.includes('ECONNREFUSED')) {
-                    printError('Cannot connect to server', 'Check your internet connection and API URL');
-                }
-                else {
-                    printError(message);
-                }
-            }
-            console.log();
-            printInfo('Need help? Visit: http://localhost:3000/docs/cli/authentication');
-            process.exit(1);
-        }
-    },
-};
-// Export individual commands for direct import
-export const loginCommand = authCommands.login;
-export { loadConfig, saveConfig, CONFIG_FILE };
-//# sourceMappingURL=auth.js.map

package/dist/commands/config.js

@@ -1,51 +0,0 @@
-/**
- * Config Command - Manage CLI configuration
- */
-import { loadConfig, saveConfig, CONFIG_FILE } from './auth.js';
-import { SecureTokenStore } from '../auth/secure-auth.js';
-export async function configCommand(options) {
-    const config = await loadConfig();
-    if (options.get) {
-        const value = config[options.get];
-        if (value !== undefined) {
-            console.log(`${options.get}: ${value}`);
-        }
-        else {
-            console.log(`${options.get}: (not set)`);
-        }
-        process.exit(0);
-    }
-    if (options.set) {
-        const [key, value] = options.set.split('=');
-        if (!key || value === undefined) {
-            console.error('❌ Error: Invalid format. Use: key=value');
-            process.exit(1);
-        }
-        const newConfig = {
-            ...config,
-            apiUrl: config.apiUrl || 'http://localhost:3000',
-            [key]: value,
-        };
-        await saveConfig(newConfig);
-        console.log(`✅ Set ${key} = ${value}`);
-        process.exit(0);
-    }
-    if (options.list || (!options.get && !options.set)) {
-        console.log('🔧 Delta CLI Configuration');
-        console.log(`   Config file: ${CONFIG_FILE}`);
-        console.log();
-        const hasPat = await SecureTokenStore.hasTokens();
-        if (hasPat) {
-            console.log('   PAT: ✅ Set (securely stored in keychain)');
-        }
-        else {
-            console.log('   PAT: ❌ Not set');
-        }
-        console.log(`   API URL: ${config.apiUrl || 'http://localhost:3000 (default)'}`);
-        if (config.lastUsedAt) {
-            console.log(`   Last used: ${new Date(config.lastUsedAt).toLocaleString()}`);
-        }
-        process.exit(0);
-    }
-}
-//# sourceMappingURL=config.js.map

package/dist/commands/deploy.js

@@ -1,6 +0,0 @@
-import { printSuccess, printInfo } from '../ui.js';
-export async function deployCommand(_options) {
-    printInfo('Deploying documentation site...');
-    printSuccess('Deploy completed successfully');
-}
-//# sourceMappingURL=deploy.js.map

package/dist/commands/init.js

@@ -1,47 +0,0 @@
-/**
- * Init Command - Initialize a new Delta project
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-export async function initCommand(projectPath, options) {
-    const targetPath = path.resolve(projectPath);
-    const configPath = path.join(targetPath, 'delta.config.json');
-    try {
-        // Check if directory exists
-        await fs.access(targetPath);
-    }
-    catch {
-        console.log(`📁 Creating directory: ${targetPath}`);
-        await fs.mkdir(targetPath, { recursive: true });
-    }
-    // Check if config already exists
-    try {
-        await fs.access(configPath);
-        if (!options.force) {
-            console.log('⚠️  Delta config already exists');
-            console.log('   Use --force to overwrite');
-            return;
-        }
-    }
-    catch {
-        // Config doesn't exist, continue
-    }
-    // Create default config
-    const config = {
-        name: path.basename(targetPath),
-        version: '1.0.0',
-        template: options.template || 'default',
-        createdAt: new Date().toISOString(),
-        settings: {
-            include: ['src/**/*'],
-            exclude: ['node_modules', 'dist', '.git'],
-            maxFileSize: 10485760,
-        },
-    };
-    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
-    console.log('✅ Project initialized');
-    console.log(`   Path: ${targetPath}`);
-    console.log(`   Config: ${configPath}`);
-    console.log(`   Template: ${config.template}`);
-}
-//# sourceMappingURL=init.js.map