kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/analyze.js

@@ -13,53 +13,6 @@
  *
  * 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';
@@ -67,43 +20,25 @@ import * as fs from 'fs/promises';
 import { writeFile } from 'fs/promises';
 import { resolve } from 'path';
 // Dynamic import for AST analyzer
-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*/];
-            }
-        });
-    });
+async function getASTAnalyzer() {
+    try {
+        return await import('../ruvector/ast-analyzer.js');
+    }
+    catch {
+        return null;
+    }
 }
 // Dynamic import for graph analyzer
-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*/];
-            }
-        });
-    });
+async function getGraphAnalyzer() {
+    try {
+        return await import('../ruvector/graph-analyzer.js');
+    }
+    catch {
+        return null;
+    }
 }
 // Diff subcommand
-var diffCommand = {
+const diffCommand = {
     name: 'diff',
     description: 'Analyze git diff for change risk assessment and classification',
     options: [
@@ -112,35 +47,35 @@ var 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: [
@@ -149,201 +84,191 @@ var 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: 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 }];
-                    }
+    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();
-                    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*/];
+                    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) {
+                    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)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Code subcommand (placeholder for future code analysis)
-var codeCommand = {
+const 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: 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 }];
-        });
-    }); }
+    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 };
+    },
 };
 // ============================================================================
 // AST Analysis Subcommands (using ruvector tree-sitter with fallback)
@@ -351,8 +276,7 @@ var codeCommand = {
 /**
  * Helper: Truncate file path for display
  */
-function truncatePathAst(filePath, maxLen) {
-    if (maxLen === void 0) { maxLen = 45; }
+function truncatePathAst(filePath, maxLen = 45) {
     if (filePath.length <= maxLen)
         return filePath;
     return '...' + filePath.slice(-(maxLen - 3));
@@ -395,7 +319,7 @@ function getComplexityRatingAst(value) {
 /**
  * AST analysis subcommand
  */
-var astCommand = {
+const astCommand = {
     name: 'ast',
     description: 'Analyze code using AST parsing (tree-sitter via ruvector)',
     options: [
@@ -404,35 +328,35 @@ var 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: [
@@ -441,223 +365,193 @@ var astCommand = {
         { command: 'claude-flow analyze ast . --format json', description: 'JSON output' },
         { command: 'claude-flow analyze ast src/ --symbols', description: 'Extract symbols' },
     ],
-    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');
-                    }
-                    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 {
-                        // 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));
+    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));
+                        }
                     }
-                    _o.label = 13;
-                case 13:
-                    spinner.stop();
-                    if (results.length === 0) {
-                        output.printWarning('No files analyzed');
-                        return [2 /*return*/, { success: true }];
+                    catch {
+                        // Skip files that can't be analyzed
                     }
-                    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:
+                }
+            }
+            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 {
                     output.printJson(jsonOutput);
-                    _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"));
-                        }
+                }
+                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 });
                     }
-                    // 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"));
-                        }
+                    for (const cls of r.classes) {
+                        allSymbols.push({ name: cls.name, type: 'class', file: truncatePathAst(r.filePath, 30), line: cls.startLine });
                     }
-                    // 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 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);
                     }
-                    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*/];
+                }
+                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}`);
             }
-        });
-    }); }
+            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
  */
-var complexityAstCommand = {
+const complexityAstCommand = {
     name: 'complexity',
     aliases: ['cx'],
     description: 'Analyze code complexity metrics',
@@ -667,82 +561,55 @@ var 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: 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;
+    action: async (ctx) => {
+        const targetPath = ctx.args[0] || ctx.cwd;
+        const threshold = ctx.flags.threshold || 10;
+        const formatType = ctx.flags.format || 'text';
+        const outputFile = ctx.flags.output;
+        output.printInfo(`Analyzing complexity: ${output.highlight(targetPath)}`);
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Calculating complexity...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const astModule = await getASTAnalyzer();
+            const resolvedPath = resolve(targetPath);
+            const stat = await fs.stat(resolvedPath);
+            const files = stat.isDirectory() ? await scanSourceFiles(resolvedPath) : [resolvedPath];
+            const results = [];
+            for (const file of files.slice(0, 100)) {
+                try {
+                    const content = await fs.readFile(file, 'utf-8');
+                    let analysis;
                     if (astModule) {
-                        analyzer = astModule.createASTAnalyzer();
+                        const analyzer = astModule.createASTAnalyzer();
                         analysis = analyzer.analyze(content, file);
                     }
                     else {
                         analysis = fallbackAnalyze(content, file);
                     }
-                    flagged = analysis.complexity.cyclomatic > threshold;
-                    rating = analysis.complexity.cyclomatic <= 5 ? 'Simple' :
+                    const flagged = analysis.complexity.cyclomatic > threshold;
+                    const rating = analysis.complexity.cyclomatic <= 5 ? 'Simple' :
                         analysis.complexity.cyclomatic <= 10 ? 'Moderate' :
                             analysis.complexity.cyclomatic <= 20 ? 'Complex' : 'Very Complex';
                     results.push({
@@ -751,100 +618,91 @@ var complexityAstCommand = {
                         cognitive: analysis.complexity.cognitive,
                         loc: analysis.complexity.loc,
                         commentDensity: analysis.complexity.commentDensity,
-                        rating: rating,
-                        flagged: flagged
+                        rating,
+                        flagged,
                     });
-                    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:
+                }
+                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 {
                     output.printJson(jsonOutput);
-                    _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: 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}`);
+            }
+            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
  */
