kynjal-cli 3.1.3 → 4.0.0

package/dist/src/commands/analyze.js

@@ -13,6 +13,53 @@
  *
  * Created with ruv.io
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as path from 'path';
@@ -20,25 +67,43 @@ import * as fs from 'fs/promises';
 import { writeFile } from 'fs/promises';
 import { resolve } from 'path';
 // Dynamic import for AST analyzer
-async function getASTAnalyzer() {
-    try {
-        return await import('../ruvector/ast-analyzer.js');
-    }
-    catch {
-        return null;
-    }
+function getASTAnalyzer() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, import('../ruvector/ast-analyzer.js')];
+                case 1: return [2 /*return*/, _b.sent()];
+                case 2:
+                    _a = _b.sent();
+                    return [2 /*return*/, null];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
 }
 // Dynamic import for graph analyzer
-async function getGraphAnalyzer() {
-    try {
-        return await import('../ruvector/graph-analyzer.js');
-    }
-    catch {
-        return null;
-    }
+function getGraphAnalyzer() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, import('../ruvector/graph-analyzer.js')];
+                case 1: return [2 /*return*/, _b.sent()];
+                case 2:
+                    _a = _b.sent();
+                    return [2 /*return*/, null];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
 }
 // Diff subcommand
-const diffCommand = {
+var diffCommand = {
     name: 'diff',
     description: 'Analyze git diff for change risk assessment and classification',
     options: [
@@ -47,35 +112,35 @@ const diffCommand = {
             short: 'r',
             description: 'Show risk assessment',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'classify',
             short: 'c',
             description: 'Classify change type',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'reviewers',
             description: 'Show recommended reviewers',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'format',
             short: 'f',
             description: 'Output format: text, json, table',
             type: 'string',
-            default: 'text',
-            choices: ['text', 'json', 'table'],
+            "default": 'text',
+            choices: ['text', 'json', 'table']
         },
         {
             name: 'verbose',
             short: 'v',
             description: 'Show detailed file-level analysis',
             type: 'boolean',
-            default: false,
+            "default": false
         },
     ],
     examples: [
@@ -84,191 +149,201 @@ const diffCommand = {
         { command: 'claude-flow analyze diff main..feature --format json', description: 'Compare branches with JSON output' },
         { command: 'claude-flow analyze diff --reviewers', description: 'Get recommended reviewers for changes' },
     ],
-    action: async (ctx) => {
-        const ref = ctx.args[0] || 'HEAD';
-        const showRisk = ctx.flags.risk;
-        const showClassify = ctx.flags.classify;
-        const showReviewers = ctx.flags.reviewers;
-        const formatType = ctx.flags.format || 'text';
-        const verbose = ctx.flags.verbose;
-        // If no specific flag, show all
-        const showAll = !showRisk && !showClassify && !showReviewers;
-        output.printInfo(`Analyzing diff: ${output.highlight(ref)}`);
-        try {
-            // Call MCP tool for diff analysis
-            const result = await callMCPTool('analyze_diff', {
-                ref,
-                includeFileRisks: verbose,
-                includeReviewers: showReviewers || showAll,
-            });
-            // JSON output
-            if (formatType === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            // Summary box
-            const files = result.files || [];
-            const risk = result.risk || { overall: 'unknown', score: 0, breakdown: { fileCount: 0, totalChanges: 0, highRiskFiles: [], securityConcerns: [], breakingChanges: [], testCoverage: 'unknown' } };
-            const classification = result.classification || { category: 'unknown', confidence: 0, reasoning: '' };
-            output.printBox([
-                `Ref: ${result.ref || 'HEAD'}`,
-                `Files: ${files.length}`,
-                `Risk: ${getRiskDisplay(risk.overall)} (${risk.score}/100)`,
-                `Type: ${classification.category}${classification.subcategory ? ` (${classification.subcategory})` : ''}`,
-                ``,
-                result.summary || 'No summary available',
-            ].join('\n'), 'Diff Analysis');
-            // Risk assessment
-            if (showRisk || showAll) {
-                output.writeln();
-                output.writeln(output.bold('Risk Assessment'));
-                output.writeln(output.dim('-'.repeat(50)));
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 30 },
-                    ],
-                    data: [
-                        { metric: 'Overall Risk', value: getRiskDisplay(risk.overall) },
-                        { metric: 'Risk Score', value: `${risk.score}/100` },
-                        { metric: 'Files Changed', value: risk.breakdown.fileCount },
-                        { metric: 'Total Lines Changed', value: risk.breakdown.totalChanges },
-                        { metric: 'Test Coverage', value: risk.breakdown.testCoverage },
-                    ],
-                });
-                // Security concerns
-                if (risk.breakdown.securityConcerns.length > 0) {
-                    output.writeln();
-                    output.writeln(output.bold(output.warning('Security Concerns')));
-                    output.printList(risk.breakdown.securityConcerns.map(c => output.warning(c)));
-                }
-                // Breaking changes
-                if (risk.breakdown.breakingChanges.length > 0) {
-                    output.writeln();
-                    output.writeln(output.bold(output.error('Potential Breaking Changes')));
-                    output.printList(risk.breakdown.breakingChanges.map(c => output.error(c)));
-                }
-                // High risk files
-                if (risk.breakdown.highRiskFiles.length > 0) {
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var ref, showRisk, showClassify, showReviewers, formatType, verbose, showAll, result, files, risk, classification, reviewers, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ref = ctx.args[0] || 'HEAD';
+                    showRisk = ctx.flags.risk;
+                    showClassify = ctx.flags.classify;
+                    showReviewers = ctx.flags.reviewers;
+                    formatType = ctx.flags.format || 'text';
+                    verbose = ctx.flags.verbose;
+                    showAll = !showRisk && !showClassify && !showReviewers;
+                    output.printInfo("Analyzing diff: " + output.highlight(ref));
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, callMCPTool('analyze_diff', {
+                            ref: ref,
+                            includeFileRisks: verbose,
+                            includeReviewers: showReviewers || showAll
+                        })];
+                case 2:
+                    result = _a.sent();
+                    // JSON output
+                    if (formatType === 'json') {
+                        output.printJson(result);
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
                     output.writeln();
-                    output.writeln(output.bold('High Risk Files'));
-                    output.printList(risk.breakdown.highRiskFiles.map(f => output.warning(f)));
-                }
-            }
-            // Classification
-            if (showClassify || showAll) {
-                output.writeln();
-                output.writeln(output.bold('Classification'));
-                output.writeln(output.dim('-'.repeat(50)));
-                output.printTable({
-                    columns: [
-                        { key: 'field', header: 'Field', width: 15 },
-                        { key: 'value', header: 'Value', width: 40 },
-                    ],
-                    data: [
-                        { field: 'Category', value: classification.category },
-                        { field: 'Subcategory', value: classification.subcategory || '-' },
-                        { field: 'Confidence', value: `${(classification.confidence * 100).toFixed(0)}%` },
-                    ],
-                });
-                output.writeln();
-                output.writeln(output.dim(`Reasoning: ${classification.reasoning}`));
-            }
-            // Reviewers
-            if (showReviewers || showAll) {
-                output.writeln();
-                output.writeln(output.bold('Recommended Reviewers'));
-                output.writeln(output.dim('-'.repeat(50)));
-                const reviewers = result.recommendedReviewers || [];
-                if (reviewers.length > 0) {
-                    output.printNumberedList(reviewers.map(r => output.highlight(r)));
-                }
-                else {
-                    output.writeln(output.dim('No specific reviewers recommended'));
-                }
-            }
-            // Verbose file-level details
-            if (verbose && result.fileRisks) {
-                output.writeln();
-                output.writeln(output.bold('File-Level Analysis'));
-                output.writeln(output.dim('-'.repeat(50)));
-                output.printTable({
-                    columns: [
-                        { key: 'path', header: 'File', width: 40 },
-                        { key: 'risk', header: 'Risk', width: 12, format: (v) => getRiskDisplay(String(v)) },
-                        { key: 'score', header: 'Score', width: 8, align: 'right' },
-                        { key: 'reasons', header: 'Reasons', width: 30, format: (v) => {
-                                const reasons = v;
-                                return reasons.slice(0, 2).join('; ');
-                            } },
-                    ],
-                    data: result.fileRisks,
-                });
-            }
-            // Files changed table
-            if (formatType === 'table' || showAll) {
-                output.writeln();
-                output.writeln(output.bold('Files Changed'));
-                output.writeln(output.dim('-'.repeat(50)));
-                output.printTable({
-                    columns: [
-                        { key: 'status', header: 'Status', width: 10, format: (v) => getStatusDisplay(String(v)) },
-                        { key: 'path', header: 'File', width: 45 },
-                        { key: 'additions', header: '+', width: 8, align: 'right', format: (v) => output.success(`+${v}`) },
-                        { key: 'deletions', header: '-', width: 8, align: 'right', format: (v) => output.error(`-${v}`) },
-                    ],
-                    data: files.slice(0, 20),
-                });
-                if (files.length > 20) {
-                    output.writeln(output.dim(`  ... and ${files.length - 20} more files`));
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Diff analysis failed: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+                    files = result.files || [];
+                    risk = result.risk || { overall: 'unknown', score: 0, breakdown: { fileCount: 0, totalChanges: 0, highRiskFiles: [], securityConcerns: [], breakingChanges: [], testCoverage: 'unknown' } };
+                    classification = result.classification || { category: 'unknown', confidence: 0, reasoning: '' };
+                    output.printBox([
+                        "Ref: " + (result.ref || 'HEAD'),
+                        "Files: " + files.length,
+                        "Risk: " + getRiskDisplay(risk.overall) + " (" + risk.score + "/100)",
+                        "Type: " + classification.category + (classification.subcategory ? " (" + classification.subcategory + ")" : ''),
+                        "",
+                        result.summary || 'No summary available',
+                    ].join('\n'), 'Diff Analysis');
+                    // Risk assessment
+                    if (showRisk || showAll) {
+                        output.writeln();
+                        output.writeln(output.bold('Risk Assessment'));
+                        output.writeln(output.dim('-'.repeat(50)));
+                        output.printTable({
+                            columns: [
+                                { key: 'metric', header: 'Metric', width: 25 },
+                                { key: 'value', header: 'Value', width: 30 },
+                            ],
+                            data: [
+                                { metric: 'Overall Risk', value: getRiskDisplay(risk.overall) },
+                                { metric: 'Risk Score', value: risk.score + "/100" },
+                                { metric: 'Files Changed', value: risk.breakdown.fileCount },
+                                { metric: 'Total Lines Changed', value: risk.breakdown.totalChanges },
+                                { metric: 'Test Coverage', value: risk.breakdown.testCoverage },
+                            ]
+                        });
+                        // Security concerns
+                        if (risk.breakdown.securityConcerns.length > 0) {
+                            output.writeln();
+                            output.writeln(output.bold(output.warning('Security Concerns')));
+                            output.printList(risk.breakdown.securityConcerns.map(function (c) { return output.warning(c); }));
+                        }
+                        // Breaking changes
+                        if (risk.breakdown.breakingChanges.length > 0) {
+                            output.writeln();
+                            output.writeln(output.bold(output.error('Potential Breaking Changes')));
+                            output.printList(risk.breakdown.breakingChanges.map(function (c) { return output.error(c); }));
+                        }
+                        // High risk files
+                        if (risk.breakdown.highRiskFiles.length > 0) {
+                            output.writeln();
+                            output.writeln(output.bold('High Risk Files'));
+                            output.printList(risk.breakdown.highRiskFiles.map(function (f) { return output.warning(f); }));
+                        }
+                    }
+                    // Classification
+                    if (showClassify || showAll) {
+                        output.writeln();
+                        output.writeln(output.bold('Classification'));
+                        output.writeln(output.dim('-'.repeat(50)));
+                        output.printTable({
+                            columns: [
+                                { key: 'field', header: 'Field', width: 15 },
+                                { key: 'value', header: 'Value', width: 40 },
+                            ],
+                            data: [
+                                { field: 'Category', value: classification.category },
+                                { field: 'Subcategory', value: classification.subcategory || '-' },
+                                { field: 'Confidence', value: (classification.confidence * 100).toFixed(0) + "%" },
+                            ]
+                        });
+                        output.writeln();
+                        output.writeln(output.dim("Reasoning: " + classification.reasoning));
+                    }
+                    // Reviewers
+                    if (showReviewers || showAll) {
+                        output.writeln();
+                        output.writeln(output.bold('Recommended Reviewers'));
+                        output.writeln(output.dim('-'.repeat(50)));
+                        reviewers = result.recommendedReviewers || [];
+                        if (reviewers.length > 0) {
+                            output.printNumberedList(reviewers.map(function (r) { return output.highlight(r); }));
+                        }
+                        else {
+                            output.writeln(output.dim('No specific reviewers recommended'));
+                        }
+                    }
+                    // Verbose file-level details
+                    if (verbose && result.fileRisks) {
+                        output.writeln();
+                        output.writeln(output.bold('File-Level Analysis'));
+                        output.writeln(output.dim('-'.repeat(50)));
+                        output.printTable({
+                            columns: [
+                                { key: 'path', header: 'File', width: 40 },
+                                { key: 'risk', header: 'Risk', width: 12, format: function (v) { return getRiskDisplay(String(v)); } },
+                                { key: 'score', header: 'Score', width: 8, align: 'right' },
+                                { key: 'reasons', header: 'Reasons', width: 30, format: function (v) {
+                                        var reasons = v;
+                                        return reasons.slice(0, 2).join('; ');
+                                    } },
+                            ],
+                            data: result.fileRisks
+                        });
+                    }
+                    // Files changed table
+                    if (formatType === 'table' || showAll) {
+                        output.writeln();
+                        output.writeln(output.bold('Files Changed'));
+                        output.writeln(output.dim('-'.repeat(50)));
+                        output.printTable({
+                            columns: [
+                                { key: 'status', header: 'Status', width: 10, format: function (v) { return getStatusDisplay(String(v)); } },
+                                { key: 'path', header: 'File', width: 45 },
+                                { key: 'additions', header: '+', width: 8, align: 'right', format: function (v) { return output.success("+" + v); } },
+                                { key: 'deletions', header: '-', width: 8, align: 'right', format: function (v) { return output.error("-" + v); } },
+                            ],
+                            data: files.slice(0, 20)
+                        });
+                        if (files.length > 20) {
+                            output.writeln(output.dim("  ... and " + (files.length - 20) + " more files"));
+                        }
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 3:
+                    error_1 = _a.sent();
+                    if (error_1 instanceof MCPClientError) {
+                        output.printError("Diff analysis failed: " + error_1.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_1));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 // Code subcommand (placeholder for future code analysis)
-const codeCommand = {
+var codeCommand = {
     name: 'code',
     description: 'Static code analysis and quality assessment',
     options: [
-        { name: 'path', short: 'p', type: 'string', description: 'Path to analyze', default: '.' },
-        { name: 'type', short: 't', type: 'string', description: 'Analysis type: quality, complexity, security', default: 'quality' },
-        { name: 'format', short: 'f', type: 'string', description: 'Output format: text, json', default: 'text' },
+        { name: 'path', short: 'p', type: 'string', description: 'Path to analyze', "default": '.' },
+        { name: 'type', short: 't', type: 'string', description: 'Analysis type: quality, complexity, security', "default": 'quality' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: text, json', "default": 'text' },
     ],
     examples: [
         { command: 'claude-flow analyze code -p ./src', description: 'Analyze source directory' },
         { command: 'claude-flow analyze code --type complexity', description: 'Run complexity analysis' },
     ],
-    action: async (ctx) => {
-        const path = ctx.flags.path || '.';
-        const analysisType = ctx.flags.type || 'quality';
-        output.writeln();
-        output.writeln(output.bold('Code Analysis'));
-        output.writeln(output.dim('-'.repeat(50)));
-        output.printInfo(`Analyzing ${path} for ${analysisType}...`);
-        output.writeln();
-        // Placeholder - would integrate with actual code analysis tools
-        output.printBox([
-            `Path: ${path}`,
-            `Type: ${analysisType}`,
-            `Status: Feature in development`,
-            ``,
-            `Code analysis capabilities coming soon.`,
-            `Use 'analyze diff' for change analysis.`,
-        ].join('\n'), 'Code Analysis');
-        return { success: true };
-    },
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var path, analysisType;
+        return __generator(this, function (_a) {
+            path = ctx.flags.path || '.';
+            analysisType = ctx.flags.type || 'quality';
+            output.writeln();
+            output.writeln(output.bold('Code Analysis'));
+            output.writeln(output.dim('-'.repeat(50)));
+            output.printInfo("Analyzing " + path + " for " + analysisType + "...");
+            output.writeln();
+            // Placeholder - would integrate with actual code analysis tools
+            output.printBox([
+                "Path: " + path,
+                "Type: " + analysisType,
+                "Status: Feature in development",
+                "",
+                "Code analysis capabilities coming soon.",
+                "Use 'analyze diff' for change analysis.",
+            ].join('\n'), 'Code Analysis');
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 // ============================================================================
 // AST Analysis Subcommands (using ruvector tree-sitter with fallback)
@@ -276,7 +351,8 @@ const codeCommand = {
 /**
  * Helper: Truncate file path for display
  */
-function truncatePathAst(filePath, maxLen = 45) {
+function truncatePathAst(filePath, maxLen) {
+    if (maxLen === void 0) { maxLen = 45; }
     if (filePath.length <= maxLen)
         return filePath;
     return '...' + filePath.slice(-(maxLen - 3));
@@ -319,7 +395,7 @@ function getComplexityRatingAst(value) {
 /**
  * AST analysis subcommand
  */
-const astCommand = {
+var astCommand = {
     name: 'ast',
     description: 'Analyze code using AST parsing (tree-sitter via ruvector)',
     options: [
@@ -328,35 +404,35 @@ const astCommand = {
             short: 'c',
             description: 'Include complexity metrics',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'symbols',
             short: 's',
             description: 'Include symbol extraction',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'format',
             short: 'f',
             description: 'Output format (text, json, table)',
             type: 'string',
-            default: 'text',
-            choices: ['text', 'json', 'table'],
+            "default": 'text',
+            choices: ['text', 'json', 'table']
         },
         {
             name: 'output',
             short: 'o',
             description: 'Output file path',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'verbose',
             short: 'v',
             description: 'Show detailed analysis',
             type: 'boolean',
-            default: false,
+            "default": false
         },
     ],
     examples: [
@@ -365,193 +441,223 @@ const astCommand = {
         { command: 'claude-flow analyze ast . --format json', description: 'JSON output' },
         { command: 'claude-flow 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));
-                        }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var targetPath, showComplexity, showSymbols, formatType, outputFile, verbose, showAll, spinner, astModule, resolvedPath, stat, isDirectory, results, files, _i, _a, file, content, analyzer, analysis, _b, content, analyzer, analysis, totals, jsonOutput, complexityData, allSymbols, _c, results_1, r, _d, _e, fn, _f, _g, cls, displaySymbols, importCounts, _h, results_2, r, _j, _k, imp, topImports, _l, topImports_1, _m, imp, count, error_2, message;
+        return __generator(this, function (_o) {
+            switch (_o.label) {
+                case 0:
+                    targetPath = ctx.args[0] || ctx.cwd;
+                    showComplexity = ctx.flags.complexity;
+                    showSymbols = ctx.flags.symbols;
+                    formatType = ctx.flags.format || 'text';
+                    outputFile = ctx.flags.output;
+                    verbose = ctx.flags.verbose;
+                    showAll = !showComplexity && !showSymbols;
+                    output.printInfo("Analyzing: " + output.highlight(targetPath));
+                    output.writeln();
+                    spinner = output.createSpinner({ text: 'Parsing AST...', spinner: 'dots' });
+                    spinner.start();
+                    _o.label = 1;
+                case 1:
+                    _o.trys.push([1, 20, , 21]);
+                    return [4 /*yield*/, getASTAnalyzer()];
+                case 2:
+                    astModule = _o.sent();
+                    if (!astModule) {
+                        spinner.stop();
+                        output.printWarning('AST analyzer not available, using regex fallback');
                     }
-                    catch {
-                        // Skip files that can't be analyzed
+                    resolvedPath = resolve(targetPath);
+                    return [4 /*yield*/, fs.stat(resolvedPath)];
+                case 3:
+                    stat = _o.sent();
+                    isDirectory = stat.isDirectory();
+                    results = [];
+                    if (!isDirectory) return [3 /*break*/, 11];
+                    return [4 /*yield*/, scanSourceFiles(resolvedPath)];
+                case 4:
+                    files = _o.sent();
+                    spinner.stop();
+                    output.printInfo("Found " + files.length + " source files");
+                    spinner.start();
+                    _i = 0, _a = files.slice(0, 100);
+                    _o.label = 5;
+                case 5:
+                    if (!(_i < _a.length)) return [3 /*break*/, 10];
+                    file = _a[_i];
+                    _o.label = 6;
+                case 6:
+                    _o.trys.push([6, 8, , 9]);
+                    return [4 /*yield*/, fs.readFile(file, 'utf-8')];
+                case 7:
+                    content = _o.sent();
+                    if (astModule) {
+                        analyzer = astModule.createASTAnalyzer();
+                        analysis = analyzer.analyze(content, file);
+                        results.push(analysis);
                     }
-                }
-            }
-            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 writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
-                    output.printSuccess(`Results written to ${outputFile}`);
-                }
-                else {
+                    else {
+                        // Fallback analysis
+                        results.push(fallbackAnalyze(content, file));
+                    }
+                    return [3 /*break*/, 9];
+                case 8:
+                    _b = _o.sent();
+                    return [3 /*break*/, 9];
+                case 9:
+                    _i++;
+                    return [3 /*break*/, 5];
+                case 10: return [3 /*break*/, 13];
+                case 11: return [4 /*yield*/, fs.readFile(resolvedPath, 'utf-8')];
+                case 12:
+                    content = _o.sent();
+                    if (astModule) {
+                        analyzer = astModule.createASTAnalyzer();
+                        analysis = analyzer.analyze(content, resolvedPath);
+                        results.push(analysis);
+                    }
+                    else {
+                        results.push(fallbackAnalyze(content, resolvedPath));
+                    }
+                    _o.label = 13;
+                case 13:
+                    spinner.stop();
+                    if (results.length === 0) {
+                        output.printWarning('No files analyzed');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    totals = {
+                        files: results.length,
+                        functions: results.reduce(function (sum, r) { return sum + r.functions.length; }, 0),
+                        classes: results.reduce(function (sum, r) { return sum + r.classes.length; }, 0),
+                        imports: results.reduce(function (sum, r) { return sum + r.imports.length; }, 0),
+                        avgComplexity: results.reduce(function (sum, r) { return sum + r.complexity.cyclomatic; }, 0) / results.length,
+                        totalLoc: results.reduce(function (sum, r) { return sum + r.complexity.loc; }, 0)
+                    };
+                    if (!(formatType === 'json')) return [3 /*break*/, 17];
+                    jsonOutput = { files: results, totals: totals };
+                    if (!outputFile) return [3 /*break*/, 15];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(jsonOutput, null, 2))];
+                case 14:
+                    _o.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    return [3 /*break*/, 16];
+                case 15:
                     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 });
+                    _o.label = 16;
+                case 16: return [2 /*return*/, { success: true, data: jsonOutput }];
+                case 17:
+                    // 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)));
+                        complexityData = results
+                            .map(function (r) { return ({
+                            file: truncatePathAst(r.filePath),
+                            cyclomatic: r.complexity.cyclomatic,
+                            cognitive: r.complexity.cognitive,
+                            loc: r.complexity.loc,
+                            rating: getComplexityRatingAst(r.complexity.cyclomatic)
+                        }); })
+                            .sort(function (a, b) { return 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: function (v) { return 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"));
+                        }
                     }
-                    for (const cls of r.classes) {
-                        allSymbols.push({ name: cls.name, type: 'class', file: truncatePathAst(r.filePath, 30), line: cls.startLine });
+                    // Symbols view
+                    if (showSymbols || showAll) {
+                        output.writeln();
+                        output.writeln(output.bold('Extracted Symbols'));
+                        output.writeln(output.dim('-'.repeat(60)));
+                        allSymbols = [];
+                        for (_c = 0, results_1 = results; _c < results_1.length; _c++) {
+                            r = results_1[_c];
+                            for (_d = 0, _e = r.functions; _d < _e.length; _d++) {
+                                fn = _e[_d];
+                                allSymbols.push({ name: fn.name, type: 'function', file: truncatePathAst(r.filePath, 30), line: fn.startLine });
+                            }
+                            for (_f = 0, _g = r.classes; _f < _g.length; _f++) {
+                                cls = _g[_f];
+                                allSymbols.push({ name: cls.name, type: 'class', file: truncatePathAst(r.filePath, 30), line: cls.startLine });
+                            }
+                        }
+                        displaySymbols = allSymbols.slice(0, 20);
+                        output.printTable({
+                            columns: [
+                                { key: 'type', header: 'Type', width: 8, format: function (v) { return 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"));
+                        }
                     }
-                }
-                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);
+                    // Verbose output
+                    if (verbose) {
+                        output.writeln();
+                        output.writeln(output.bold('Import Analysis'));
+                        output.writeln(output.dim('-'.repeat(60)));
+                        importCounts = new Map();
+                        for (_h = 0, results_2 = results; _h < results_2.length; _h++) {
+                            r = results_2[_h];
+                            for (_j = 0, _k = r.imports; _j < _k.length; _j++) {
+                                imp = _k[_j];
+                                importCounts.set(imp, (importCounts.get(imp) || 0) + 1);
+                            }
+                        }
+                        topImports = Array.from(importCounts.entries())
+                            .sort(function (a, b) { return b[1] - a[1]; })
+                            .slice(0, 10);
+                        for (_l = 0, topImports_1 = topImports; _l < topImports_1.length; _l++) {
+                            _m = topImports_1[_l], imp = _m[0], count = _m[1];
+                            output.writeln("  " + output.highlight(count.toString().padStart(3)) + " " + imp);
+                        }
                     }
-                }
-                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 writeFile(outputFile, JSON.stringify({ files: results, totals }, null, 2));
-                output.printSuccess(`Results written to ${outputFile}`);
+                    if (!outputFile) return [3 /*break*/, 19];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify({ files: results, totals: totals }, null, 2))];
+                case 18:
+                    _o.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    _o.label = 19;
+                case 19: return [2 /*return*/, { success: true, data: { files: results, totals: totals } }];
+                case 20:
+                    error_2 = _o.sent();
+                    spinner.stop();
+                    message = error_2 instanceof Error ? error_2.message : String(error_2);
+                    output.printError("AST analysis failed: " + message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 21: return [2 /*return*/];
             }
-            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 };
-        }
-    },
+        });
+    }); }
 };
 /**
  * Complexity analysis subcommand
  */
-const complexityAstCommand = {
+var complexityAstCommand = {
     name: 'complexity',
     aliases: ['cx'],
     description: 'Analyze code complexity metrics',
@@ -561,55 +667,82 @@ const complexityAstCommand = {
             short: 't',
             description: 'Complexity threshold to flag (default: 10)',
             type: 'number',
-            default: 10,
+            "default": 10
         },
         {
             name: 'format',
             short: 'f',
             description: 'Output format (text, json)',
             type: 'string',
-            default: 'text',
-            choices: ['text', 'json'],
+            "default": 'text',
+            choices: ['text', 'json']
         },
         {
             name: 'output',
             short: 'o',
             description: 'Output file path',
-            type: 'string',
+            type: 'string'
         },
     ],
     examples: [
         { command: 'claude-flow analyze complexity src/', description: 'Analyze complexity' },
         { command: 'claude-flow 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;
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var targetPath, threshold, formatType, outputFile, spinner, astModule, resolvedPath, stat, files, _a, results, _i, _b, file, content, analysis, analyzer, flagged, rating, _c, flaggedCount, avgComplexity, jsonOutput, flaggedFiles, displayFiles, error_3, message;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    targetPath = ctx.args[0] || ctx.cwd;
+                    threshold = ctx.flags.threshold || 10;
+                    formatType = ctx.flags.format || 'text';
+                    outputFile = ctx.flags.output;
+                    output.printInfo("Analyzing complexity: " + output.highlight(targetPath));
+                    output.writeln();
+                    spinner = output.createSpinner({ text: 'Calculating complexity...', spinner: 'dots' });
+                    spinner.start();
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 19, , 20]);
+                    return [4 /*yield*/, getASTAnalyzer()];
+                case 2:
+                    astModule = _d.sent();
+                    resolvedPath = resolve(targetPath);
+                    return [4 /*yield*/, fs.stat(resolvedPath)];
+                case 3:
+                    stat = _d.sent();
+                    if (!stat.isDirectory()) return [3 /*break*/, 5];
+                    return [4 /*yield*/, scanSourceFiles(resolvedPath)];
+                case 4:
+                    _a = _d.sent();
+                    return [3 /*break*/, 6];
+                case 5:
+                    _a = [resolvedPath];
+                    _d.label = 6;
+                case 6:
+                    files = _a;
+                    results = [];
+                    _i = 0, _b = files.slice(0, 100);
+                    _d.label = 7;
+                case 7:
+                    if (!(_i < _b.length)) return [3 /*break*/, 12];
+                    file = _b[_i];
+                    _d.label = 8;
+                case 8:
+                    _d.trys.push([8, 10, , 11]);
+                    return [4 /*yield*/, fs.readFile(file, 'utf-8')];
+                case 9:
+                    content = _d.sent();
+                    analysis = void 0;
                     if (astModule) {
-                        const analyzer = astModule.createASTAnalyzer();
+                        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' :
+                    flagged = analysis.complexity.cyclomatic > threshold;
+                    rating = analysis.complexity.cyclomatic <= 5 ? 'Simple' :
                         analysis.complexity.cyclomatic <= 10 ? 'Moderate' :
                             analysis.complexity.cyclomatic <= 20 ? 'Complex' : 'Very Complex';
                     results.push({
@@ -618,91 +751,100 @@ const complexityAstCommand = {
                         cognitive: analysis.complexity.cognitive,
                         loc: analysis.complexity.loc,
                         commentDensity: analysis.complexity.commentDensity,
-                        rating,
-                        flagged,
+                        rating: rating,
+                        flagged: 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 writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
-                    output.printSuccess(`Results written to ${outputFile}`);
-                }
-                else {
+                    return [3 /*break*/, 11];
+                case 10:
+                    _c = _d.sent();
+                    return [3 /*break*/, 11];
+                case 11:
+                    _i++;
+                    return [3 /*break*/, 7];
+                case 12:
+                    spinner.stop();
+                    // Sort by complexity descending
+                    results.sort(function (a, b) { return b.cyclomatic - a.cyclomatic; });
+                    flaggedCount = results.filter(function (r) { return r.flagged; }).length;
+                    avgComplexity = results.length > 0
+                        ? results.reduce(function (sum, r) { return sum + r.cyclomatic; }, 0) / results.length
+                        : 0;
+                    if (!(formatType === 'json')) return [3 /*break*/, 16];
+                    jsonOutput = { files: results, summary: { total: results.length, flagged: flaggedCount, avgComplexity: avgComplexity, threshold: threshold } };
+                    if (!outputFile) return [3 /*break*/, 14];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(jsonOutput, null, 2))];
+                case 13:
+                    _d.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    return [3 /*break*/, 15];
+                case 14:
                     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 writeFile(outputFile, JSON.stringify({ files: results, summary: { total: results.length, flagged: flaggedCount, avgComplexity, threshold } }, null, 2));
-                output.printSuccess(`Results written to ${outputFile}`);
+                    _d.label = 15;
+                case 15: return [2 /*return*/, { success: true, data: jsonOutput }];
+                case 16:
+                    // 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)));
+                        flaggedFiles = results.filter(function (r) { return r.flagged; }).slice(0, 10);
+                        output.printTable({
+                            columns: [
+                                { key: 'file', header: 'File', width: 40, format: function (v) { return truncatePathAst(v); } },
+                                { key: 'cyclomatic', header: 'Cyclo', width: 8, align: 'right', format: function (v) { return 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)));
+                    displayFiles = results.slice(0, 15);
+                    output.printTable({
+                        columns: [
+                            { key: 'file', header: 'File', width: 40, format: function (v) { return truncatePathAst(v); } },
+                            { key: 'cyclomatic', header: 'Cyclo', width: 8, align: 'right', format: function (v) { return 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) return [3 /*break*/, 18];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify({ files: results, summary: { total: results.length, flagged: flaggedCount, avgComplexity: avgComplexity, threshold: threshold } }, null, 2))];
+                case 17:
+                    _d.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    _d.label = 18;
+                case 18: return [2 /*return*/, { success: true, data: { files: results, flaggedCount: flaggedCount } }];
+                case 19:
+                    error_3 = _d.sent();
+                    spinner.stop();
+                    message = error_3 instanceof Error ? error_3.message : String(error_3);
+                    output.printError("Complexity analysis failed: " + message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 20: return [2 /*return*/];
             }
-            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
  */
-const symbolsCommand = {
+var symbolsCommand = {
     name: 'symbols',
     aliases: ['sym'],
     description: 'Extract and list code symbols (functions, classes, types)',
@@ -712,22 +854,22 @@ const symbolsCommand = {
             short: 't',
             description: 'Filter by symbol type (function, class, all)',
             type: 'string',
-            default: 'all',
-            choices: ['function', 'class', 'all'],
+            "default": 'all',
+            choices: ['function', 'class', 'all']
         },
         {
             name: 'format',
             short: 'f',
             description: 'Output format (text, json)',
             type: 'string',
-            default: 'text',
-            choices: ['text', 'json'],
+            "default": 'text',
+            choices: ['text', 'json']
         },
         {
             name: 'output',
             short: 'o',
             description: 'Output file path',
-            type: 'string',
+            type: 'string'
         },
     ],
     examples: [
@@ -735,115 +877,152 @@ const symbolsCommand = {
         { command: 'claude-flow analyze symbols src/ --type function', description: 'Only functions' },
         { command: 'claude-flow 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;
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var targetPath, symbolType, formatType, outputFile, spinner, astModule, resolvedPath, stat, files, _a, symbols, _i, _b, file, content, analysis, analyzer, _c, _d, fn, _e, _f, cls, _g, functionCount, classCount, displaySymbols, error_4, message;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    targetPath = ctx.args[0] || ctx.cwd;
+                    symbolType = ctx.flags.type || 'all';
+                    formatType = ctx.flags.format || 'text';
+                    outputFile = ctx.flags.output;
+                    output.printInfo("Extracting symbols: " + output.highlight(targetPath));
+                    output.writeln();
+                    spinner = output.createSpinner({ text: 'Parsing code...', spinner: 'dots' });
+                    spinner.start();
+                    _h.label = 1;
+                case 1:
+                    _h.trys.push([1, 19, , 20]);
+                    return [4 /*yield*/, getASTAnalyzer()];
+                case 2:
+                    astModule = _h.sent();
+                    resolvedPath = resolve(targetPath);
+                    return [4 /*yield*/, fs.stat(resolvedPath)];
+                case 3:
+                    stat = _h.sent();
+                    if (!stat.isDirectory()) return [3 /*break*/, 5];
+                    return [4 /*yield*/, scanSourceFiles(resolvedPath)];
+                case 4:
+                    _a = _h.sent();
+                    return [3 /*break*/, 6];
+                case 5:
+                    _a = [resolvedPath];
+                    _h.label = 6;
+                case 6:
+                    files = _a;
+                    symbols = [];
+                    _i = 0, _b = files.slice(0, 100);
+                    _h.label = 7;
+                case 7:
+                    if (!(_i < _b.length)) return [3 /*break*/, 12];
+                    file = _b[_i];
+                    _h.label = 8;
+                case 8:
+                    _h.trys.push([8, 10, , 11]);
+                    return [4 /*yield*/, fs.readFile(file, 'utf-8')];
+                case 9:
+                    content = _h.sent();
+                    analysis = void 0;
                     if (astModule) {
-                        const analyzer = astModule.createASTAnalyzer();
+                        analyzer = astModule.createASTAnalyzer();
                         analysis = analyzer.analyze(content, file);
                     }
                     else {
                         analysis = fallbackAnalyze(content, file);
                     }
                     if (symbolType === 'all' || symbolType === 'function') {
-                        for (const fn of analysis.functions) {
+                        for (_c = 0, _d = analysis.functions; _c < _d.length; _c++) {
+                            fn = _d[_c];
                             symbols.push({
                                 name: fn.name,
                                 type: 'function',
-                                file,
+                                file: file,
                                 startLine: fn.startLine,
-                                endLine: fn.endLine,
+                                endLine: fn.endLine
                             });
                         }
                     }
                     if (symbolType === 'all' || symbolType === 'class') {
-                        for (const cls of analysis.classes) {
+                        for (_e = 0, _f = analysis.classes; _e < _f.length; _e++) {
+                            cls = _f[_e];
                             symbols.push({
                                 name: cls.name,
                                 type: 'class',
-                                file,
+                                file: file,
                                 startLine: cls.startLine,
-                                endLine: cls.endLine,
+                                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 writeFile(outputFile, JSON.stringify(symbols, null, 2));
-                    output.printSuccess(`Results written to ${outputFile}`);
-                }
-                else {
+                    return [3 /*break*/, 11];
+                case 10:
+                    _g = _h.sent();
+                    return [3 /*break*/, 11];
+                case 11:
+                    _i++;
+                    return [3 /*break*/, 7];
+                case 12:
+                    spinner.stop();
+                    // Sort by file then name
+                    symbols.sort(function (a, b) { return a.file.localeCompare(b.file) || a.name.localeCompare(b.name); });
+                    if (!(formatType === 'json')) return [3 /*break*/, 16];
+                    if (!outputFile) return [3 /*break*/, 14];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(symbols, null, 2))];
+                case 13:
+                    _h.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    return [3 /*break*/, 15];
+                case 14:
                     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 writeFile(outputFile, JSON.stringify(symbols, null, 2));
-                output.printSuccess(`Results written to ${outputFile}`);
+                    _h.label = 15;
+                case 15: return [2 /*return*/, { success: true, data: symbols }];
+                case 16:
+                    functionCount = symbols.filter(function (s) { return s.type === 'function'; }).length;
+                    classCount = symbols.filter(function (s) { return 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)));
+                    displaySymbols = symbols.slice(0, 30);
+                    output.printTable({
+                        columns: [
+                            { key: 'type', header: 'Type', width: 10, format: function (v) { return getTypeMarkerAst(v); } },
+                            { key: 'name', header: 'Name', width: 30 },
+                            { key: 'file', header: 'File', width: 35, format: function (v) { return 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) return [3 /*break*/, 18];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(symbols, null, 2))];
+                case 17:
+                    _h.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    _h.label = 18;
+                case 18: return [2 /*return*/, { success: true, data: symbols }];
+                case 19:
+                    error_4 = _h.sent();
+                    spinner.stop();
+                    message = error_4 instanceof Error ? error_4.message : String(error_4);
+                    output.printError("Symbol extraction failed: " + message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 20: return [2 /*return*/];
             }
-            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 };
-        }
-    },
+        });
+    }); }
 };
 /**
  * Imports analysis subcommand
  */
-const importsCommand = {
+var importsCommand = {
     name: 'imports',
     aliases: ['imp'],
     description: 'Analyze import dependencies across files',
@@ -853,275 +1032,357 @@ const importsCommand = {
             short: 'f',
             description: 'Output format (text, json)',
             type: 'string',
-            default: 'text',
-            choices: ['text', 'json'],
+            "default": 'text',
+            choices: ['text', 'json']
         },
         {
             name: 'output',
             short: 'o',
             description: 'Output file path',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'external',
             short: 'e',
             description: 'Show only external (npm) imports',
             type: 'boolean',
-            default: false,
+            "default": false
         },
     ],
     examples: [
         { command: 'claude-flow analyze imports src/', description: 'Analyze all imports' },
         { command: 'claude-flow analyze imports src/ --external', description: 'Only npm packages' },
     ],
-    action: async (ctx) => {
-        const targetPath = ctx.args[0] || ctx.cwd;
-        const formatType = ctx.flags.format || 'text';
-        const outputFile = ctx.flags.output;
-        const externalOnly = ctx.flags.external;
-        output.printInfo(`Analyzing imports: ${output.highlight(targetPath)}`);
-        output.writeln();
-        const spinner = output.createSpinner({ text: 'Scanning imports...', 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 importCounts = new Map();
-            const fileImports = new Map();
-            for (const file of files.slice(0, 100)) {
-                try {
-                    const content = await fs.readFile(file, 'utf-8');
-                    let analysis;
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var targetPath, formatType, outputFile, externalOnly, spinner, astModule, resolvedPath, stat, files, _a, importCounts, fileImports, _i, _b, file, content, analysis, analyzer, imports, _c, imports_1, imp, existing, _d, sortedImports, jsonOutput, externalImports, localImports, topImports, error_5, message;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    targetPath = ctx.args[0] || ctx.cwd;
+                    formatType = ctx.flags.format || 'text';
+                    outputFile = ctx.flags.output;
+                    externalOnly = ctx.flags.external;
+                    output.printInfo("Analyzing imports: " + output.highlight(targetPath));
+                    output.writeln();
+                    spinner = output.createSpinner({ text: 'Scanning imports...', spinner: 'dots' });
+                    spinner.start();
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 19, , 20]);
+                    return [4 /*yield*/, getASTAnalyzer()];
+                case 2:
+                    astModule = _e.sent();
+                    resolvedPath = resolve(targetPath);
+                    return [4 /*yield*/, fs.stat(resolvedPath)];
+                case 3:
+                    stat = _e.sent();
+                    if (!stat.isDirectory()) return [3 /*break*/, 5];
+                    return [4 /*yield*/, scanSourceFiles(resolvedPath)];
+                case 4:
+                    _a = _e.sent();
+                    return [3 /*break*/, 6];
+                case 5:
+                    _a = [resolvedPath];
+                    _e.label = 6;
+                case 6:
+                    files = _a;
+                    importCounts = new Map();
+                    fileImports = new Map();
+                    _i = 0, _b = files.slice(0, 100);
+                    _e.label = 7;
+                case 7:
+                    if (!(_i < _b.length)) return [3 /*break*/, 12];
+                    file = _b[_i];
+                    _e.label = 8;
+                case 8:
+                    _e.trys.push([8, 10, , 11]);
+                    return [4 /*yield*/, fs.readFile(file, 'utf-8')];
+                case 9:
+                    content = _e.sent();
+                    analysis = void 0;
                     if (astModule) {
-                        const analyzer = astModule.createASTAnalyzer();
+                        analyzer = astModule.createASTAnalyzer();
                         analysis = analyzer.analyze(content, file);
                     }
                     else {
                         analysis = fallbackAnalyze(content, file);
                     }
-                    const imports = analysis.imports.filter(imp => {
+                    imports = analysis.imports.filter(function (imp) {
                         if (externalOnly) {
                             return !imp.startsWith('.') && !imp.startsWith('/');
                         }
                         return true;
                     });
                     fileImports.set(file, imports);
-                    for (const imp of imports) {
-                        const existing = importCounts.get(imp) || { count: 0, files: [] };
+                    for (_c = 0, imports_1 = imports; _c < imports_1.length; _c++) {
+                        imp = imports_1[_c];
+                        existing = importCounts.get(imp) || { count: 0, files: [] };
                         existing.count++;
                         existing.files.push(file);
                         importCounts.set(imp, existing);
                     }
-                }
-                catch {
-                    // Skip files that can't be parsed
-                }
-            }
-            spinner.stop();
-            // Sort by count
-            const sortedImports = Array.from(importCounts.entries())
-                .sort((a, b) => b[1].count - a[1].count);
-            if (formatType === 'json') {
-                const jsonOutput = {
-                    imports: Object.fromEntries(sortedImports),
-                    fileImports: Object.fromEntries(fileImports),
-                };
-                if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
-                    output.printSuccess(`Results written to ${outputFile}`);
-                }
-                else {
+                    return [3 /*break*/, 11];
+                case 10:
+                    _d = _e.sent();
+                    return [3 /*break*/, 11];
+                case 11:
+                    _i++;
+                    return [3 /*break*/, 7];
+                case 12:
+                    spinner.stop();
+                    sortedImports = Array.from(importCounts.entries())
+                        .sort(function (a, b) { return b[1].count - a[1].count; });
+                    if (!(formatType === 'json')) return [3 /*break*/, 16];
+                    jsonOutput = {
+                        imports: Object.fromEntries(sortedImports),
+                        fileImports: Object.fromEntries(fileImports)
+                    };
+                    if (!outputFile) return [3 /*break*/, 14];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(jsonOutput, null, 2))];
+                case 13:
+                    _e.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    return [3 /*break*/, 15];
+                case 14:
                     output.printJson(jsonOutput);
-                }
-                return { success: true, data: jsonOutput };
-            }
-            // Summary
-            const externalImports = sortedImports.filter(([imp]) => !imp.startsWith('.') && !imp.startsWith('/'));
-            const localImports = sortedImports.filter(([imp]) => imp.startsWith('.') || imp.startsWith('/'));
-            output.printBox([
-                `Total unique imports: ${sortedImports.length}`,
-                `External (npm): ${externalImports.length}`,
-                `Local (relative): ${localImports.length}`,
-                `Files scanned: ${files.length}`,
-            ].join('\n'), 'Import Analysis');
-            // Most used imports
-            output.writeln();
-            output.writeln(output.bold('Most Used Imports'));
-            output.writeln(output.dim('-'.repeat(60)));
-            const topImports = sortedImports.slice(0, 20);
-            output.printTable({
-                columns: [
-                    { key: 'count', header: 'Uses', width: 8, align: 'right' },
-                    { key: 'import', header: 'Import', width: 50 },
-                    { key: 'type', header: 'Type', width: 10 },
-                ],
-                data: topImports.map(([imp, data]) => ({
-                    count: data.count,
-                    import: imp,
-                    type: imp.startsWith('.') || imp.startsWith('/') ? output.dim('local') : output.highlight('npm'),
-                })),
-            });
-            if (sortedImports.length > 20) {
-                output.writeln(output.dim(`  ... and ${sortedImports.length - 20} more imports`));
-            }
-            if (outputFile) {
-                await writeFile(outputFile, JSON.stringify({
-                    imports: Object.fromEntries(sortedImports),
-                    fileImports: Object.fromEntries(fileImports),
-                }, null, 2));
-                output.printSuccess(`Results written to ${outputFile}`);
+                    _e.label = 15;
+                case 15: return [2 /*return*/, { success: true, data: jsonOutput }];
+                case 16:
+                    externalImports = sortedImports.filter(function (_a) {
+                        var imp = _a[0];
+                        return !imp.startsWith('.') && !imp.startsWith('/');
+                    });
+                    localImports = sortedImports.filter(function (_a) {
+                        var imp = _a[0];
+                        return imp.startsWith('.') || imp.startsWith('/');
+                    });
+                    output.printBox([
+                        "Total unique imports: " + sortedImports.length,
+                        "External (npm): " + externalImports.length,
+                        "Local (relative): " + localImports.length,
+                        "Files scanned: " + files.length,
+                    ].join('\n'), 'Import Analysis');
+                    // Most used imports
+                    output.writeln();
+                    output.writeln(output.bold('Most Used Imports'));
+                    output.writeln(output.dim('-'.repeat(60)));
+                    topImports = sortedImports.slice(0, 20);
+                    output.printTable({
+                        columns: [
+                            { key: 'count', header: 'Uses', width: 8, align: 'right' },
+                            { key: 'import', header: 'Import', width: 50 },
+                            { key: 'type', header: 'Type', width: 10 },
+                        ],
+                        data: topImports.map(function (_a) {
+                            var imp = _a[0], data = _a[1];
+                            return ({
+                                count: data.count,
+                                "import": imp,
+                                type: imp.startsWith('.') || imp.startsWith('/') ? output.dim('local') : output.highlight('npm')
+                            });
+                        })
+                    });
+                    if (sortedImports.length > 20) {
+                        output.writeln(output.dim("  ... and " + (sortedImports.length - 20) + " more imports"));
+                    }
+                    if (!outputFile) return [3 /*break*/, 18];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify({
+                            imports: Object.fromEntries(sortedImports),
+                            fileImports: Object.fromEntries(fileImports)
+                        }, null, 2))];
+                case 17:
+                    _e.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    _e.label = 18;
+                case 18: return [2 /*return*/, { success: true, data: { imports: sortedImports } }];
+                case 19:
+                    error_5 = _e.sent();
+                    spinner.stop();
+                    message = error_5 instanceof Error ? error_5.message : String(error_5);
+                    output.printError("Import analysis failed: " + message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 20: return [2 /*return*/];
             }
-            return { success: true, data: { imports: sortedImports } };
-        }
-        catch (error) {
-            spinner.stop();
-            const message = error instanceof Error ? error.message : String(error);
-            output.printError(`Import analysis failed: ${message}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 /**
  * Helper: Scan directory for source files
  */
-async function scanSourceFiles(dir, maxDepth = 10) {
-    const files = [];
-    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-    const excludeDirs = ['node_modules', 'dist', 'build', '.git', 'coverage', '__pycache__'];
-    async function scan(currentDir, depth) {
-        if (depth > maxDepth)
-            return;
-        try {
-            const entries = await fs.readdir(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    if (!excludeDirs.includes(entry.name)) {
-                        await scan(fullPath, depth + 1);
-                    }
-                }
-                else if (entry.isFile()) {
-                    const ext = path.extname(entry.name);
-                    if (extensions.includes(ext)) {
-                        files.push(fullPath);
+function scanSourceFiles(dir, maxDepth) {
+    if (maxDepth === void 0) { maxDepth = 10; }
+    return __awaiter(this, void 0, Promise, function () {
+        function scan(currentDir, depth) {
+            return __awaiter(this, void 0, Promise, function () {
+                var entries, _i, entries_1, entry, fullPath, ext, _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (depth > maxDepth)
+                                return [2 /*return*/];
+                            _b.label = 1;
+                        case 1:
+                            _b.trys.push([1, 9, , 10]);
+                            return [4 /*yield*/, fs.readdir(currentDir, { withFileTypes: true })];
+                        case 2:
+                            entries = _b.sent();
+                            _i = 0, entries_1 = entries;
+                            _b.label = 3;
+                        case 3:
+                            if (!(_i < entries_1.length)) return [3 /*break*/, 8];
+                            entry = entries_1[_i];
+                            fullPath = path.join(currentDir, entry.name);
+                            if (!entry.isDirectory()) return [3 /*break*/, 6];
+                            if (!!excludeDirs.includes(entry.name)) return [3 /*break*/, 5];
+                            return [4 /*yield*/, scan(fullPath, depth + 1)];
+                        case 4:
+                            _b.sent();
+                            _b.label = 5;
+                        case 5: return [3 /*break*/, 7];
+                        case 6:
+                            if (entry.isFile()) {
+                                ext = path.extname(entry.name);
+                                if (extensions.includes(ext)) {
+                                    files.push(fullPath);
+                                }
+                            }
+                            _b.label = 7;
+                        case 7:
+                            _i++;
+                            return [3 /*break*/, 3];
+                        case 8: return [3 /*break*/, 10];
+                        case 9:
+                            _a = _b.sent();
+                            return [3 /*break*/, 10];
+                        case 10: return [2 /*return*/];
                     }
-                }
-            }
-        }
-        catch {
-            // Skip directories we can't read
+                });
+            });
         }
-    }
-    await scan(dir, 0);
-    return files;
+        var files, extensions, excludeDirs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    files = [];
+                    extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+                    excludeDirs = ['node_modules', 'dist', 'build', '.git', 'coverage', '__pycache__'];
+                    return [4 /*yield*/, scan(dir, 0)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, files];
+            }
+        });
+    });
 }
 /**
  * Fallback analysis when ruvector is not available
  */
 function fallbackAnalyze(code, filePath) {
-    const lines = code.split('\n');
-    const functions = [];
-    const classes = [];
-    const imports = [];
-    const exports = [];
+    var lines = code.split('\n');
+    var functions = [];
+    var classes = [];
+    var imports = [];
+    var exports = [];
     // Extract functions
-    const funcPattern = /(?:export\s+)?(?:async\s+)?function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>|^\s*(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{/gm;
-    let match;
+    var funcPattern = /(?:export\s+)?(?:async\s+)?function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>|^\s*(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{/gm;
+    var match;
     while ((match = funcPattern.exec(code)) !== null) {
-        const name = match[1] || match[2] || match[3];
+        var name = match[1] || match[2] || match[3];
         if (name && !['if', 'while', 'for', 'switch'].includes(name)) {
-            const lineNum = code.substring(0, match.index).split('\n').length;
-            functions.push({ name, startLine: lineNum, endLine: lineNum + 10 });
+            var lineNum = code.substring(0, match.index).split('\n').length;
+            functions.push({ name: name, startLine: lineNum, endLine: lineNum + 10 });
         }
     }
     // Extract classes
-    const classPattern = /(?:export\s+)?class\s+(\w+)/gm;
+    var classPattern = /(?:export\s+)?class\s+(\w+)/gm;
     while ((match = classPattern.exec(code)) !== null) {
-        const lineNum = code.substring(0, match.index).split('\n').length;
+        var lineNum = code.substring(0, match.index).split('\n').length;
         classes.push({ name: match[1], startLine: lineNum, endLine: lineNum + 20 });
     }
     // Extract imports
-    const importPattern = /import\s+(?:.*\s+from\s+)?['"]([^'"]+)['"]/gm;
+    var importPattern = /import\s+(?:.*\s+from\s+)?['"]([^'"]+)['"]/gm;
     while ((match = importPattern.exec(code)) !== null) {
         imports.push(match[1]);
     }
-    const requirePattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm;
+    var requirePattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm;
     while ((match = requirePattern.exec(code)) !== null) {
         imports.push(match[1]);
     }
     // Extract exports
-    const exportPattern = /export\s+(?:default\s+)?(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/gm;
+    var exportPattern = /export\s+(?:default\s+)?(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/gm;
     while ((match = exportPattern.exec(code)) !== null) {
         exports.push(match[1]);
     }
     // Calculate complexity
-    const nonEmptyLines = lines.filter(l => l.trim().length > 0).length;
-    const commentLines = lines.filter(l => /^\s*(\/\/|\/\*|\*|#)/.test(l)).length;
-    const decisionPoints = (code.match(/\b(if|else|for|while|switch|case|catch|&&|\|\||\?)\b/g) || []).length;
-    let cognitive = 0;
-    let nestingLevel = 0;
-    for (const line of lines) {
-        const opens = (line.match(/\{/g) || []).length;
-        const closes = (line.match(/\}/g) || []).length;
+    var nonEmptyLines = lines.filter(function (l) { return l.trim().length > 0; }).length;
+    var commentLines = lines.filter(function (l) { return /^\s*(\/\/|\/\*|\*|#)/.test(l); }).length;
+    var decisionPoints = (code.match(/\b(if|else|for|while|switch|case|catch|&&|\|\||\?)\b/g) || []).length;
+    var cognitive = 0;
+    var nestingLevel = 0;
+    for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+        var line = lines_1[_i];
+        var opens = (line.match(/\{/g) || []).length;
+        var closes = (line.match(/\}/g) || []).length;
         if (/\b(if|for|while|switch)\b/.test(line)) {
             cognitive += 1 + nestingLevel;
         }
         nestingLevel = Math.max(0, nestingLevel + opens - closes);
     }
     // Detect language
-    const ext = path.extname(filePath).toLowerCase();
-    const language = ext === '.ts' || ext === '.tsx' ? 'typescript' :
+    var ext = path.extname(filePath).toLowerCase();
+    var language = ext === '.ts' || ext === '.tsx' ? 'typescript' :
         ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs' ? 'javascript' :
             ext === '.py' ? 'python' : 'unknown';
     return {
-        filePath,
-        language,
-        functions,
-        classes,
-        imports,
-        exports,
+        filePath: filePath,
+        language: language,
+        functions: functions,
+        classes: classes,
+        imports: imports,
+        exports: exports,
         complexity: {
             cyclomatic: decisionPoints + 1,
-            cognitive,
+            cognitive: cognitive,
             loc: nonEmptyLines,
-            commentDensity: lines.length > 0 ? commentLines / lines.length : 0,
-        },
+            commentDensity: lines.length > 0 ? commentLines / lines.length : 0
+        }
     };
 }
 // Dependencies subcommand
-const depsCommand = {
+var depsCommand = {
     name: 'deps',
     description: 'Analyze project dependencies',
     options: [
         { name: 'outdated', short: 'o', type: 'boolean', description: 'Show only outdated dependencies' },
         { name: 'security', short: 's', type: 'boolean', description: 'Check for security vulnerabilities' },
-        { name: 'format', short: 'f', type: 'string', description: 'Output format: text, json', default: 'text' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: text, json', "default": 'text' },
     ],
     examples: [
         { command: 'claude-flow analyze deps --outdated', description: 'Show outdated dependencies' },
         { command: 'claude-flow analyze deps --security', description: 'Check for vulnerabilities' },
     ],
-    action: async (ctx) => {
-        const showOutdated = ctx.flags.outdated;
-        const checkSecurity = ctx.flags.security;
-        output.writeln();
-        output.writeln(output.bold('Dependency Analysis'));
-        output.writeln(output.dim('-'.repeat(50)));
-        output.printInfo('Analyzing dependencies...');
-        output.writeln();
-        // Placeholder - would integrate with npm/yarn audit
-        output.printBox([
-            `Outdated Check: ${showOutdated ? 'Enabled' : 'Disabled'}`,
-            `Security Check: ${checkSecurity ? 'Enabled' : 'Disabled'}`,
-            `Status: Feature in development`,
-            ``,
-            `Dependency analysis capabilities coming soon.`,
-            `Use 'security scan --type deps' for security scanning.`,
-        ].join('\n'), 'Dependency Analysis');
-        return { success: true };
-    },
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var showOutdated, checkSecurity;
+        return __generator(this, function (_a) {
+            showOutdated = ctx.flags.outdated;
+            checkSecurity = ctx.flags.security;
+            output.writeln();
+            output.writeln(output.bold('Dependency Analysis'));
+            output.writeln(output.dim('-'.repeat(50)));
+            output.printInfo('Analyzing dependencies...');
+            output.writeln();
+            // Placeholder - would integrate with npm/yarn audit
+            output.printBox([
+                "Outdated Check: " + (showOutdated ? 'Enabled' : 'Disabled'),
+                "Security Check: " + (checkSecurity ? 'Enabled' : 'Disabled'),
+                "Status: Feature in development",
+                "",
+                "Dependency analysis capabilities coming soon.",
+                "Use 'security scan --type deps' for security scanning.",
+            ].join('\n'), 'Dependency Analysis');
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 // ============================================================================
 // Graph Analysis Subcommands (MinCut, Louvain, Circular Dependencies)
@@ -1129,7 +1390,7 @@ const depsCommand = {
 /**
  * Analyze code boundaries using MinCut algorithm
  */
-const boundariesCommand = {
+var boundariesCommand = {
     name: 'boundaries',
     aliases: ['boundary', 'mincut'],
     description: 'Find natural code boundaries using MinCut algorithm',
@@ -1139,21 +1400,21 @@ const boundariesCommand = {
             short: 'p',
             description: 'Number of partitions to find',
             type: 'number',
-            default: 2,
+            "default": 2
         },
         {
             name: 'output',
             short: 'o',
             description: 'Output file path',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'format',
             short: 'f',
             description: 'Output format (text, json, dot)',
             type: 'string',
-            default: 'text',
-            choices: ['text', 'json', 'dot'],
+            "default": 'text',
+            choices: ['text', 'json', 'dot']
         },
     ],
     examples: [
@@ -1161,127 +1422,145 @@ const boundariesCommand = {
         { command: 'claude-flow analyze boundaries -p 3 src/', description: 'Find 3 partitions' },
         { command: 'claude-flow analyze boundaries -f dot -o graph.dot src/', description: 'Export to DOT format' },
     ],
-    action: async (ctx) => {
-        const targetDir = ctx.args[0] || ctx.cwd;
-        const numPartitions = ctx.flags.partitions || 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 writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
-                    output.printSuccess(`Results written to ${outputFile}`);
-                }
-                else {
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var targetDir, numPartitions, outputFile, format, spinner, analyzer, result, jsonOutput, dotOutput, i, boundary, p1Display, p2Display, _i, _a, cycle, severityColor, error_6, message;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    targetDir = ctx.args[0] || ctx.cwd;
+                    numPartitions = ctx.flags.partitions || 2;
+                    outputFile = ctx.flags.output;
+                    format = ctx.flags.format || 'text';
+                    output.printInfo("Analyzing code boundaries in: " + output.highlight(targetDir));
+                    output.writeln();
+                    spinner = output.createSpinner({ text: 'Building dependency graph...', spinner: 'dots' });
+                    spinner.start();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 14, , 15]);
+                    return [4 /*yield*/, getGraphAnalyzer()];
+                case 2:
+                    analyzer = _b.sent();
+                    if (!analyzer) {
+                        spinner.stop();
+                        output.printError('Graph analyzer module not available');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    return [4 /*yield*/, analyzer.analyzeGraph(resolve(targetDir), {
+                            includeBoundaries: true,
+                            includeModules: false,
+                            numPartitions: numPartitions
+                        })];
+                case 3:
+                    result = _b.sent();
+                    spinner.stop();
+                    if (!(format === 'json')) return [3 /*break*/, 7];
+                    jsonOutput = {
+                        boundaries: result.boundaries,
+                        statistics: result.statistics,
+                        circularDependencies: result.circularDependencies
+                    };
+                    if (!outputFile) return [3 /*break*/, 5];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(jsonOutput, null, 2))];
+                case 4:
+                    _b.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    return [3 /*break*/, 6];
+                case 5:
                     output.printJson(jsonOutput);
-                }
-                return { success: true, data: jsonOutput };
-            }
-            if (format === 'dot') {
-                const dotOutput = analyzer.exportToDot(result, {
-                    includeLabels: true,
-                    highlightCycles: true,
-                });
-                if (outputFile) {
-                    await writeFile(outputFile, dotOutput);
-                    output.printSuccess(`DOT graph written to ${outputFile}`);
+                    _b.label = 6;
+                case 6: return [2 /*return*/, { success: true, data: jsonOutput }];
+                case 7:
+                    if (!(format === 'dot')) return [3 /*break*/, 11];
+                    dotOutput = analyzer.exportToDot(result, {
+                        includeLabels: true,
+                        highlightCycles: true
+                    });
+                    if (!outputFile) return [3 /*break*/, 9];
+                    return [4 /*yield*/, writeFile(outputFile, dotOutput)];
+                case 8:
+                    _b.sent();
+                    output.printSuccess("DOT graph written to " + outputFile);
                     output.writeln(output.dim('Visualize with: dot -Tpng -o graph.png ' + outputFile));
-                }
-                else {
+                    return [3 /*break*/, 10];
+                case 9:
                     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`));
+                    _b.label = 10;
+                case 10: return [2 /*return*/, { success: true }];
+                case 11:
+                    // 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 (i = 0; i < result.boundaries.length; i++) {
+                            boundary = result.boundaries[i];
+                            output.writeln(output.bold("Boundary " + (i + 1) + " (cut value: " + boundary.cutValue + ")"));
+                            output.writeln();
+                            output.writeln(output.dim('Partition 1:'));
+                            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:'));
+                            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();
+                        }
                     }
-                    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`));
+                    // Show circular dependencies
+                    if (result.circularDependencies.length > 0) {
+                        output.writeln();
+                        output.writeln(output.bold(output.warning('Circular Dependencies Detected')));
+                        output.writeln();
+                        for (_i = 0, _a = result.circularDependencies.slice(0, 5); _i < _a.length; _i++) {
+                            cycle = _a[_i];
+                            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"));
+                        }
                     }
-                    output.writeln();
-                    output.writeln(output.success('Suggestion:'));
-                    output.writeln(`  ${boundary.suggestion}`);
-                    output.writeln();
-                }
+                    if (!outputFile) return [3 /*break*/, 13];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(result, null, 2))];
+                case 12:
+                    _b.sent();
+                    output.printSuccess("Full results written to " + outputFile);
+                    _b.label = 13;
+                case 13: return [2 /*return*/, { success: true, data: result }];
+                case 14:
+                    error_6 = _b.sent();
+                    spinner.stop();
+                    message = error_6 instanceof Error ? error_6.message : String(error_6);
+                    output.printError("Analysis failed: " + message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 15: return [2 /*return*/];
             }
-            // 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 writeFile(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
  */
-const modulesCommand = {
+var modulesCommand = {
     name: 'modules',
     aliases: ['communities', 'louvain'],
     description: 'Detect module communities using Louvain algorithm',
@@ -1290,22 +1569,22 @@ const modulesCommand = {
             name: 'output',
             short: 'o',
             description: 'Output file path',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'format',
             short: 'f',
             description: 'Output format (text, json, dot)',
             type: 'string',
-            default: 'text',
-            choices: ['text', 'json', 'dot'],
+            "default": 'text',
+            choices: ['text', 'json', 'dot']
         },
         {
             name: 'min-size',
             short: 'm',
             description: 'Minimum community size to display',
             type: 'number',
-            default: 2,
+            "default": 2
         },
     ],
     examples: [
@@ -1313,109 +1592,128 @@ const modulesCommand = {
         { command: 'claude-flow analyze modules -f dot -o modules.dot src/', description: 'Export colored DOT graph' },
         { command: 'claude-flow 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 writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
-                    output.printSuccess(`Results written to ${outputFile}`);
-                }
-                else {
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var targetDir, outputFile, format, minSize, spinner, analyzer, result, communities, jsonOutput, dotOutput, _i, _a, community, cohesionIndicator, displayMembers, _b, displayMembers_1, member, error_7, message;
+        var _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    targetDir = ctx.args[0] || ctx.cwd;
+                    outputFile = ctx.flags.output;
+                    format = ctx.flags.format || 'text';
+                    minSize = ctx.flags['min-size'] || 2;
+                    output.printInfo("Detecting module communities in: " + output.highlight(targetDir));
+                    output.writeln();
+                    spinner = output.createSpinner({ text: 'Building dependency graph...', spinner: 'dots' });
+                    spinner.start();
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 14, , 15]);
+                    return [4 /*yield*/, getGraphAnalyzer()];
+                case 2:
+                    analyzer = _e.sent();
+                    if (!analyzer) {
+                        spinner.stop();
+                        output.printError('Graph analyzer module not available');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    return [4 /*yield*/, analyzer.analyzeGraph(resolve(targetDir), {
+                            includeBoundaries: false,
+                            includeModules: true
+                        })];
+                case 3:
+                    result = _e.sent();
+                    spinner.stop();
+                    communities = ((_c = result.communities) === null || _c === void 0 ? void 0 : _c.filter(function (c) { return c.members.length >= minSize; })) || [];
+                    if (!(format === 'json')) return [3 /*break*/, 7];
+                    jsonOutput = {
+                        communities: communities,
+                        statistics: result.statistics
+                    };
+                    if (!outputFile) return [3 /*break*/, 5];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(jsonOutput, null, 2))];
+                case 4:
+                    _e.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    return [3 /*break*/, 6];
+                case 5:
                     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 writeFile(outputFile, dotOutput);
-                    output.printSuccess(`DOT graph written to ${outputFile}`);
+                    _e.label = 6;
+                case 6: return [2 /*return*/, { success: true, data: jsonOutput }];
+                case 7:
+                    if (!(format === 'dot')) return [3 /*break*/, 11];
+                    dotOutput = analyzer.exportToDot(result, {
+                        includeLabels: true,
+                        colorByCommunity: true,
+                        highlightCycles: true
+                    });
+                    if (!outputFile) return [3 /*break*/, 9];
+                    return [4 /*yield*/, writeFile(outputFile, dotOutput)];
+                case 8:
+                    _e.sent();
+                    output.printSuccess("DOT graph written to " + outputFile);
                     output.writeln(output.dim('Visualize with: dot -Tpng -o modules.png ' + outputFile));
-                }
-                else {
+                    return [3 /*break*/, 10];
+                case 9:
                     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`));
+                    _e.label = 10;
+                case 10: return [2 /*return*/, { success: true }];
+                case 11:
+                    // Text format (default)
+                    output.printBox([
+                        "Files analyzed: " + result.statistics.nodeCount,
+                        "Dependencies: " + result.statistics.edgeCount,
+                        "Communities found: " + (((_d = result.communities) === null || _d === void 0 ? void 0 : _d.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 (_i = 0, _a = communities.slice(0, 10); _i < _a.length; _i++) {
+                            community = _a[_i];
+                            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");
+                            displayMembers = community.members.slice(0, 5);
+                            for (_b = 0, displayMembers_1 = displayMembers; _b < displayMembers_1.length; _b++) {
+                                member = displayMembers_1[_b];
+                                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"));
+                        }
                     }
-                    output.writeln();
-                }
-                if (communities.length > 10) {
-                    output.writeln(output.dim(`... and ${communities.length - 10} more communities`));
-                }
-            }
-            if (outputFile) {
-                await writeFile(outputFile, JSON.stringify(result, null, 2));
-                output.printSuccess(`Full results written to ${outputFile}`);
+                    if (!outputFile) return [3 /*break*/, 13];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(result, null, 2))];
+                case 12:
+                    _e.sent();
+                    output.printSuccess("Full results written to " + outputFile);
+                    _e.label = 13;
+                case 13: return [2 /*return*/, { success: true, data: result }];
+                case 14:
+                    error_7 = _e.sent();
+                    spinner.stop();
+                    message = error_7 instanceof Error ? error_7.message : String(error_7);
+                    output.printError("Analysis failed: " + message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 15: return [2 /*return*/];
             }
-            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 };
-        }
-    },
+        });
+    }); }
 };
 /**
  * Build and export dependency graph
  */
-const dependenciesCommand = {
+var dependenciesCommand = {
     name: 'dependencies',
     aliases: ['graph'],
     description: 'Build and export full dependency graph',
@@ -1424,36 +1722,36 @@ const dependenciesCommand = {
             name: 'output',
             short: 'o',
             description: 'Output file path',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'format',
             short: 'f',
             description: 'Output format (text, json, dot)',
             type: 'string',
-            default: 'text',
-            choices: ['text', 'json', 'dot'],
+            "default": 'text',
+            choices: ['text', 'json', 'dot']
         },
         {
             name: 'include',
             short: 'i',
             description: 'File extensions to include (comma-separated)',
             type: 'string',
-            default: '.ts,.tsx,.js,.jsx,.mjs,.cjs',
+            "default": '.ts,.tsx,.js,.jsx,.mjs,.cjs'
         },
         {
             name: 'exclude',
             short: 'e',
             description: 'Patterns to exclude (comma-separated)',
             type: 'string',
-            default: 'node_modules,dist,build,.git',
+            "default": 'node_modules,dist,build,.git'
         },
         {
             name: 'depth',
             short: 'd',
             description: 'Maximum directory depth',
             type: 'number',
-            default: 10,
+            "default": 10
         },
     ],
     examples: [
@@ -1461,138 +1759,152 @@ const dependenciesCommand = {
         { command: 'claude-flow analyze dependencies -f dot -o deps.dot src/', description: 'Export to DOT' },
         { command: 'claude-flow analyze dependencies -i .ts,.tsx src/', description: 'Only TypeScript files' },
     ],
-    action: async (ctx) => {
-        const targetDir = ctx.args[0] || ctx.cwd;
-        const outputFile = ctx.flags.output;
-        const format = ctx.flags.format || 'text';
-        const include = (ctx.flags.include || '.ts,.tsx,.js,.jsx,.mjs,.cjs').split(',');
-        const exclude = (ctx.flags.exclude || 'node_modules,dist,build,.git').split(',');
-        const maxDepth = ctx.flags.depth || 10;
-        output.printInfo(`Building dependency graph for: ${output.highlight(targetDir)}`);
-        output.writeln();
-        const spinner = output.createSpinner({ text: 'Scanning files...', 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 graph = await analyzer.buildDependencyGraph(resolve(targetDir), {
-                include,
-                exclude,
-                maxDepth,
-            });
-            spinner.stop();
-            // Detect circular dependencies
-            const circularDeps = analyzer.detectCircularDependencies(graph);
-            // Handle different output formats
-            if (format === 'json') {
-                const jsonOutput = {
-                    nodes: Array.from(graph.nodes.values()),
-                    edges: graph.edges,
-                    metadata: graph.metadata,
-                    circularDependencies: circularDeps,
-                };
-                if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
-                    output.printSuccess(`Graph written to ${outputFile}`);
-                }
-                else {
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var targetDir, outputFile, format, include, exclude, maxDepth, spinner, analyzer, graph_1, circularDeps, jsonOutput, result, dotOutput, nodesByDegree, _i, _a, cycle, fullOutput, error_8, message;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    targetDir = ctx.args[0] || ctx.cwd;
+                    outputFile = ctx.flags.output;
+                    format = ctx.flags.format || 'text';
+                    include = (ctx.flags.include || '.ts,.tsx,.js,.jsx,.mjs,.cjs').split(',');
+                    exclude = (ctx.flags.exclude || 'node_modules,dist,build,.git').split(',');
+                    maxDepth = ctx.flags.depth || 10;
+                    output.printInfo("Building dependency graph for: " + output.highlight(targetDir));
+                    output.writeln();
+                    spinner = output.createSpinner({ text: 'Scanning files...', spinner: 'dots' });
+                    spinner.start();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 14, , 15]);
+                    return [4 /*yield*/, getGraphAnalyzer()];
+                case 2:
+                    analyzer = _b.sent();
+                    if (!analyzer) {
+                        spinner.stop();
+                        output.printError('Graph analyzer module not available');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    return [4 /*yield*/, analyzer.buildDependencyGraph(resolve(targetDir), {
+                            include: include,
+                            exclude: exclude,
+                            maxDepth: maxDepth
+                        })];
+                case 3:
+                    graph_1 = _b.sent();
+                    spinner.stop();
+                    circularDeps = analyzer.detectCircularDependencies(graph_1);
+                    if (!(format === 'json')) return [3 /*break*/, 7];
+                    jsonOutput = {
+                        nodes: Array.from(graph_1.nodes.values()),
+                        edges: graph_1.edges,
+                        metadata: graph_1.metadata,
+                        circularDependencies: circularDeps
+                    };
+                    if (!outputFile) return [3 /*break*/, 5];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(jsonOutput, null, 2))];
+                case 4:
+                    _b.sent();
+                    output.printSuccess("Graph written to " + outputFile);
+                    return [3 /*break*/, 6];
+                case 5:
                     output.printJson(jsonOutput);
-                }
-                return { success: true, data: jsonOutput };
-            }
-            if (format === 'dot') {
-                const result = { graph, circularDependencies: circularDeps, statistics: {
-                        nodeCount: graph.nodes.size,
-                        edgeCount: graph.edges.length,
-                        avgDegree: 0,
-                        maxDegree: 0,
-                        density: 0,
-                        componentCount: 0,
-                    } };
-                const dotOutput = analyzer.exportToDot(result, {
-                    includeLabels: true,
-                    highlightCycles: true,
-                });
-                if (outputFile) {
-                    await writeFile(outputFile, dotOutput);
-                    output.printSuccess(`DOT graph written to ${outputFile}`);
+                    _b.label = 6;
+                case 6: return [2 /*return*/, { success: true, data: jsonOutput }];
+                case 7:
+                    if (!(format === 'dot')) return [3 /*break*/, 11];
+                    result = { graph: graph_1, circularDependencies: circularDeps, statistics: {
+                            nodeCount: graph_1.nodes.size,
+                            edgeCount: graph_1.edges.length,
+                            avgDegree: 0,
+                            maxDegree: 0,
+                            density: 0,
+                            componentCount: 0
+                        } };
+                    dotOutput = analyzer.exportToDot(result, {
+                        includeLabels: true,
+                        highlightCycles: true
+                    });
+                    if (!outputFile) return [3 /*break*/, 9];
+                    return [4 /*yield*/, writeFile(outputFile, dotOutput)];
+                case 8:
+                    _b.sent();
+                    output.printSuccess("DOT graph written to " + outputFile);
                     output.writeln(output.dim('Visualize with: dot -Tpng -o deps.png ' + outputFile));
-                }
-                else {
+                    return [3 /*break*/, 10];
+                case 9:
                     output.writeln(dotOutput);
-                }
-                return { success: true };
-            }
-            // Text format (default)
-            output.printBox([
-                `Files: ${graph.metadata.totalFiles}`,
-                `Dependencies: ${graph.metadata.totalEdges}`,
-                `Build time: ${graph.metadata.buildTime}ms`,
-                `Root: ${graph.metadata.rootDir}`,
-            ].join('\n'), 'Dependency Graph');
-            // Show top files by imports
-            output.writeln();
-            output.writeln(output.bold('Most Connected Files'));
-            output.writeln();
-            const nodesByDegree = Array.from(graph.nodes.values())
-                .map(n => ({
-                ...n,
-                degree: graph.edges.filter(e => e.source === n.id || e.target === n.id).length,
-            }))
-                .sort((a, b) => b.degree - a.degree)
-                .slice(0, 10);
-            output.printTable({
-                columns: [
-                    { key: 'path', header: 'File', width: 50 },
-                    { key: 'degree', header: 'Connections', width: 12, align: 'right' },
-                    { key: 'complexity', header: 'Complexity', width: 12, align: 'right' },
-                ],
-                data: nodesByDegree.map(n => ({
-                    path: n.path.length > 48 ? '...' + n.path.slice(-45) : n.path,
-                    degree: n.degree,
-                    complexity: n.complexity || 0,
-                })),
-            });
-            // Show circular dependencies
-            if (circularDeps.length > 0) {
-                output.writeln();
-                output.writeln(output.bold(output.warning(`Circular Dependencies: ${circularDeps.length}`)));
-                output.writeln();
-                for (const cycle of circularDeps.slice(0, 3)) {
-                    output.writeln(`  ${cycle.cycle.join(' -> ')}`);
-                }
-                if (circularDeps.length > 3) {
-                    output.writeln(output.dim(`  ... and ${circularDeps.length - 3} more`));
-                }
-            }
-            if (outputFile) {
-                const fullOutput = {
-                    nodes: Array.from(graph.nodes.values()),
-                    edges: graph.edges,
-                    metadata: graph.metadata,
-                    circularDependencies: circularDeps,
-                };
-                await writeFile(outputFile, JSON.stringify(fullOutput, null, 2));
-                output.printSuccess(`Full results written to ${outputFile}`);
+                    _b.label = 10;
+                case 10: return [2 /*return*/, { success: true }];
+                case 11:
+                    // Text format (default)
+                    output.printBox([
+                        "Files: " + graph_1.metadata.totalFiles,
+                        "Dependencies: " + graph_1.metadata.totalEdges,
+                        "Build time: " + graph_1.metadata.buildTime + "ms",
+                        "Root: " + graph_1.metadata.rootDir,
+                    ].join('\n'), 'Dependency Graph');
+                    // Show top files by imports
+                    output.writeln();
+                    output.writeln(output.bold('Most Connected Files'));
+                    output.writeln();
+                    nodesByDegree = Array.from(graph_1.nodes.values())
+                        .map(function (n) { return (__assign(__assign({}, n), { degree: graph_1.edges.filter(function (e) { return e.source === n.id || e.target === n.id; }).length })); })
+                        .sort(function (a, b) { return b.degree - a.degree; })
+                        .slice(0, 10);
+                    output.printTable({
+                        columns: [
+                            { key: 'path', header: 'File', width: 50 },
+                            { key: 'degree', header: 'Connections', width: 12, align: 'right' },
+                            { key: 'complexity', header: 'Complexity', width: 12, align: 'right' },
+                        ],
+                        data: nodesByDegree.map(function (n) { return ({
+                            path: n.path.length > 48 ? '...' + n.path.slice(-45) : n.path,
+                            degree: n.degree,
+                            complexity: n.complexity || 0
+                        }); })
+                    });
+                    // Show circular dependencies
+                    if (circularDeps.length > 0) {
+                        output.writeln();
+                        output.writeln(output.bold(output.warning("Circular Dependencies: " + circularDeps.length)));
+                        output.writeln();
+                        for (_i = 0, _a = circularDeps.slice(0, 3); _i < _a.length; _i++) {
+                            cycle = _a[_i];
+                            output.writeln("  " + cycle.cycle.join(' -> '));
+                        }
+                        if (circularDeps.length > 3) {
+                            output.writeln(output.dim("  ... and " + (circularDeps.length - 3) + " more"));
+                        }
+                    }
+                    if (!outputFile) return [3 /*break*/, 13];
+                    fullOutput = {
+                        nodes: Array.from(graph_1.nodes.values()),
+                        edges: graph_1.edges,
+                        metadata: graph_1.metadata,
+                        circularDependencies: circularDeps
+                    };
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(fullOutput, null, 2))];
+                case 12:
+                    _b.sent();
+                    output.printSuccess("Full results written to " + outputFile);
+                    _b.label = 13;
+                case 13: return [2 /*return*/, { success: true }];
+                case 14:
+                    error_8 = _b.sent();
+                    spinner.stop();
+                    message = error_8 instanceof Error ? error_8.message : String(error_8);
+                    output.printError("Analysis failed: " + message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 15: return [2 /*return*/];
             }
-            return { success: true };
-        }
-        catch (error) {
-            spinner.stop();
-            const message = error instanceof Error ? error.message : String(error);
-            output.printError(`Analysis failed: ${message}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 /**
  * Detect circular dependencies
  */
-const circularCommand = {
+var circularCommand = {
     name: 'circular',
     aliases: ['cycles'],
     description: 'Detect circular dependencies in codebase',
@@ -1601,111 +1913,127 @@ const circularCommand = {
             name: 'output',
             short: 'o',
             description: 'Output file path',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'format',
             short: 'f',
             description: 'Output format (text, json)',
             type: 'string',
-            default: 'text',
-            choices: ['text', 'json'],
+            "default": 'text',
+            choices: ['text', 'json']
         },
         {
             name: 'severity',
             short: 's',
             description: 'Minimum severity to show (low, medium, high)',
             type: 'string',
-            default: 'low',
-            choices: ['low', 'medium', 'high'],
+            "default": 'low',
+            choices: ['low', 'medium', 'high']
         },
     ],
     examples: [
         { command: 'claude-flow analyze circular src/', description: 'Find circular dependencies' },
         { command: 'claude-flow analyze circular -s high src/', description: 'Only high severity cycles' },
     ],
-    action: async (ctx) => {
-        const targetDir = ctx.args[0] || ctx.cwd;
-        const outputFile = ctx.flags.output;
-        const format = ctx.flags.format || 'text';
-        const minSeverity = ctx.flags.severity || 'low';
-        output.printInfo(`Detecting circular dependencies in: ${output.highlight(targetDir)}`);
-        output.writeln();
-        const spinner = output.createSpinner({ text: 'Analyzing dependencies...', 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 graph = await analyzer.buildDependencyGraph(resolve(targetDir));
-            const cycles = analyzer.detectCircularDependencies(graph);
-            spinner.stop();
-            // Filter by severity
-            const severityOrder = { low: 0, medium: 1, high: 2 };
-            const minLevel = severityOrder[minSeverity] || 0;
-            const filtered = cycles.filter(c => severityOrder[c.severity] >= minLevel);
-            if (format === 'json') {
-                const jsonOutput = { cycles: filtered, total: cycles.length, filtered: filtered.length };
-                if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
-                    output.printSuccess(`Results written to ${outputFile}`);
-                }
-                else {
-                    output.printJson(jsonOutput);
-                }
-                return { success: true, data: jsonOutput };
-            }
-            // Text format
-            if (filtered.length === 0) {
-                output.printSuccess('No circular dependencies found!');
-                return { success: true };
-            }
-            output.printBox([
-                `Total cycles: ${cycles.length}`,
-                `Shown (${minSeverity}+): ${filtered.length}`,
-                `High severity: ${cycles.filter(c => c.severity === 'high').length}`,
-                `Medium severity: ${cycles.filter(c => c.severity === 'medium').length}`,
-                `Low severity: ${cycles.filter(c => c.severity === 'low').length}`,
-            ].join('\n'), 'Circular Dependencies');
-            output.writeln();
-            // Group by severity
-            const grouped = {
-                high: filtered.filter(c => c.severity === 'high'),
-                medium: filtered.filter(c => c.severity === 'medium'),
-                low: filtered.filter(c => c.severity === 'low'),
-            };
-            for (const [severity, items] of Object.entries(grouped)) {
-                if (items.length === 0)
-                    continue;
-                const color = severity === 'high' ? output.error : severity === 'medium' ? output.warning : output.dim;
-                output.writeln(color(output.bold(`${severity.toUpperCase()} SEVERITY (${items.length})`)));
-                output.writeln();
-                for (const cycle of items.slice(0, 5)) {
-                    output.writeln(`  ${cycle.cycle.join(' -> ')}`);
-                    output.writeln(output.dim(`  Fix: ${cycle.suggestion}`));
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var targetDir, outputFile, format, minSeverity, spinner, analyzer, graph, cycles, severityOrder_1, minLevel_1, filtered, jsonOutput, grouped, _i, _a, _b, severity, items, color, _c, _d, cycle, error_9, message;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    targetDir = ctx.args[0] || ctx.cwd;
+                    outputFile = ctx.flags.output;
+                    format = ctx.flags.format || 'text';
+                    minSeverity = ctx.flags.severity || 'low';
+                    output.printInfo("Detecting circular dependencies in: " + output.highlight(targetDir));
                     output.writeln();
-                }
-                if (items.length > 5) {
-                    output.writeln(output.dim(`  ... and ${items.length - 5} more ${severity} cycles`));
+                    spinner = output.createSpinner({ text: 'Analyzing dependencies...', spinner: 'dots' });
+                    spinner.start();
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 10, , 11]);
+                    return [4 /*yield*/, getGraphAnalyzer()];
+                case 2:
+                    analyzer = _e.sent();
+                    if (!analyzer) {
+                        spinner.stop();
+                        output.printError('Graph analyzer module not available');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    return [4 /*yield*/, analyzer.buildDependencyGraph(resolve(targetDir))];
+                case 3:
+                    graph = _e.sent();
+                    cycles = analyzer.detectCircularDependencies(graph);
+                    spinner.stop();
+                    severityOrder_1 = { low: 0, medium: 1, high: 2 };
+                    minLevel_1 = severityOrder_1[minSeverity] || 0;
+                    filtered = cycles.filter(function (c) { return severityOrder_1[c.severity] >= minLevel_1; });
+                    if (!(format === 'json')) return [3 /*break*/, 7];
+                    jsonOutput = { cycles: filtered, total: cycles.length, filtered: filtered.length };
+                    if (!outputFile) return [3 /*break*/, 5];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify(jsonOutput, null, 2))];
+                case 4:
+                    _e.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    return [3 /*break*/, 6];
+                case 5:
+                    output.printJson(jsonOutput);
+                    _e.label = 6;
+                case 6: return [2 /*return*/, { success: true, data: jsonOutput }];
+                case 7:
+                    // Text format
+                    if (filtered.length === 0) {
+                        output.printSuccess('No circular dependencies found!');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    output.printBox([
+                        "Total cycles: " + cycles.length,
+                        "Shown (" + minSeverity + "+): " + filtered.length,
+                        "High severity: " + cycles.filter(function (c) { return c.severity === 'high'; }).length,
+                        "Medium severity: " + cycles.filter(function (c) { return c.severity === 'medium'; }).length,
+                        "Low severity: " + cycles.filter(function (c) { return c.severity === 'low'; }).length,
+                    ].join('\n'), 'Circular Dependencies');
                     output.writeln();
-                }
-            }
-            if (outputFile) {
-                await writeFile(outputFile, JSON.stringify({ cycles: filtered }, null, 2));
-                output.printSuccess(`Results written to ${outputFile}`);
+                    grouped = {
+                        high: filtered.filter(function (c) { return c.severity === 'high'; }),
+                        medium: filtered.filter(function (c) { return c.severity === 'medium'; }),
+                        low: filtered.filter(function (c) { return c.severity === 'low'; })
+                    };
+                    for (_i = 0, _a = Object.entries(grouped); _i < _a.length; _i++) {
+                        _b = _a[_i], severity = _b[0], items = _b[1];
+                        if (items.length === 0)
+                            continue;
+                        color = severity === 'high' ? output.error : severity === 'medium' ? output.warning : output.dim;
+                        output.writeln(color(output.bold(severity.toUpperCase() + " SEVERITY (" + items.length + ")")));
+                        output.writeln();
+                        for (_c = 0, _d = items.slice(0, 5); _c < _d.length; _c++) {
+                            cycle = _d[_c];
+                            output.writeln("  " + cycle.cycle.join(' -> '));
+                            output.writeln(output.dim("  Fix: " + cycle.suggestion));
+                            output.writeln();
+                        }
+                        if (items.length > 5) {
+                            output.writeln(output.dim("  ... and " + (items.length - 5) + " more " + severity + " cycles"));
+                            output.writeln();
+                        }
+                    }
+                    if (!outputFile) return [3 /*break*/, 9];
+                    return [4 /*yield*/, writeFile(outputFile, JSON.stringify({ cycles: filtered }, null, 2))];
+                case 8:
+                    _e.sent();
+                    output.printSuccess("Results written to " + outputFile);
+                    _e.label = 9;
+                case 9: return [2 /*return*/, { success: true, data: { cycles: filtered } }];
+                case 10:
+                    error_9 = _e.sent();
+                    spinner.stop();
+                    message = error_9 instanceof Error ? error_9.message : String(error_9);
+                    output.printError("Analysis failed: " + message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 11: return [2 /*return*/];
             }
-            return { success: true, data: { cycles: filtered } };
-        }
-        catch (error) {
-            spinner.stop();
-            const message = error instanceof Error ? error.message : String(error);
-            output.printError(`Analysis failed: ${message}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 // Helper functions
 function getRiskDisplay(risk) {
@@ -1737,7 +2065,7 @@ function getStatusDisplay(status) {
     }
 }
 // Main analyze command
-export const analyzeCommand = {
+export var analyzeCommand = {
     name: 'analyze',
     description: 'Code analysis, diff classification, graph boundaries, and change risk assessment',
     aliases: ['an'],
@@ -1760,7 +2088,7 @@ export const analyzeCommand = {
             short: 'f',
             description: 'Output format: text, json, table',
             type: 'string',
-            default: 'text',
+            "default": 'text'
         },
     ],
     examples: [
@@ -1775,49 +2103,51 @@ export const analyzeCommand = {
         { command: 'claude-flow analyze circular src/', description: 'Find circular dependencies' },
         { command: 'claude-flow analyze deps --security', description: 'Check dependency vulnerabilities' },
     ],
-    action: async (ctx) => {
-        // If no subcommand, show help
-        output.writeln();
-        output.writeln(output.bold('Analyze Commands'));
-        output.writeln(output.dim('-'.repeat(50)));
-        output.writeln();
-        output.writeln(output.bold('Available subcommands:'));
-        output.writeln();
-        output.writeln(`  ${output.highlight('diff')}         Analyze git diff for change risk and classification`);
-        output.writeln(`  ${output.highlight('code')}         Static code analysis and quality assessment`);
-        output.writeln(`  ${output.highlight('deps')}         Analyze project dependencies`);
-        output.writeln(`  ${output.highlight('ast')}          AST analysis with symbol extraction and complexity`);
-        output.writeln(`  ${output.highlight('complexity')}   Analyze cyclomatic and cognitive complexity`);
-        output.writeln(`  ${output.highlight('symbols')}      Extract functions, classes, and types`);
-        output.writeln(`  ${output.highlight('imports')}      Analyze import dependencies`);
-        output.writeln(`  ${output.highlight('boundaries')}   Find code boundaries using MinCut algorithm`);
-        output.writeln(`  ${output.highlight('modules')}      Detect module communities using Louvain algorithm`);
-        output.writeln(`  ${output.highlight('dependencies')} Build and export full dependency graph`);
-        output.writeln(`  ${output.highlight('circular')}     Detect circular dependencies in codebase`);
-        output.writeln();
-        output.writeln(output.bold('AST Analysis Examples:'));
-        output.writeln();
-        output.writeln(`  ${output.dim('claude-flow analyze ast src/')}                  # Full AST analysis`);
-        output.writeln(`  ${output.dim('claude-flow analyze ast src/index.ts -c')}       # Include complexity`);
-        output.writeln(`  ${output.dim('claude-flow analyze complexity src/ -t 15')}     # Flag high complexity`);
-        output.writeln(`  ${output.dim('claude-flow analyze symbols src/ --type fn')}    # Extract functions`);
-        output.writeln(`  ${output.dim('claude-flow analyze imports src/ --external')}   # Only npm imports`);
-        output.writeln();
-        output.writeln(output.bold('Graph Analysis Examples:'));
-        output.writeln();
-        output.writeln(`  ${output.dim('claude-flow analyze boundaries src/')}            # Find natural code boundaries`);
-        output.writeln(`  ${output.dim('claude-flow analyze modules src/')}               # Detect module communities`);
-        output.writeln(`  ${output.dim('claude-flow analyze dependencies -f dot src/')}   # Export to DOT format`);
-        output.writeln(`  ${output.dim('claude-flow analyze circular src/')}              # Find circular deps`);
-        output.writeln();
-        output.writeln(output.bold('Diff Analysis Examples:'));
-        output.writeln();
-        output.writeln(`  ${output.dim('claude-flow analyze diff --risk')}              # Risk assessment`);
-        output.writeln(`  ${output.dim('claude-flow analyze diff HEAD~1 --classify')}   # Classify changes`);
-        output.writeln(`  ${output.dim('claude-flow analyze diff main..feature')}       # Compare branches`);
-        output.writeln();
-        return { success: true };
-    },
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            // If no subcommand, show help
+            output.writeln();
+            output.writeln(output.bold('Analyze Commands'));
+            output.writeln(output.dim('-'.repeat(50)));
+            output.writeln();
+            output.writeln(output.bold('Available subcommands:'));
+            output.writeln();
+            output.writeln("  " + output.highlight('diff') + "         Analyze git diff for change risk and classification");
+            output.writeln("  " + output.highlight('code') + "         Static code analysis and quality assessment");
+            output.writeln("  " + output.highlight('deps') + "         Analyze project dependencies");
+            output.writeln("  " + output.highlight('ast') + "          AST analysis with symbol extraction and complexity");
+            output.writeln("  " + output.highlight('complexity') + "   Analyze cyclomatic and cognitive complexity");
+            output.writeln("  " + output.highlight('symbols') + "      Extract functions, classes, and types");
+            output.writeln("  " + output.highlight('imports') + "      Analyze import dependencies");
+            output.writeln("  " + output.highlight('boundaries') + "   Find code boundaries using MinCut algorithm");
+            output.writeln("  " + output.highlight('modules') + "      Detect module communities using Louvain algorithm");
+            output.writeln("  " + output.highlight('dependencies') + " Build and export full dependency graph");
+            output.writeln("  " + output.highlight('circular') + "     Detect circular dependencies in codebase");
+            output.writeln();
+            output.writeln(output.bold('AST Analysis Examples:'));
+            output.writeln();
+            output.writeln("  " + output.dim('claude-flow analyze ast src/') + "                  # Full AST analysis");
+            output.writeln("  " + output.dim('claude-flow analyze ast src/index.ts -c') + "       # Include complexity");
+            output.writeln("  " + output.dim('claude-flow analyze complexity src/ -t 15') + "     # Flag high complexity");
+            output.writeln("  " + output.dim('claude-flow analyze symbols src/ --type fn') + "    # Extract functions");
+            output.writeln("  " + output.dim('claude-flow analyze imports src/ --external') + "   # Only npm imports");
+            output.writeln();
+            output.writeln(output.bold('Graph Analysis Examples:'));
+            output.writeln();
+            output.writeln("  " + output.dim('claude-flow analyze boundaries src/') + "            # Find natural code boundaries");
+            output.writeln("  " + output.dim('claude-flow analyze modules src/') + "               # Detect module communities");
+            output.writeln("  " + output.dim('claude-flow analyze dependencies -f dot src/') + "   # Export to DOT format");
+            output.writeln("  " + output.dim('claude-flow analyze circular src/') + "              # Find circular deps");
+            output.writeln();
+            output.writeln(output.bold('Diff Analysis Examples:'));
+            output.writeln();
+            output.writeln("  " + output.dim('claude-flow analyze diff --risk') + "              # Risk assessment");
+            output.writeln("  " + output.dim('claude-flow analyze diff HEAD~1 --classify') + "   # Classify changes");
+            output.writeln("  " + output.dim('claude-flow analyze diff main..feature') + "       # Compare branches");
+            output.writeln();
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 export default analyzeCommand;
 //# sourceMappingURL=analyze.js.map