monomind 1.17.0 → 1.17.2

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

@@ -0,0 +1,26 @@
+/**
+ * Analyze AST subcommand
+ * AST-based code analysis using monovector tree-sitter with regex fallback
+ */
+import type { Command } from '../types.js';
+/**
+ * Helper: Truncate file path for display
+ */
+export declare function truncatePathAst(filePath: string, maxLen?: number): string;
+/**
+ * Helper: Format complexity value with color coding
+ */
+export declare function formatComplexityValueAst(value: number): string;
+/**
+ * Helper: Get type marker for symbols
+ */
+export declare function getTypeMarkerAst(type: string): string;
+/**
+ * Helper: Get complexity rating text
+ */
+export declare function getComplexityRatingAst(value: number): string;
+/**
+ * AST analysis subcommand
+ */
+export declare const astCommand: Command;
+//# sourceMappingURL=analyze-ast.d.ts.map

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

@@ -0,0 +1,284 @@
+/**
+ * Analyze AST subcommand
+ * AST-based code analysis using monovector tree-sitter with regex fallback
+ */
+import { output } from '../output.js';
+import * as fs from 'fs/promises';
+import { resolve } from 'path';
+import { getASTAnalyzer, safeWriteOutputFile, scanSourceFiles, fallbackAnalyze } from './analyze.js';
+/**
+ * Helper: Truncate file path for display
+ */
+export function truncatePathAst(filePath, maxLen = 45) {
+    if (filePath.length <= maxLen)
+        return filePath;
+    return '...' + filePath.slice(-(maxLen - 3));
+}
+/**
+ * Helper: Format complexity value with color coding
+ */
+export function formatComplexityValueAst(value) {
+    if (value <= 5)
+        return output.success(String(value));
+    if (value <= 10)
+        return output.warning(String(value));
+    return output.error(String(value));
+}
+/**
+ * Helper: Get type marker for symbols
+ */
+export function getTypeMarkerAst(type) {
+    switch (type) {
+        case 'function': return output.success('fn');
+        case 'class': return output.info('class');
+        case 'variable': return output.dim('var');
+        case 'type': return output.highlight('type');
+        case 'interface': return output.highlight('iface');
+        default: return output.dim(type.slice(0, 5));
+    }
+}
+/**
+ * Helper: Get complexity rating text
+ */
+export function getComplexityRatingAst(value) {
+    if (value <= 5)
+        return output.success('Simple');
+    if (value <= 10)
+        return output.warning('Moderate');
+    if (value <= 20)
+        return output.error('Complex');
+    return output.error(output.bold('Very Complex'));
+}
+/**
+ * AST analysis subcommand
+ */
+export const astCommand = {
+    name: 'ast',
+    description: 'Analyze code using AST parsing (tree-sitter via monovector)',
+    options: [
+        {
+            name: 'complexity',
+            short: 'c',
+            description: 'Include complexity metrics',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'symbols',
+            short: 's',
+            description: 'Include symbol extraction',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'format',
+            short: 'f',
+            description: 'Output format (text, json, table)',
+            type: 'string',
+            default: 'text',
+            choices: ['text', 'json', 'table'],
+        },
+        {
+            name: 'output',
+            short: 'o',
+            description: 'Output file path',
+            type: 'string',
+        },
+        {
+            name: 'verbose',
+            short: 'v',
+            description: 'Show detailed analysis',
+            type: 'boolean',
+            default: false,
+        },
+    ],
+    examples: [
+        { command: 'monomind analyze ast src/', description: 'Analyze all files in src/' },
+        { command: 'monomind analyze ast src/index.ts --complexity', description: 'Analyze with complexity' },
+        { command: 'monomind analyze ast . --format json', description: 'JSON output' },
+        { command: 'monomind analyze ast src/ --symbols', description: 'Extract symbols' },
+    ],
+    action: async (ctx) => {
+        const targetPath = ctx.args[0] || ctx.cwd;
+        const showComplexity = ctx.flags.complexity;
+        const showSymbols = ctx.flags.symbols;
+        const formatType = ctx.flags.format || 'text';
+        const outputFile = ctx.flags.output;
+        const verbose = ctx.flags.verbose;
+        // If no specific flags, show summary
+        const showAll = !showComplexity && !showSymbols;
+        output.printInfo(`Analyzing: ${output.highlight(targetPath)}`);
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Parsing AST...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const astModule = await getASTAnalyzer();
+            if (!astModule) {
+                spinner.stop();
+                output.printWarning('AST analyzer not available, using regex fallback');
+            }
+            // Resolve path and check if file or directory
+            const resolvedPath = resolve(targetPath);
+            const stat = await fs.stat(resolvedPath);
+            const isDirectory = stat.isDirectory();
+            let results = [];
+            if (isDirectory) {
+                // Scan directory for source files
+                const files = await scanSourceFiles(resolvedPath);
+                spinner.stop();
+                output.printInfo(`Found ${files.length} source files`);
+                spinner.start();
+                for (const file of files.slice(0, 100)) {
+                    try {
+                        const content = await fs.readFile(file, 'utf-8');
+                        if (astModule) {
+                            const analyzer = astModule.createASTAnalyzer();
+                            const analysis = analyzer.analyze(content, file);
+                            results.push(analysis);
+                        }
+                        else {
+                            // Fallback analysis
+                            results.push(fallbackAnalyze(content, file));
+                        }
+                    }
+                    catch {
+                        // Skip files that can't be analyzed
+                    }
+                }
+            }
+            else {
+                // Single file
+                const content = await fs.readFile(resolvedPath, 'utf-8');
+                if (astModule) {
+                    const analyzer = astModule.createASTAnalyzer();
+                    const analysis = analyzer.analyze(content, resolvedPath);
+                    results.push(analysis);
+                }
+                else {
+                    results.push(fallbackAnalyze(content, resolvedPath));
+                }
+            }
+            spinner.stop();
+            if (results.length === 0) {
+                output.printWarning('No files analyzed');
+                return { success: true };
+            }
+            // Calculate totals
+            const totals = {
+                files: results.length,
+                functions: results.reduce((sum, r) => sum + r.functions.length, 0),
+                classes: results.reduce((sum, r) => sum + r.classes.length, 0),
+                imports: results.reduce((sum, r) => sum + r.imports.length, 0),
+                avgComplexity: results.reduce((sum, r) => sum + r.complexity.cyclomatic, 0) / results.length,
+                totalLoc: results.reduce((sum, r) => sum + r.complexity.loc, 0),
+            };
+            // JSON output
+            if (formatType === 'json') {
+                const jsonOutput = { files: results, totals };
+                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 box
+            output.printBox([
+                `Files analyzed: ${totals.files}`,
+                `Functions: ${totals.functions}`,
+                `Classes: ${totals.classes}`,
+                `Total LOC: ${totals.totalLoc}`,
+                `Avg Complexity: ${formatComplexityValueAst(Math.round(totals.avgComplexity))}`,
+            ].join('\n'), 'AST Analysis Summary');
+            // Complexity view
+            if (showComplexity || showAll) {
+                output.writeln();
+                output.writeln(output.bold('Complexity by File'));
+                output.writeln(output.dim('-'.repeat(60)));
+                const complexityData = results
+                    .map(r => ({
+                    file: truncatePathAst(r.filePath),
+                    cyclomatic: r.complexity.cyclomatic,
+                    cognitive: r.complexity.cognitive,
+                    loc: r.complexity.loc,
+                    rating: getComplexityRatingAst(r.complexity.cyclomatic),
+                }))
+                    .sort((a, b) => b.cyclomatic - a.cyclomatic)
+                    .slice(0, 15);
+                output.printTable({
+                    columns: [
+                        { key: 'file', header: 'File', width: 40 },
+                        { 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' },
+                        { key: 'rating', header: 'Rating', width: 15 },
+                    ],
+                    data: complexityData,
+                });
+                if (results.length > 15) {
+                    output.writeln(output.dim(`  ... and ${results.length - 15} more files`));
+                }
+            }
+            // Symbols view
+            if (showSymbols || showAll) {
+                output.writeln();
+                output.writeln(output.bold('Extracted Symbols'));
+                output.writeln(output.dim('-'.repeat(60)));
+                const allSymbols = [];
+                for (const r of results) {
+                    for (const fn of r.functions) {
+                        allSymbols.push({ name: fn.name, type: 'function', file: truncatePathAst(r.filePath, 30), line: fn.startLine });
+                    }
+                    for (const cls of r.classes) {
+                        allSymbols.push({ name: cls.name, type: 'class', file: truncatePathAst(r.filePath, 30), line: cls.startLine });
+                    }
+                }
+                const displaySymbols = allSymbols.slice(0, 20);
+                output.printTable({
+                    columns: [
+                        { key: 'type', header: 'Type', width: 8, format: (v) => getTypeMarkerAst(v) },
+                        { key: 'name', header: 'Symbol', width: 30 },
+                        { key: 'file', header: 'File', width: 35 },
+                        { key: 'line', header: 'Line', width: 8, align: 'right' },
+                    ],
+                    data: displaySymbols,
+                });
+                if (allSymbols.length > 20) {
+                    output.writeln(output.dim(`  ... and ${allSymbols.length - 20} more symbols`));
+                }
+            }
+            // Verbose output
+            if (verbose) {
+                output.writeln();
+                output.writeln(output.bold('Import Analysis'));
+                output.writeln(output.dim('-'.repeat(60)));
+                const importCounts = new Map();
+                for (const r of results) {
+                    for (const imp of r.imports) {
+                        importCounts.set(imp, (importCounts.get(imp) || 0) + 1);
+                    }
+                }
+                const topImports = Array.from(importCounts.entries())
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 10);
+                for (const [imp, count] of topImports) {
+                    output.writeln(`  ${output.highlight(count.toString().padStart(3))} ${imp}`);
+                }
+            }
+            if (outputFile) {
+                await safeWriteOutputFile(outputFile, JSON.stringify({ files: results, totals }, null, 2));
+                output.printSuccess(`Results written to ${outputFile}`);
+            }
+            return { success: true, data: { files: results, totals } };
+        }
+        catch (error) {
+            spinner.stop();
+            const message = error instanceof Error ? error.message : String(error);
+            output.printError(`AST analysis failed: ${message}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+//# sourceMappingURL=analyze-ast.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Analyze boundaries and modules subcommands
+ * MinCut boundary detection and Louvain community detection
+ */
+import type { Command } from '../types.js';
+/**
+ * Analyze code boundaries using MinCut algorithm
+ */
+export declare const boundariesCommand: Command;
+/**
+ * Analyze modules/communities using Louvain algorithm
+ */
+export declare const modulesCommand: Command;
+//# sourceMappingURL=analyze-boundaries.d.ts.map

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

@@ -0,0 +1,295 @@
+/**
+ * Analyze boundaries and modules subcommands
+ * MinCut boundary detection and Louvain community detection
+ */
+import { output } from '../output.js';
+import { resolve } from 'path';
+import { getGraphAnalyzer, safeWriteOutputFile } from './analyze.js';
+/**
+ * Analyze code boundaries using MinCut algorithm
+ */
+export const boundariesCommand = {
+    name: 'boundaries',
+    aliases: ['boundary', 'mincut'],
+    description: 'Find natural code boundaries using MinCut algorithm',
+    options: [
+        {
+            name: 'partitions',
+            short: 'p',
+            description: 'Number of partitions to find',
+            type: 'number',
+            default: 2,
+        },
+        {
+            name: 'output',
+            short: 'o',
+            description: 'Output file path',
+            type: 'string',
+        },
+        {
+            name: 'format',
+            short: 'f',
+            description: 'Output format (text, json, dot)',
+            type: 'string',
+            default: 'text',
+            choices: ['text', 'json', 'dot'],
+        },
+    ],
+    examples: [
+        { command: 'monomind analyze boundaries src/', description: 'Find code boundaries in src/' },
+        { command: 'monomind analyze boundaries -p 3 src/', description: 'Find 3 partitions' },
+        { command: 'monomind analyze boundaries -f dot -o graph.dot src/', description: 'Export to DOT format' },
+    ],
+    action: async (ctx) => {
+        const targetDir = ctx.args[0] || ctx.cwd;
+        const rawPartitions = ctx.flags.partitions || 2;
+        const numPartitions = Number.isFinite(rawPartitions) ? Math.max(1, Math.min(rawPartitions, 100)) : 2;
+        const outputFile = ctx.flags.output;
+        const format = ctx.flags.format || 'text';
+        output.printInfo(`Analyzing code boundaries in: ${output.highlight(targetDir)}`);
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Building dependency graph...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const analyzer = await getGraphAnalyzer();
+            if (!analyzer) {
+                spinner.stop();
+                output.printError('Graph analyzer module not available');
+                return { success: false, exitCode: 1 };
+            }
+            const result = await analyzer.analyzeGraph(resolve(targetDir), {
+                includeBoundaries: true,
+                includeModules: false,
+                numPartitions,
+            });
+            spinner.stop();
+            // Handle different output formats
+            if (format === 'json') {
+                const jsonOutput = {
+                    boundaries: result.boundaries,
+                    statistics: result.statistics,
+                    circularDependencies: result.circularDependencies,
+                };
+                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 };
+            }
+            if (format === 'dot') {
+                const dotOutput = analyzer.exportToDot(result, {
+                    includeLabels: true,
+                    highlightCycles: true,
+                });
+                if (outputFile) {
+                    await safeWriteOutputFile(outputFile, dotOutput);
+                    output.printSuccess(`DOT graph written to ${outputFile}`);
+                    output.writeln(output.dim('Visualize with: dot -Tpng -o graph.png ' + outputFile));
+                }
+                else {
+                    output.writeln(dotOutput);
+                }
+                return { success: true };
+            }
+            // Text format (default)
+            output.printBox([
+                `Files analyzed: ${result.statistics.nodeCount}`,
+                `Dependencies: ${result.statistics.edgeCount}`,
+                `Avg degree: ${result.statistics.avgDegree.toFixed(2)}`,
+                `Density: ${(result.statistics.density * 100).toFixed(2)}%`,
+                `Components: ${result.statistics.componentCount}`,
+            ].join('\n'), 'Graph Statistics');
+            if (result.boundaries && result.boundaries.length > 0) {
+                output.writeln();
+                output.writeln(output.bold('MinCut Boundaries'));
+                output.writeln();
+                for (let i = 0; i < result.boundaries.length; i++) {
+                    const boundary = result.boundaries[i];
+                    output.writeln(output.bold(`Boundary ${i + 1} (cut value: ${boundary.cutValue})`));
+                    output.writeln();
+                    output.writeln(output.dim('Partition 1:'));
+                    const p1Display = boundary.partition1.slice(0, 10);
+                    output.printList(p1Display);
+                    if (boundary.partition1.length > 10) {
+                        output.writeln(output.dim(`  ... and ${boundary.partition1.length - 10} more files`));
+                    }
+                    output.writeln();
+                    output.writeln(output.dim('Partition 2:'));
+                    const p2Display = boundary.partition2.slice(0, 10);
+                    output.printList(p2Display);
+                    if (boundary.partition2.length > 10) {
+                        output.writeln(output.dim(`  ... and ${boundary.partition2.length - 10} more files`));
+                    }
+                    output.writeln();
+                    output.writeln(output.success('Suggestion:'));
+                    output.writeln(`  ${boundary.suggestion}`);
+                    output.writeln();
+                }
+            }
+            // Show circular dependencies
+            if (result.circularDependencies.length > 0) {
+                output.writeln();
+                output.writeln(output.bold(output.warning('Circular Dependencies Detected')));
+                output.writeln();
+                for (const cycle of result.circularDependencies.slice(0, 5)) {
+                    const severityColor = cycle.severity === 'high' ? output.error : cycle.severity === 'medium' ? output.warning : output.dim;
+                    output.writeln(`${severityColor(`[${cycle.severity.toUpperCase()}]`)} ${cycle.cycle.join(' -> ')}`);
+                    output.writeln(output.dim(`  ${cycle.suggestion}`));
+                    output.writeln();
+                }
+                if (result.circularDependencies.length > 5) {
+                    output.writeln(output.dim(`... and ${result.circularDependencies.length - 5} more cycles`));
+                }
+            }
+            if (outputFile) {
+                await safeWriteOutputFile(outputFile, JSON.stringify(result, null, 2));
+                output.printSuccess(`Full results written to ${outputFile}`);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            spinner.stop();
+            const message = error instanceof Error ? error.message : String(error);
+            output.printError(`Analysis failed: ${message}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+/**
+ * Analyze modules/communities using Louvain algorithm
+ */
+export const modulesCommand = {
+    name: 'modules',
+    aliases: ['communities', 'louvain'],
+    description: 'Detect module communities using Louvain algorithm',
+    options: [
+        {
+            name: 'output',
+            short: 'o',
+            description: 'Output file path',
+            type: 'string',
+        },
+        {
+            name: 'format',
+            short: 'f',
+            description: 'Output format (text, json, dot)',
+            type: 'string',
+            default: 'text',
+            choices: ['text', 'json', 'dot'],
+        },
+        {
+            name: 'min-size',
+            short: 'm',
+            description: 'Minimum community size to display',
+            type: 'number',
+            default: 2,
+        },
+    ],
+    examples: [
+        { command: 'monomind analyze modules src/', description: 'Detect module communities' },
+        { command: 'monomind analyze modules -f dot -o modules.dot src/', description: 'Export colored DOT graph' },
+        { command: 'monomind analyze modules -m 3 src/', description: 'Only show communities with 3+ files' },
+    ],
+    action: async (ctx) => {
+        const targetDir = ctx.args[0] || ctx.cwd;
+        const outputFile = ctx.flags.output;
+        const format = ctx.flags.format || 'text';
+        const minSize = ctx.flags['min-size'] || 2;
+        output.printInfo(`Detecting module communities in: ${output.highlight(targetDir)}`);
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Building dependency graph...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const analyzer = await getGraphAnalyzer();
+            if (!analyzer) {
+                spinner.stop();
+                output.printError('Graph analyzer module not available');
+                return { success: false, exitCode: 1 };
+            }
+            const result = await analyzer.analyzeGraph(resolve(targetDir), {
+                includeBoundaries: false,
+                includeModules: true,
+            });
+            spinner.stop();
+            // Filter communities by size
+            const communities = result.communities?.filter(c => c.members.length >= minSize) || [];
+            // Handle different output formats
+            if (format === 'json') {
+                const jsonOutput = {
+                    communities,
+                    statistics: result.statistics,
+                };
+                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 };
+            }
+            if (format === 'dot') {
+                const dotOutput = analyzer.exportToDot(result, {
+                    includeLabels: true,
+                    colorByCommunity: true,
+                    highlightCycles: true,
+                });
+                if (outputFile) {
+                    await safeWriteOutputFile(outputFile, dotOutput);
+                    output.printSuccess(`DOT graph written to ${outputFile}`);
+                    output.writeln(output.dim('Visualize with: dot -Tpng -o modules.png ' + outputFile));
+                }
+                else {
+                    output.writeln(dotOutput);
+                }
+                return { success: true };
+            }
+            // Text format (default)
+            output.printBox([
+                `Files analyzed: ${result.statistics.nodeCount}`,
+                `Dependencies: ${result.statistics.edgeCount}`,
+                `Communities found: ${result.communities?.length || 0}`,
+                `Showing: ${communities.length} (min size: ${minSize})`,
+            ].join('\n'), 'Module Detection Results');
+            if (communities.length > 0) {
+                output.writeln();
+                output.writeln(output.bold('Detected Communities'));
+                output.writeln();
+                for (const community of communities.slice(0, 10)) {
+                    const cohesionIndicator = community.cohesion > 0.5 ? output.success('High') :
+                        community.cohesion > 0.2 ? output.warning('Medium') : output.dim('Low');
+                    output.writeln(output.bold(`Community ${community.id}: ${community.suggestedName || 'unnamed'}`));
+                    output.writeln(`  ${output.dim('Cohesion:')} ${cohesionIndicator} (${(community.cohesion * 100).toFixed(1)}%)`);
+                    output.writeln(`  ${output.dim('Central node:')} ${community.centralNode || 'none'}`);
+                    output.writeln(`  ${output.dim('Members:')} ${community.members.length} files`);
+                    const displayMembers = community.members.slice(0, 5);
+                    for (const member of displayMembers) {
+                        output.writeln(`    - ${member}`);
+                    }
+                    if (community.members.length > 5) {
+                        output.writeln(output.dim(`    ... and ${community.members.length - 5} more`));
+                    }
+                    output.writeln();
+                }
+                if (communities.length > 10) {
+                    output.writeln(output.dim(`... and ${communities.length - 10} more communities`));
+                }
+            }
+            if (outputFile) {
+                await safeWriteOutputFile(outputFile, JSON.stringify(result, null, 2));
+                output.printSuccess(`Full results written to ${outputFile}`);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            spinner.stop();
+            const message = error instanceof Error ? error.message : String(error);
+            output.printError(`Analysis failed: ${message}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+//# sourceMappingURL=analyze-boundaries.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Analyze diff and code subcommands
+ * Handles git diff risk assessment and static code quality analysis
+ */
+import type { Command } from '../types.js';
+export declare const diffCommand: Command;
+export declare const codeCommand: Command;
+//# sourceMappingURL=analyze-diff.d.ts.map