-var symbolsCommand = {
+const symbolsCommand = {
     name: 'symbols',
     aliases: ['sym'],
     description: 'Extract and list code symbols (functions, classes, types)',
@@ -854,22 +712,22 @@ var 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: [
@@ -877,152 +735,115 @@ var symbolsCommand = {
         { command: 'claude-flow analyze symbols src/ --type function', description: 'Only functions' },
         { command: 'claude-flow analyze symbols src/ --format json', description: 'JSON output' },
     ],
-    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;
+    action: async (ctx) => {
+        const targetPath = ctx.args[0] || ctx.cwd;
+        const symbolType = ctx.flags.type || 'all';
+        const formatType = ctx.flags.format || 'text';
+        const outputFile = ctx.flags.output;
+        output.printInfo(`Extracting symbols: ${output.highlight(targetPath)}`);
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Parsing code...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const astModule = await getASTAnalyzer();
+            const resolvedPath = resolve(targetPath);
+            const stat = await fs.stat(resolvedPath);
+            const files = stat.isDirectory() ? await scanSourceFiles(resolvedPath) : [resolvedPath];
+            const symbols = [];
+            for (const file of files.slice(0, 100)) {
+                try {
+                    const content = await fs.readFile(file, 'utf-8');
+                    let analysis;
                     if (astModule) {
-                        analyzer = astModule.createASTAnalyzer();
+                        const analyzer = astModule.createASTAnalyzer();
                         analysis = analyzer.analyze(content, file);
                     }
                     else {
                         analysis = fallbackAnalyze(content, file);
                     }
                     if (symbolType === 'all' || symbolType === 'function') {
-                        for (_c = 0, _d = analysis.functions; _c < _d.length; _c++) {
-                            fn = _d[_c];
+                        for (const fn of analysis.functions) {
                             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 (_e = 0, _f = analysis.classes; _e < _f.length; _e++) {
-                            cls = _f[_e];
+                        for (const cls of analysis.classes) {
                             symbols.push({
                                 name: cls.name,
                                 type: 'class',
-                                file: file,
+                                file,
                                 startLine: cls.startLine,
-                                endLine: cls.endLine
+                                endLine: cls.endLine,
                             });
                         }
                     }
-                    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:
+                }
+                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 {
                     output.printJson(symbols);
-                    _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 };
+            }
+            // 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}`);
+            }
+            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
  */
-var importsCommand = {
+const importsCommand = {
     name: 'imports',
     aliases: ['imp'],
     description: 'Analyze import dependencies across files',
@@ -1032,357 +853,275 @@ var 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: 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;
+    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;
                     if (astModule) {
-                        analyzer = astModule.createASTAnalyzer();
+                        const analyzer = astModule.createASTAnalyzer();
                         analysis = analyzer.analyze(content, file);
                     }
                     else {
                         analysis = fallbackAnalyze(content, file);
                     }
-                    imports = analysis.imports.filter(function (imp) {
+                    const imports = analysis.imports.filter(imp => {
                         if (externalOnly) {
                             return !imp.startsWith('.') && !imp.startsWith('/');
                         }
                         return true;
                     });
                     fileImports.set(file, imports);
-                    for (_c = 0, imports_1 = imports; _c < imports_1.length; _c++) {
-                        imp = imports_1[_c];
-                        existing = importCounts.get(imp) || { count: 0, files: [] };
+                    for (const imp of imports) {
+                        const existing = importCounts.get(imp) || { count: 0, files: [] };
                         existing.count++;
                         existing.files.push(file);
                         importCounts.set(imp, existing);
                     }
-                    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:
+                }
+                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 {
                     output.printJson(jsonOutput);
-                    _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: 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}`);
+            }
+            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
  */
-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*/];
+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);
                     }
-                });
-            });
-        }
-        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];
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name);
+                    if (extensions.includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
             }
-        });
-    });
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    await scan(dir, 0);
+    return files;
 }
 /**
  * Fallback analysis when ruvector is not available
  */
 function fallbackAnalyze(code, filePath) {
-    var lines = code.split('\n');
-    var functions = [];
-    var classes = [];
-    var imports = [];
-    var exports = [];
+    const lines = code.split('\n');
+    const functions = [];
+    const classes = [];
+    const imports = [];
+    const exports = [];
     // Extract functions
-    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;
+    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;
     while ((match = funcPattern.exec(code)) !== null) {
-        var name = match[1] || match[2] || match[3];
+        const name = match[1] || match[2] || match[3];
         if (name && !['if', 'while', 'for', 'switch'].includes(name)) {
-            var lineNum = code.substring(0, match.index).split('\n').length;
-            functions.push({ name: name, startLine: lineNum, endLine: lineNum + 10 });
+            const lineNum = code.substring(0, match.index).split('\n').length;
+            functions.push({ name, startLine: lineNum, endLine: lineNum + 10 });
         }
     }
     // Extract classes
-    var classPattern = /(?:export\s+)?class\s+(\w+)/gm;
+    const classPattern = /(?:export\s+)?class\s+(\w+)/gm;
     while ((match = classPattern.exec(code)) !== null) {
-        var lineNum = code.substring(0, match.index).split('\n').length;
+        const lineNum = code.substring(0, match.index).split('\n').length;
         classes.push({ name: match[1], startLine: lineNum, endLine: lineNum + 20 });
     }
     // Extract imports
-    var importPattern = /import\s+(?:.*\s+from\s+)?['"]([^'"]+)['"]/gm;
+    const importPattern = /import\s+(?:.*\s+from\s+)?['"]([^'"]+)['"]/gm;
     while ((match = importPattern.exec(code)) !== null) {
         imports.push(match[1]);
     }
-    var requirePattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm;
+    const requirePattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm;
     while ((match = requirePattern.exec(code)) !== null) {
         imports.push(match[1]);
     }
     // Extract exports
-    var exportPattern = /export\s+(?:default\s+)?(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/gm;
+    const 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
-    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;
+    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;
         if (/\b(if|for|while|switch)\b/.test(line)) {
             cognitive += 1 + nestingLevel;
         }
         nestingLevel = Math.max(0, nestingLevel + opens - closes);
     }
     // Detect language
-    var ext = path.extname(filePath).toLowerCase();
-    var language = ext === '.ts' || ext === '.tsx' ? 'typescript' :
+    const ext = path.extname(filePath).toLowerCase();
+    const language = ext === '.ts' || ext === '.tsx' ? 'typescript' :
         ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs' ? 'javascript' :
             ext === '.py' ? 'python' : 'unknown';
     return {
-        filePath: filePath,
-        language: language,
-        functions: functions,
-        classes: classes,
-        imports: imports,
-        exports: exports,
+        filePath,
+        language,
+        functions,
+        classes,
+        imports,
+        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
-var depsCommand = {
+const 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: 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 }];
-        });
-    }); }
+    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 };
+    },
 };
 // ============================================================================
 // Graph Analysis Subcommands (MinCut, Louvain, Circular Dependencies)
@@ -1390,7 +1129,7 @@ var depsCommand = {
 /**
  * Analyze code boundaries using MinCut algorithm
  */
-var boundariesCommand = {
+const boundariesCommand = {
     name: 'boundaries',
     aliases: ['boundary', 'mincut'],
     description: 'Find natural code boundaries using MinCut algorithm',
@@ -1400,21 +1139,21 @@ var 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: [
@@ -1422,145 +1161,127 @@ var 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: 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:
+    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 {
                     output.printJson(jsonOutput);
-                    _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);
+                }
+                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}`);
                     output.writeln(output.dim('Visualize with: dot -Tpng -o graph.png ' + outputFile));
-                    return [3 /*break*/, 10];
-                case 9:
+                }
+                else {
                     output.writeln(dotOutput);
-                    _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();
-                        }
+                }
+                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`));
                     }
-                    // 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.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`));
                     }
-                    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*/];
+                    output.writeln();
+                    output.writeln(output.success('Suggestion:'));
+                    output.writeln(`  ${boundary.suggestion}`);
+                    output.writeln();
+                }
             }
-        });
-    }); }
+            // Show circular dependencies
+            if (result.circularDependencies.length > 0) {
+                output.writeln();
+                output.writeln(output.bold(output.warning('Circular Dependencies Detected')));
+                output.writeln();
+                for (const cycle of result.circularDependencies.slice(0, 5)) {
+                    const severityColor = cycle.severity === 'high' ? output.error : cycle.severity === 'medium' ? output.warning : output.dim;
+                    output.writeln(`${severityColor(`[${cycle.severity.toUpperCase()}]`)} ${cycle.cycle.join(' -> ')}`);
+                    output.writeln(output.dim(`  ${cycle.suggestion}`));
+                    output.writeln();
+                }
+                if (result.circularDependencies.length > 5) {
+                    output.writeln(output.dim(`... and ${result.circularDependencies.length - 5} more cycles`));
+                }
+            }
+            if (outputFile) {
+                await 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
  */
-var modulesCommand = {
+const modulesCommand = {
     name: 'modules',
     aliases: ['communities', 'louvain'],
     description: 'Detect module communities using Louvain algorithm',
@@ -1569,22 +1290,22 @@ var 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: [
@@ -1592,128 +1313,109 @@ var 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: 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:
+    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 {
                     output.printJson(jsonOutput);
-                    _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);
+                }
+                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}`);
                     output.writeln(output.dim('Visualize with: dot -Tpng -o modules.png ' + outputFile));
-                    return [3 /*break*/, 10];
-                case 9:
+                }
+                else {
                     output.writeln(dotOutput);
-                    _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"));
-                        }
+                }
+                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`));
                     }
