archicore 0.1.0

package/dist/architecture/index.js

@@ -0,0 +1,249 @@
+/**
+ * Architecture Knowledge Layer
+ *
+ * Слой архитектурных знаний:
+ * - Bounded Contexts (границы контекстов)
+ * - Domain Entities (доменные сущности)
+ * - Architectural Rules (архитектурные правила)
+ * - Invariants (инварианты)
+ */
+import { Logger } from '../utils/logger.js';
+import { readFile, writeFile } from 'fs/promises';
+export class ArchitectureKnowledge {
+    model;
+    configPath;
+    constructor(configPath = '.aiarhitector/architecture.json') {
+        this.configPath = configPath;
+        this.model = {
+            boundedContexts: [],
+            entities: [],
+            rules: [],
+            invariants: []
+        };
+    }
+    async load() {
+        try {
+            const content = await readFile(this.configPath, 'utf-8');
+            this.model = JSON.parse(content);
+            Logger.success('Architecture model loaded');
+        }
+        catch (error) {
+            Logger.warn('No architecture model found, using defaults');
+            this.initializeDefaults();
+        }
+    }
+    async save() {
+        try {
+            const content = JSON.stringify(this.model, null, 2);
+            await writeFile(this.configPath, content, 'utf-8');
+            Logger.success('Architecture model saved');
+        }
+        catch (error) {
+            Logger.error('Failed to save architecture model', error);
+            throw error;
+        }
+    }
+    getModel() {
+        return this.model;
+    }
+    addBoundedContext(context) {
+        this.model.boundedContexts.push(context);
+        Logger.success(`Added bounded context: ${context.name}`);
+    }
+    addEntity(entity) {
+        this.model.entities.push(entity);
+        Logger.success(`Added entity: ${entity.name}`);
+    }
+    addRule(rule) {
+        this.model.rules.push(rule);
+        Logger.success(`Added rule: ${rule.description}`);
+    }
+    addInvariant(invariant) {
+        this.model.invariants.push(invariant);
+        Logger.success(`Added invariant: ${invariant.description}`);
+    }
+    validateArchitecture(context) {
+        Logger.progress('Validating architecture...');
+        const violations = [];
+        for (const rule of this.model.rules) {
+            const ruleViolations = rule.validator(context);
+            violations.push(...ruleViolations);
+        }
+        violations.push(...this.validateBoundedContexts(context));
+        violations.push(...this.validateInvariants(context));
+        if (violations.length > 0) {
+            Logger.warn(`Found ${violations.length} architecture violations`);
+        }
+        else {
+            Logger.success('Architecture validation passed');
+        }
+        return violations;
+    }
+    validateBoundedContexts(context) {
+        const violations = [];
+        for (const boundedContext of this.model.boundedContexts) {
+            for (const prohibited of boundedContext.prohibitedDependencies) {
+                const hasProhibitedDep = this.checkDependency(context.graph, boundedContext.modules, prohibited);
+                if (hasProhibitedDep) {
+                    violations.push({
+                        rule: `bounded-context-isolation:${boundedContext.name}`,
+                        severity: 'error',
+                        message: `Bounded context "${boundedContext.name}" has prohibited dependency on "${prohibited}"`,
+                        suggestion: `Remove dependency or refactor to use proper interface`
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    validateInvariants(_context) {
+        const violations = [];
+        for (const invariant of this.model.invariants) {
+            Logger.info(`Checking invariant: ${invariant.description}`);
+        }
+        return violations;
+    }
+    checkDependency(graph, modules, targetModule) {
+        for (const module of modules) {
+            const edges = graph.edges.get(module) || [];
+            for (const edge of edges) {
+                const targetNode = graph.nodes.get(edge.to);
+                if (targetNode?.filePath.includes(targetModule)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    getBoundedContext(name) {
+        return this.model.boundedContexts.find(c => c.name === name);
+    }
+    getEntity(name) {
+        return this.model.entities.find(e => e.name === name);
+    }
+    getContextForFile(filePath) {
+        for (const context of this.model.boundedContexts) {
+            for (const module of context.modules) {
+                if (filePath.includes(module)) {
+                    return context;
+                }
+            }
+        }
+        return null;
+    }
+    initializeDefaults() {
+        this.model = {
+            boundedContexts: [
+                {
+                    id: 'core',
+                    name: 'Core',
+                    description: 'Core domain logic',
+                    modules: ['src/core'],
+                    dependencies: [],
+                    prohibitedDependencies: ['src/ui', 'src/external']
+                },
+                {
+                    id: 'ui',
+                    name: 'UI',
+                    description: 'User interface layer',
+                    modules: ['src/ui'],
+                    dependencies: ['src/core'],
+                    prohibitedDependencies: ['src/external']
+                },
+                {
+                    id: 'external',
+                    name: 'External',
+                    description: 'External integrations',
+                    modules: ['src/external'],
+                    dependencies: ['src/core'],
+                    prohibitedDependencies: ['src/ui']
+                }
+            ],
+            entities: [],
+            rules: this.createDefaultRules(),
+            invariants: []
+        };
+    }
+    createDefaultRules() {
+        return [
+            {
+                id: 'no-circular-deps',
+                description: 'No circular dependencies allowed',
+                type: 'dependency',
+                severity: 'error',
+                validator: (context) => {
+                    return this.detectCircularDependencies(context.graph);
+                }
+            },
+            {
+                id: 'naming-convention',
+                description: 'Follow naming conventions',
+                type: 'naming',
+                severity: 'warning',
+                pattern: '^[A-Z][a-zA-Z0-9]*$',
+                validator: (_context) => {
+                    return [];
+                }
+            }
+        ];
+    }
+    detectCircularDependencies(graph) {
+        const violations = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const hasCycle = (nodeId, path) => {
+            visited.add(nodeId);
+            recursionStack.add(nodeId);
+            const edges = graph.edges.get(nodeId) || [];
+            for (const edge of edges) {
+                if (!visited.has(edge.to)) {
+                    if (hasCycle(edge.to, [...path, nodeId])) {
+                        return true;
+                    }
+                }
+                else if (recursionStack.has(edge.to)) {
+                    violations.push({
+                        rule: 'no-circular-deps',
+                        severity: 'error',
+                        message: `Circular dependency detected: ${[...path, nodeId, edge.to].join(' -> ')}`,
+                        suggestion: 'Refactor to break the circular dependency'
+                    });
+                    return true;
+                }
+            }
+            recursionStack.delete(nodeId);
+            return false;
+        };
+        for (const nodeId of graph.nodes.keys()) {
+            if (!visited.has(nodeId)) {
+                hasCycle(nodeId, []);
+            }
+        }
+        return violations;
+    }
+    generateReport() {
+        let report = '# Architecture Report\n\n';
+        report += '## Bounded Contexts\n\n';
+        for (const context of this.model.boundedContexts) {
+            report += `### ${context.name}\n`;
+            report += `${context.description}\n\n`;
+            report += `**Modules:** ${context.modules.join(', ')}\n`;
+            report += `**Dependencies:** ${context.dependencies.join(', ') || 'None'}\n`;
+            report += `**Prohibited:** ${context.prohibitedDependencies.join(', ') || 'None'}\n\n`;
+        }
+        report += '## Domain Entities\n\n';
+        for (const entity of this.model.entities) {
+            report += `### ${entity.name}\n`;
+            report += `**Context:** ${entity.context}\n`;
+            report += `**Properties:** ${entity.properties.length}\n`;
+            report += `**Relationships:** ${entity.relationships.length}\n\n`;
+        }
+        report += '## Rules\n\n';
+        for (const rule of this.model.rules) {
+            report += `- **${rule.description}** (${rule.severity})\n`;
+        }
+        return report;
+    }
+}
+export * from '../types/index.js';
+//# sourceMappingURL=index.js.map

package/dist/cli/commands/analyzers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ArchiCore CLI - Analyzer Commands
+ */
+import { Command } from 'commander';
+export declare function registerAnalyzerCommands(program: Command): void;
+//# sourceMappingURL=analyzers.d.ts.map

package/dist/cli/commands/analyzers.js

@@ -0,0 +1,431 @@
+/**
+ * ArchiCore CLI - Analyzer Commands
+ */
+import { loadConfig } from '../utils/config.js';
+import { colors, icons, createSpinner, printSuccess, printError, printSection, printKeyValue, metricsTable, formatSeverity, } from '../ui/index.js';
+async function getProjectId() {
+    const config = await loadConfig();
+    if (!config.activeProjectId) {
+        throw new Error('No project selected. Use "archicore projects select <id>" first.');
+    }
+    return config.activeProjectId;
+}
+async function fetchAnalysis(endpoint, projectId) {
+    const config = await loadConfig();
+    const id = projectId || await getProjectId();
+    const response = await fetch(`${config.serverUrl}/api/projects/${id}/${endpoint}`);
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error || `Failed to run ${endpoint}`);
+    }
+    return response.json();
+}
+export function registerAnalyzerCommands(program) {
+    // Dead Code
+    program
+        .command('dead-code')
+        .description('Find dead/unused code')
+        .option('-p, --project <id>', 'Project ID')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spinner = createSpinner('Analyzing dead code...').start();
+        try {
+            const data = await fetchAnalysis('dead-code', options.project);
+            spinner.succeed('Analysis complete');
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const result = data.deadCode;
+            printSection('Dead Code Analysis');
+            // Summary
+            console.log(colors.highlight('  Summary'));
+            printKeyValue('  Unused Exports', String(result.unusedExports?.length || 0));
+            printKeyValue('  Unused Variables', String(result.unusedVariables?.length || 0));
+            printKeyValue('  Unreachable Code', String(result.unreachableCode?.length || 0));
+            printKeyValue('  Empty Blocks', String(result.emptyBlocks?.length || 0));
+            printKeyValue('  Commented Code', String(result.commentedCode?.length || 0));
+            console.log();
+            if (result.summary) {
+                printKeyValue('  Total Issues', String(result.summary.totalIssues || 0));
+                printKeyValue('  Cleanup Time', result.summary.estimatedCleanupTime || 'N/A');
+            }
+            // Unused Exports
+            if (result.unusedExports?.length > 0) {
+                printSection('Unused Exports');
+                for (const item of result.unusedExports.slice(0, 15)) {
+                    console.log(`  ${colors.error(icons.error)} ${colors.code(item.name)}`);
+                    console.log(`    ${colors.dim(item.filePath)}:${item.line || ''}`);
+                }
+                if (result.unusedExports.length > 15) {
+                    console.log(colors.muted(`  ... and ${result.unusedExports.length - 15} more`));
+                }
+            }
+            // Unused Variables
+            if (result.unusedVariables?.length > 0) {
+                printSection('Unused Variables');
+                for (const item of result.unusedVariables.slice(0, 15)) {
+                    console.log(`  ${colors.warning(icons.warning)} ${colors.code(item.name)}`);
+                    console.log(`    ${colors.dim(item.filePath)}:${item.line || ''}`);
+                }
+                if (result.unusedVariables.length > 15) {
+                    console.log(colors.muted(`  ... and ${result.unusedVariables.length - 15} more`));
+                }
+            }
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Analysis failed');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Duplication
+    program
+        .command('duplication')
+        .description('Find code duplication')
+        .option('-p, --project <id>', 'Project ID')
+        .option('--min-lines <n>', 'Minimum lines to consider', '5')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spinner = createSpinner('Analyzing duplication...').start();
+        try {
+            const data = await fetchAnalysis('duplication', options.project);
+            spinner.succeed('Analysis complete');
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const result = data.duplication;
+            printSection('Code Duplication Analysis');
+            printKeyValue('  Duplication', `${(result.duplicationPercentage || 0).toFixed(1)}%`);
+            printKeyValue('  Clone Groups', String(result.clones?.length || 0));
+            console.log();
+            if (result.clones?.length > 0) {
+                printSection('Clone Groups');
+                for (const clone of result.clones.slice(0, 10)) {
+                    console.log(`  ${colors.warning(icons.warning)} ${colors.highlight(`${clone.lines || '?'} lines`)} duplicated in ${clone.instances?.length || 0} locations`);
+                    for (const instance of (clone.instances || []).slice(0, 3)) {
+                        console.log(`    ${colors.dim(instance.filePath)}:${instance.startLine}-${instance.endLine}`);
+                    }
+                    if ((clone.instances?.length || 0) > 3) {
+                        console.log(colors.muted(`    ... and ${clone.instances.length - 3} more locations`));
+                    }
+                    console.log();
+                }
+                if (result.clones.length > 10) {
+                    console.log(colors.muted(`  ... and ${result.clones.length - 10} more clone groups`));
+                }
+            }
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Analysis failed');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Security
+    program
+        .command('security')
+        .description('Security vulnerability analysis')
+        .option('-p, --project <id>', 'Project ID')
+        .option('--severity <level>', 'Minimum severity (low|medium|high|critical)')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spinner = createSpinner('Analyzing security...').start();
+        try {
+            const data = await fetchAnalysis('security', options.project);
+            spinner.succeed('Analysis complete');
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const result = data.security;
+            let vulnerabilities = result.vulnerabilities || [];
+            // Filter by severity if specified
+            if (options.severity) {
+                const levels = ['low', 'medium', 'high', 'critical'];
+                const minLevel = levels.indexOf(options.severity.toLowerCase());
+                if (minLevel >= 0) {
+                    vulnerabilities = vulnerabilities.filter((v) => levels.indexOf(v.severity?.toLowerCase() || 'low') >= minLevel);
+                }
+            }
+            printSection('Security Analysis');
+            // Count by severity
+            const counts = {
+                critical: vulnerabilities.filter((v) => v.severity === 'critical').length,
+                high: vulnerabilities.filter((v) => v.severity === 'high').length,
+                medium: vulnerabilities.filter((v) => v.severity === 'medium').length,
+                low: vulnerabilities.filter((v) => v.severity === 'low').length,
+            };
+            console.log(`  ${colors.critical(`${icons.severityCritical} Critical: ${counts.critical}`)}`);
+            console.log(`  ${colors.high(`${icons.severityHigh} High: ${counts.high}`)}`);
+            console.log(`  ${colors.medium(`${icons.severityMedium} Medium: ${counts.medium}`)}`);
+            console.log(`  ${colors.low(`${icons.severityLow} Low: ${counts.low}`)}`);
+            console.log();
+            if (vulnerabilities.length > 0) {
+                printSection('Vulnerabilities');
+                for (const vuln of vulnerabilities.slice(0, 20)) {
+                    const severityMap = {
+                        critical: colors.critical,
+                        high: colors.high,
+                        medium: colors.medium,
+                        low: colors.low,
+                    };
+                    const severityColor = severityMap[vuln.severity?.toLowerCase() || 'low'] || colors.muted;
+                    console.log(`  ${severityColor(formatSeverity(vuln.severity))} ${colors.highlight(vuln.type || vuln.category)}`);
+                    console.log(`    ${vuln.description || vuln.message}`);
+                    console.log(`    ${colors.dim(vuln.filePath)}:${vuln.line || ''}`);
+                    if (vuln.remediation) {
+                        console.log(`    ${colors.info(icons.info)} ${vuln.remediation}`);
+                    }
+                    console.log();
+                }
+                if (vulnerabilities.length > 20) {
+                    console.log(colors.muted(`  ... and ${vulnerabilities.length - 20} more vulnerabilities`));
+                }
+            }
+            else {
+                printSuccess('No vulnerabilities found!');
+            }
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Analysis failed');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Metrics
+    program
+        .command('metrics')
+        .description('Calculate code metrics')
+        .option('-p, --project <id>', 'Project ID')
+        .option('-f, --file <path>', 'Analyze specific file')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spinner = createSpinner('Calculating metrics...').start();
+        try {
+            const data = await fetchAnalysis('metrics', options.project);
+            spinner.succeed('Metrics calculated');
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const result = data.metrics;
+            printSection('Code Metrics');
+            // Summary
+            if (result.summary) {
+                console.log(colors.highlight('  Summary'));
+                printKeyValue('  Total Files', String(result.summary.totalFiles || 0));
+                printKeyValue('  Total Lines', String(result.summary.totalLines || 0));
+                printKeyValue('  Avg Complexity', String((result.summary.avgComplexity || 0).toFixed(2)));
+                printKeyValue('  Avg Maintainability', String((result.summary.avgMaintainability || 0).toFixed(1)));
+                console.log();
+            }
+            // File metrics
+            if (result.files?.length > 0) {
+                printSection('File Metrics');
+                const metrics = result.files.map((f) => ({
+                    file: f.filePath || f.file,
+                    complexity: f.complexity || f.cyclomaticComplexity || 0,
+                    maintainability: f.maintainability || f.maintainabilityIndex || 0,
+                    linesOfCode: f.linesOfCode || f.loc || 0,
+                }));
+                // Sort by complexity descending
+                metrics.sort((a, b) => b.complexity - a.complexity);
+                console.log(metricsTable(metrics.slice(0, 20)));
+                if (metrics.length > 20) {
+                    console.log(colors.muted(`  ... and ${metrics.length - 20} more files`));
+                }
+            }
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Analysis failed');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Rules
+    program
+        .command('rules')
+        .description('Check architectural rules')
+        .option('-p, --project <id>', 'Project ID')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spinner = createSpinner('Checking rules...').start();
+        try {
+            const data = await fetchAnalysis('rules', options.project);
+            spinner.succeed('Rules checked');
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const result = data.rules;
+            const violations = result.violations || [];
+            printSection('Architectural Rules');
+            printKeyValue('  Rules Checked', String(result.rulesChecked || 0));
+            printKeyValue('  Violations', String(violations.length));
+            printKeyValue('  Status', violations.length === 0
+                ? colors.success('PASS')
+                : colors.error('FAIL'));
+            console.log();
+            if (violations.length > 0) {
+                printSection('Violations');
+                for (const v of violations.slice(0, 20)) {
+                    const severityColor = v.severity === 'error' ? colors.error : colors.warning;
+                    console.log(`  ${severityColor(v.severity?.toUpperCase() || 'WARNING')} ${colors.highlight(v.rule || v.type)}`);
+                    console.log(`    ${v.message || v.description}`);
+                    if (v.filePath) {
+                        console.log(`    ${colors.dim(v.filePath)}:${v.line || ''}`);
+                    }
+                    console.log();
+                }
+                if (violations.length > 20) {
+                    console.log(colors.muted(`  ... and ${violations.length - 20} more violations`));
+                }
+            }
+            else {
+                printSuccess('All rules pass!');
+            }
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Analysis failed');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Refactoring
+    program
+        .command('refactoring')
+        .description('Get refactoring suggestions')
+        .option('-p, --project <id>', 'Project ID')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spinner = createSpinner('Analyzing refactoring opportunities...').start();
+        try {
+            const data = await fetchAnalysis('refactoring', options.project);
+            spinner.succeed('Analysis complete');
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const suggestions = data.refactoring?.suggestions || data.suggestions || [];
+            printSection('Refactoring Suggestions');
+            printKeyValue('  Total Suggestions', String(suggestions.length));
+            console.log();
+            if (suggestions.length > 0) {
+                // Group by type
+                const byType = {};
+                for (const s of suggestions) {
+                    const type = s.type || 'other';
+                    if (!byType[type])
+                        byType[type] = [];
+                    byType[type].push(s);
+                }
+                for (const [type, items] of Object.entries(byType)) {
+                    console.log(colors.secondary(`  ${type.replace(/-/g, ' ').toUpperCase()} (${items.length})`));
+                    console.log();
+                    for (const item of items.slice(0, 5)) {
+                        const priority = item.priority || 'medium';
+                        const priorityColor = priority === 'high' ? colors.high : priority === 'low' ? colors.low : colors.medium;
+                        console.log(`    ${priorityColor(icons.bullet)} ${item.description || item.message}`);
+                        if (item.filePath) {
+                            console.log(`      ${colors.dim(item.filePath)}:${item.line || ''}`);
+                        }
+                        if (item.effort) {
+                            console.log(`      ${colors.muted(`Effort: ${item.effort}`)}`);
+                        }
+                    }
+                    if (items.length > 5) {
+                        console.log(colors.muted(`      ... and ${items.length - 5} more`));
+                    }
+                    console.log();
+                }
+            }
+            else {
+                printSuccess('No refactoring suggestions - code looks good!');
+            }
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Analysis failed');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+    // Full Analysis
+    program
+        .command('full-analysis')
+        .alias('analyze-all')
+        .description('Run all analyzers')
+        .option('-p, --project <id>', 'Project ID')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spinner = createSpinner('Running full analysis...').start();
+        try {
+            const config = await loadConfig();
+            const projectId = options.project || config.activeProjectId;
+            if (!projectId) {
+                spinner.fail('No project selected');
+                printError('Use "archicore projects select <id>" first.');
+                process.exit(1);
+            }
+            const response = await fetch(`${config.serverUrl}/api/projects/${projectId}/full-analysis`, {
+                method: 'POST',
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.error || 'Failed to run analysis');
+            }
+            const data = await response.json();
+            spinner.succeed('Full analysis complete');
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            printSection('Full Analysis Summary');
+            // Dead Code
+            const dc = data.deadCode;
+            console.log(colors.secondary('  Dead Code'));
+            console.log(`    Unused: ${dc?.unusedExports?.length || 0} exports, ${dc?.unusedVariables?.length || 0} variables`);
+            console.log();
+            // Duplication
+            const dup = data.duplication;
+            console.log(colors.secondary('  Duplication'));
+            console.log(`    ${(dup?.duplicationPercentage || 0).toFixed(1)}% duplicated, ${dup?.clones?.length || 0} clone groups`);
+            console.log();
+            // Security
+            const sec = data.security;
+            const vulns = sec?.vulnerabilities || [];
+            console.log(colors.secondary('  Security'));
+            console.log(`    ${vulns.length} vulnerabilities found`);
+            console.log();
+            // Metrics
+            const met = data.metrics;
+            console.log(colors.secondary('  Metrics'));
+            console.log(`    Avg complexity: ${(met?.summary?.avgComplexity || 0).toFixed(2)}`);
+            console.log(`    Avg maintainability: ${(met?.summary?.avgMaintainability || 0).toFixed(1)}`);
+            console.log();
+            // Rules
+            const rules = data.rules;
+            console.log(colors.secondary('  Rules'));
+            console.log(`    ${rules?.violations?.length || 0} violations`);
+            console.log();
+            // Refactoring
+            const ref = data.refactoring;
+            console.log(colors.secondary('  Refactoring'));
+            console.log(`    ${ref?.suggestions?.length || 0} suggestions`);
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Analysis failed');
+            printError(String(error));
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=analyzers.js.map