monomind 1.17.0 → 1.17.2

package/packages/@monomind/cli/dist/src/commands/analyze-symbols.js

@@ -0,0 +1,302 @@
+/**
+ * Analyze complexity and symbols subcommands
+ * Complexity analysis and symbol extraction from code files
+ */
+import { output } from '../output.js';
+import * as fs from 'fs/promises';
+import { resolve } from 'path';
+import { getASTAnalyzer, safeWriteOutputFile, scanSourceFiles, fallbackAnalyze } from './analyze.js';
+import { truncatePathAst, formatComplexityValueAst, getTypeMarkerAst } from './analyze-ast.js';
+/**
+ * Complexity analysis subcommand
+ */
+export const complexityAstCommand = {
+    name: 'complexity',
+    aliases: ['cx'],
+    description: 'Analyze code complexity metrics',
+    options: [
+        {
+            name: 'threshold',
+            short: 't',
+            description: 'Complexity threshold to flag (default: 10)',
+            type: 'number',
+            default: 10,
+        },
+        {
+            name: 'format',
+            short: 'f',
+            description: 'Output format (text, json)',
+            type: 'string',
+            default: 'text',
+            choices: ['text', 'json'],
+        },
+        {
+            name: 'output',
+            short: 'o',
+            description: 'Output file path',
+            type: 'string',
+        },
+    ],
+    examples: [
+        { command: 'monomind analyze complexity src/', description: 'Analyze complexity' },
+        { command: 'monomind analyze complexity src/ --threshold 15', description: 'Flag high complexity' },
+    ],
+    action: async (ctx) => {
+        const targetPath = ctx.args[0] || ctx.cwd;
+        const threshold = ctx.flags.threshold || 10;
+        const formatType = ctx.flags.format || 'text';
+        const outputFile = ctx.flags.output;
+        output.printInfo(`Analyzing complexity: ${output.highlight(targetPath)}`);
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Calculating complexity...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const astModule = await getASTAnalyzer();
+            const resolvedPath = resolve(targetPath);
+            const stat = await fs.stat(resolvedPath);
+            const files = stat.isDirectory() ? await scanSourceFiles(resolvedPath) : [resolvedPath];
+            const results = [];
+            for (const file of files.slice(0, 100)) {
+                try {
+                    const content = await fs.readFile(file, 'utf-8');
+                    let analysis;
+                    if (astModule) {
+                        const analyzer = astModule.createASTAnalyzer();
+                        analysis = analyzer.analyze(content, file);
+                    }
+                    else {
+                        analysis = fallbackAnalyze(content, file);
+                    }
+                    const flagged = analysis.complexity.cyclomatic > threshold;
+                    const rating = analysis.complexity.cyclomatic <= 5 ? 'Simple' :
+                        analysis.complexity.cyclomatic <= 10 ? 'Moderate' :
+                            analysis.complexity.cyclomatic <= 20 ? 'Complex' : 'Very Complex';
+                    results.push({
+                        file: file,
+                        cyclomatic: analysis.complexity.cyclomatic,
+                        cognitive: analysis.complexity.cognitive,
+                        loc: analysis.complexity.loc,
+                        commentDensity: analysis.complexity.commentDensity,
+                        rating,
+                        flagged,
+                    });
+                }
+                catch {
+                    // Skip files that can't be analyzed
+                }
+            }
+            spinner.stop();
+            // Sort by complexity descending
+            results.sort((a, b) => b.cyclomatic - a.cyclomatic);
+            const flaggedCount = results.filter(r => r.flagged).length;
+            const avgComplexity = results.length > 0
+                ? results.reduce((sum, r) => sum + r.cyclomatic, 0) / results.length
+                : 0;
+            if (formatType === 'json') {
+                const jsonOutput = { files: results, summary: { total: results.length, flagged: flaggedCount, avgComplexity, threshold } };
+                if (outputFile) {
+                    await safeWriteOutputFile(outputFile, JSON.stringify(jsonOutput, null, 2));
+                    output.printSuccess(`Results written to ${outputFile}`);
+                }
+                else {
+                    output.printJson(jsonOutput);
+                }
+                return { success: true, data: jsonOutput };
+            }
+            // Summary
+            output.printBox([
+                `Files analyzed: ${results.length}`,
+                `Threshold: ${threshold}`,
+                `Flagged files: ${flaggedCount > 0 ? output.error(String(flaggedCount)) : output.success('0')}`,
+                `Average complexity: ${formatComplexityValueAst(Math.round(avgComplexity))}`,
+            ].join('\n'), 'Complexity Analysis');
+            // Show flagged files first
+            if (flaggedCount > 0) {
+                output.writeln();
+                output.writeln(output.bold(output.warning(`High Complexity Files (>${threshold})`)));
+                output.writeln(output.dim('-'.repeat(60)));
+                const flaggedFiles = results.filter(r => r.flagged).slice(0, 10);
+                output.printTable({
+                    columns: [
+                        { key: 'file', header: 'File', width: 40, format: (v) => truncatePathAst(v) },
+                        { key: 'cyclomatic', header: 'Cyclo', width: 8, align: 'right', format: (v) => output.error(String(v)) },
+                        { key: 'cognitive', header: 'Cogni', width: 8, align: 'right' },
+                        { key: 'loc', header: 'LOC', width: 8, align: 'right' },
+                        { key: 'rating', header: 'Rating', width: 15 },
+                    ],
+                    data: flaggedFiles,
+                });
+            }
+            // Show all files in table format
+            output.writeln();
+            output.writeln(output.bold('All Files'));
+            output.writeln(output.dim('-'.repeat(60)));
+            const displayFiles = results.slice(0, 15);
+            output.printTable({
+                columns: [
+                    { key: 'file', header: 'File', width: 40, format: (v) => truncatePathAst(v) },
+                    { key: 'cyclomatic', header: 'Cyclo', width: 8, align: 'right', format: (v) => formatComplexityValueAst(v) },
+                    { key: 'cognitive', header: 'Cogni', width: 8, align: 'right' },
+                    { key: 'loc', header: 'LOC', width: 8, align: 'right' },
+                ],
+                data: displayFiles,
+            });
+            if (results.length > 15) {
+                output.writeln(output.dim(`  ... and ${results.length - 15} more files`));
+            }
+            if (outputFile) {
+                await safeWriteOutputFile(outputFile, JSON.stringify({ files: results, summary: { total: results.length, flagged: flaggedCount, avgComplexity, threshold } }, null, 2));
+                output.printSuccess(`Results written to ${outputFile}`);
+            }
+            return { success: true, data: { files: results, flaggedCount } };
+        }
+        catch (error) {
+            spinner.stop();
+            const message = error instanceof Error ? error.message : String(error);
+            output.printError(`Complexity analysis failed: ${message}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+/**
+ * Symbol extraction subcommand
+ */
+export const symbolsCommand = {
+    name: 'symbols',
+    aliases: ['sym'],
+    description: 'Extract and list code symbols (functions, classes, types)',
+    options: [
+        {
+            name: 'type',
+            short: 't',
+            description: 'Filter by symbol type (function, class, all)',
+            type: 'string',
+            default: 'all',
+            choices: ['function', 'class', 'all'],
+        },
+        {
+            name: 'format',
+            short: 'f',
+            description: 'Output format (text, json)',
+            type: 'string',
+            default: 'text',
+            choices: ['text', 'json'],
+        },
+        {
+            name: 'output',
+            short: 'o',
+            description: 'Output file path',
+            type: 'string',
+        },
+    ],
+    examples: [
+        { command: 'monomind analyze symbols src/', description: 'Extract all symbols' },
+        { command: 'monomind analyze symbols src/ --type function', description: 'Only functions' },
+        { command: 'monomind analyze symbols src/ --format json', description: 'JSON output' },
+    ],
+    action: async (ctx) => {
+        const targetPath = ctx.args[0] || ctx.cwd;
+        const symbolType = ctx.flags.type || 'all';
+        const formatType = ctx.flags.format || 'text';
+        const outputFile = ctx.flags.output;
+        output.printInfo(`Extracting symbols: ${output.highlight(targetPath)}`);
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Parsing code...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const astModule = await getASTAnalyzer();
+            const resolvedPath = resolve(targetPath);
+            const stat = await fs.stat(resolvedPath);
+            const files = stat.isDirectory() ? await scanSourceFiles(resolvedPath) : [resolvedPath];
+            const symbols = [];
+            for (const file of files.slice(0, 100)) {
+                try {
+                    const content = await fs.readFile(file, 'utf-8');
+                    let analysis;
+                    if (astModule) {
+                        const analyzer = astModule.createASTAnalyzer();
+                        analysis = analyzer.analyze(content, file);
+                    }
+                    else {
+                        analysis = fallbackAnalyze(content, file);
+                    }
+                    if (symbolType === 'all' || symbolType === 'function') {
+                        for (const fn of analysis.functions) {
+                            symbols.push({
+                                name: fn.name,
+                                type: 'function',
+                                file,
+                                startLine: fn.startLine,
+                                endLine: fn.endLine,
+                            });
+                        }
+                    }
+                    if (symbolType === 'all' || symbolType === 'class') {
+                        for (const cls of analysis.classes) {
+                            symbols.push({
+                                name: cls.name,
+                                type: 'class',
+                                file,
+                                startLine: cls.startLine,
+                                endLine: cls.endLine,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Skip files that can't be parsed
+                }
+            }
+            spinner.stop();
+            // Sort by file then name
+            symbols.sort((a, b) => a.file.localeCompare(b.file) || a.name.localeCompare(b.name));
+            if (formatType === 'json') {
+                if (outputFile) {
+                    await safeWriteOutputFile(outputFile, JSON.stringify(symbols, null, 2));
+                    output.printSuccess(`Results written to ${outputFile}`);
+                }
+                else {
+                    output.printJson(symbols);
+                }
+                return { success: true, data: symbols };
+            }
+            // Summary
+            const functionCount = symbols.filter(s => s.type === 'function').length;
+            const classCount = symbols.filter(s => s.type === 'class').length;
+            output.printBox([
+                `Total symbols: ${symbols.length}`,
+                `Functions: ${functionCount}`,
+                `Classes: ${classCount}`,
+                `Files: ${files.length}`,
+            ].join('\n'), 'Symbol Extraction');
+            output.writeln();
+            output.writeln(output.bold('Symbols'));
+            output.writeln(output.dim('-'.repeat(60)));
+            const displaySymbols = symbols.slice(0, 30);
+            output.printTable({
+                columns: [
+                    { key: 'type', header: 'Type', width: 10, format: (v) => getTypeMarkerAst(v) },
+                    { key: 'name', header: 'Name', width: 30 },
+                    { key: 'file', header: 'File', width: 35, format: (v) => truncatePathAst(v, 33) },
+                    { key: 'startLine', header: 'Line', width: 8, align: 'right' },
+                ],
+                data: displaySymbols,
+            });
+            if (symbols.length > 30) {
+                output.writeln(output.dim(`  ... and ${symbols.length - 30} more symbols`));
+            }
+            if (outputFile) {
+                await safeWriteOutputFile(outputFile, JSON.stringify(symbols, null, 2));
+                output.printSuccess(`Results written to ${outputFile}`);
+            }
+            return { success: true, data: symbols };
+        }
+        catch (error) {
+            spinner.stop();
+            const message = error instanceof Error ? error.message : String(error);
+            output.printError(`Symbol extraction failed: ${message}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+//# sourceMappingURL=analyze-symbols.js.map

package/packages/@monomind/cli/dist/src/commands/analyze.d.ts

@@ -14,6 +14,44 @@
  * github.com/monoes/monomind
  */
 import type { Command } from '../types.js';
+type AnalyzerModule = any;
+export declare function getASTAnalyzer(): Promise<AnalyzerModule | null>;
+export declare function getGraphAnalyzer(): Promise<AnalyzerModule | null>;
+/**
+ * Write analysis output to a file, constraining the path to the current working
+ * directory to prevent path traversal attacks via --output /etc/cron.d/x or
+ * similar. Throws if the resolved path escapes cwd.
+ */
+export declare function safeWriteOutputFile(outputFile: string, data: string): Promise<void>;
+/**
+ * Helper: Scan directory for source files
+ */
+export declare function scanSourceFiles(dir: string, maxDepth?: number): Promise<string[]>;
+/**
+ * Fallback analysis when monovector is not available
+ */
+export declare function fallbackAnalyze(code: string, filePath: string): {
+    filePath: string;
+    language: string;
+    functions: {
+        name: string;
+        startLine: number;
+        endLine: number;
+    }[];
+    classes: {
+        name: string;
+        startLine: number;
+        endLine: number;
+    }[];
+    imports: string[];
+    exports: string[];
+    complexity: {
+        cyclomatic: number;
+        cognitive: number;
+        loc: number;
+        commentDensity: number;
+    };
+};
 export declare const analyzeCommand: Command;
 export default analyzeCommand;
 //# sourceMappingURL=analyze.d.ts.map