-                    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*/];
+                    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}`);
             }
-        });
-    }); }
+            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
  */
-var dependenciesCommand = {
+const dependenciesCommand = {
     name: 'dependencies',
     aliases: ['graph'],
     description: 'Build and export full dependency graph',
@@ -1722,36 +1424,36 @@ var 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: [
@@ -1759,152 +1461,138 @@ var 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: 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:
+    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 {
                     output.printJson(jsonOutput);
-                    _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);
+                }
+                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}`);
                     output.writeln(output.dim('Visualize with: dot -Tpng -o deps.png ' + outputFile));
-                    return [3 /*break*/, 10];
-                case 9:
+                }
+                else {
                     output.writeln(dotOutput);
-                    _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 };
+            }
+            // 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}`);
             }
-        });
-    }); }
+            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
  */
-var circularCommand = {
+const circularCommand = {
     name: 'circular',
     aliases: ['cycles'],
     description: 'Detect circular dependencies in codebase',
@@ -1913,127 +1601,111 @@ var 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: 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();
-                    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:
+    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);
-                    _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');
+                }
+                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}`));
                     output.writeln();
-                    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*/];
+                }
+                if (items.length > 5) {
+                    output.writeln(output.dim(`  ... and ${items.length - 5} more ${severity} cycles`));
+                    output.writeln();
+                }
+            }
+            if (outputFile) {
+                await writeFile(outputFile, JSON.stringify({ cycles: filtered }, null, 2));
+                output.printSuccess(`Results written to ${outputFile}`);
             }
-        });
-    }); }
+            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) {
@@ -2065,7 +1737,7 @@ function getStatusDisplay(status) {
     }
 }
 // Main analyze command
-export var analyzeCommand = {
+export const analyzeCommand = {
     name: 'analyze',
     description: 'Code analysis, diff classification, graph boundaries, and change risk assessment',
     aliases: ['an'],
@@ -2088,7 +1760,7 @@ export var analyzeCommand = {
             short: 'f',
             description: 'Output format: text, json, table',
             type: 'string',
-            "default": 'text'
+            default: 'text',
         },
     ],
     examples: [
@@ -2103,51 +1775,49 @@ export var analyzeCommand = {
         { command: 'claude-flow analyze circular src/', description: 'Find circular dependencies' },
         { command: 'claude-flow analyze deps --security', description: 'Check dependency vulnerabilities' },
     ],
-    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 }];
-        });
-    }); }
+    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 };
+    },
 };
 export default analyzeCommand;
 //# sourceMappingURL=analyze.js.map