kynjal-cli 3.1.3 → 4.0.0

package/dist/src/mcp-tools/progress-tools.js

@@ -5,55 +5,93 @@
  *
  * @module @claude-flow/cli/mcp-tools/progress
  */
+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 { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, basename, dirname } from 'path';
 import { fileURLToPath } from 'url';
 // Get project root - handles both src and dist paths
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
 // From dist/src/mcp-tools or src/mcp-tools, navigate to v3 directory
 // CLI is at v3/@claude-flow/cli, so go up 2 levels from cli to get to v3
-const CLI_ROOT = join(__dirname, '../../..');
-const CLAUDE_FLOW_DIR = join(CLI_ROOT, '..'); // @claude-flow directory
-const V3_DIR = join(CLAUDE_FLOW_DIR, '..'); // v3 directory
-const PROJECT_ROOT = join(V3_DIR, '..');
+var CLI_ROOT = join(__dirname, '../../..');
+var CLAUDE_FLOW_DIR = join(CLI_ROOT, '..'); // @claude-flow directory
+var V3_DIR = join(CLAUDE_FLOW_DIR, '..'); // v3 directory
+var PROJECT_ROOT = join(V3_DIR, '..');
 // Utility/service packages follow DDD differently - their services ARE the application layer
-const UTILITY_PACKAGES = new Set([
+var UTILITY_PACKAGES = new Set([
     'cli', 'hooks', 'mcp', 'shared', 'testing', 'agents', 'integration',
     'embeddings', 'deployment', 'performance', 'plugins', 'providers'
 ]);
 // Target metrics for 100% completion
-const TARGETS = {
+var TARGETS = {
     CLI_COMMANDS: 28,
     MCP_TOOLS: 100,
-    HOOKS_SUBCOMMANDS: 27, // 27 hooks documented in CLAUDE.md
-    PACKAGES: 17,
+    HOOKS_SUBCOMMANDS: 27,
+    PACKAGES: 17
 };
 // Weight distribution for overall progress
-const WEIGHTS = {
+var WEIGHTS = {
     CLI: 0.25,
     MCP: 0.25,
     HOOKS: 0.20,
     PACKAGES: 0.15,
-    DDD: 0.15,
+    DDD: 0.15
 };
-function countFilesAndLines(dir, ext = '.ts') {
-    let files = 0;
-    let lines = 0;
+function countFilesAndLines(dir, ext) {
+    if (ext === void 0) { ext = '.ts'; }
+    var files = 0;
+    var lines = 0;
     function walk(currentDir) {
         if (!existsSync(currentDir))
             return;
         try {
-            const entries = readdirSync(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = join(currentDir, entry.name);
+            var entries = readdirSync(currentDir, { withFileTypes: true });
+            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+                var entry = entries_1[_i];
+                var fullPath = join(currentDir, entry.name);
                 if (entry.isDirectory() && !entry.name.includes('node_modules') && !entry.name.startsWith('.')) {
                     walk(fullPath);
                 }
                 else if (entry.isFile() && entry.name.endsWith(ext)) {
                     files++;
                     try {
-                        const content = readFileSync(fullPath, 'utf-8');
+                        var content = readFileSync(fullPath, 'utf-8');
                         lines += content.split('\n').length;
                     }
                     catch (_e) { /* ignore */ }
@@ -63,17 +101,17 @@ function countFilesAndLines(dir, ext = '.ts') {
         catch (_e) { /* ignore */ }
     }
     walk(dir);
-    return { files, lines };
+    return { files: files, lines: lines };
 }
 function calculateModuleProgress(moduleDir) {
     if (!existsSync(moduleDir))
         return 0;
-    const moduleName = basename(moduleDir);
+    var moduleName = basename(moduleDir);
     // Utility packages are 100% complete by design
     if (UTILITY_PACKAGES.has(moduleName)) {
         return 100;
     }
-    let progress = 0;
+    var progress = 0;
     // Check for DDD structure
     if (existsSync(join(moduleDir, 'src/domain')))
         progress += 30;
@@ -89,139 +127,146 @@ function calculateModuleProgress(moduleDir) {
         progress += 10;
     return Math.min(progress, 100);
 }
-async function calculateProgress() {
-    const now = new Date().toISOString();
-    // Count V3 modules
-    const modulesDir = join(V3_DIR, '@claude-flow');
-    const modules = [];
-    let totalProgress = 0;
-    let explicitDDD = 0;
-    let utilityDDD = 0;
-    if (existsSync(modulesDir)) {
-        const entries = readdirSync(modulesDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory() && !entry.name.startsWith('.')) {
-                const moduleDir = join(modulesDir, entry.name);
-                const { files, lines } = countFilesAndLines(moduleDir);
-                const progress = calculateModuleProgress(moduleDir);
-                modules.push({ name: entry.name, files, lines, progress });
-                totalProgress += progress;
-                if (UTILITY_PACKAGES.has(entry.name)) {
-                    utilityDDD++;
+function calculateProgress() {
+    return __awaiter(this, void 0, Promise, function () {
+        var now, modulesDir, modules, totalProgress, explicitDDD, utilityDDD, entries, _i, entries_2, entry, moduleDir, _a, files, lines, progress, avgProgress, totalStats, cliCommands, commandsIndexPath, content, matches, mcpTools, toolsIndexPath, content, hooksSubcommands, hooksPath, content, commandDefs, cliProgress, mcpProgress, hooksProgress, packagesProgress, overall;
+        return __generator(this, function (_b) {
+            now = new Date().toISOString();
+            modulesDir = join(V3_DIR, '@claude-flow');
+            modules = [];
+            totalProgress = 0;
+            explicitDDD = 0;
+            utilityDDD = 0;
+            if (existsSync(modulesDir)) {
+                entries = readdirSync(modulesDir, { withFileTypes: true });
+                for (_i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
+                    entry = entries_2[_i];
+                    if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                        moduleDir = join(modulesDir, entry.name);
+                        _a = countFilesAndLines(moduleDir), files = _a.files, lines = _a.lines;
+                        progress = calculateModuleProgress(moduleDir);
+                        modules.push({ name: entry.name, files: files, lines: lines, progress: progress });
+                        totalProgress += progress;
+                        if (UTILITY_PACKAGES.has(entry.name)) {
+                            utilityDDD++;
+                        }
+                        else if (progress >= 60) {
+                            explicitDDD++;
+                        }
+                    }
                 }
-                else if (progress >= 60) {
-                    explicitDDD++;
+            }
+            avgProgress = modules.length > 0 ? Math.round(totalProgress / modules.length) : 0;
+            totalStats = countFilesAndLines(V3_DIR);
+            cliCommands = 28;
+            commandsIndexPath = join(V3_DIR, '@claude-flow/cli/src/commands/index.ts');
+            if (existsSync(commandsIndexPath)) {
+                try {
+                    content = readFileSync(commandsIndexPath, 'utf-8');
+                    matches = content.match(/export const commands.*\[([^\]]+)\]/s);
+                    if (matches) {
+                        cliCommands = (matches[1].match(/Command/g) || []).length || 28;
+                    }
                 }
+                catch (_e) { /* ignore */ }
             }
-        }
-    }
-    const avgProgress = modules.length > 0 ? Math.round(totalProgress / modules.length) : 0;
-    const totalStats = countFilesAndLines(V3_DIR);
-    // Count CLI commands (from commands/index.ts)
-    let cliCommands = 28; // Default to known count
-    const commandsIndexPath = join(V3_DIR, '@claude-flow/cli/src/commands/index.ts');
-    if (existsSync(commandsIndexPath)) {
-        try {
-            const content = readFileSync(commandsIndexPath, 'utf-8');
-            const matches = content.match(/export const commands.*\[([^\]]+)\]/s);
-            if (matches) {
-                cliCommands = (matches[1].match(/Command/g) || []).length || 28;
+            mcpTools = 100;
+            toolsIndexPath = join(V3_DIR, '@claude-flow/cli/src/mcp-tools/index.ts');
+            if (existsSync(toolsIndexPath)) {
+                try {
+                    content = readFileSync(toolsIndexPath, 'utf-8');
+                    mcpTools = (content.match(/export.*Tools/g) || []).length * 10 || 100;
+                }
+                catch (_e) { /* ignore */ }
             }
-        }
-        catch (_e) { /* ignore */ }
-    }
-    // Count MCP tools
-    let mcpTools = 100; // Approximate
-    const toolsIndexPath = join(V3_DIR, '@claude-flow/cli/src/mcp-tools/index.ts');
-    if (existsSync(toolsIndexPath)) {
-        try {
-            const content = readFileSync(toolsIndexPath, 'utf-8');
-            mcpTools = (content.match(/export.*Tools/g) || []).length * 10 || 100;
-        }
-        catch (_e) { /* ignore */ }
-    }
-    // Count hooks subcommands (count const *Command definitions)
-    let hooksSubcommands = 27; // Default to documented count
-    const hooksPath = join(V3_DIR, '@claude-flow/cli/src/commands/hooks.ts');
-    if (existsSync(hooksPath)) {
-        try {
-            const content = readFileSync(hooksPath, 'utf-8');
-            // Count command definitions like "const fooCommand: Command = {"
-            const commandDefs = content.match(/const\s+\w+Command\s*:\s*Command\s*=/g);
-            if (commandDefs && commandDefs.length > 0) {
-                hooksSubcommands = commandDefs.length;
+            hooksSubcommands = 27;
+            hooksPath = join(V3_DIR, '@claude-flow/cli/src/commands/hooks.ts');
+            if (existsSync(hooksPath)) {
+                try {
+                    content = readFileSync(hooksPath, 'utf-8');
+                    commandDefs = content.match(/const\s+\w+Command\s*:\s*Command\s*=/g);
+                    if (commandDefs && commandDefs.length > 0) {
+                        hooksSubcommands = commandDefs.length;
+                    }
+                }
+                catch (_e) { /* ignore */ }
             }
-        }
-        catch (_e) { /* ignore */ }
-    }
-    // Calculate component progress
-    const cliProgress = Math.min(100, Math.round((cliCommands / TARGETS.CLI_COMMANDS) * 100));
-    const mcpProgress = Math.min(100, Math.round((mcpTools / TARGETS.MCP_TOOLS) * 100));
-    const hooksProgress = Math.min(100, Math.round((hooksSubcommands / TARGETS.HOOKS_SUBCOMMANDS) * 100));
-    const packagesProgress = Math.min(100, Math.round((modules.length / TARGETS.PACKAGES) * 100));
-    // Calculate overall weighted progress
-    const overall = Math.round(cliProgress * WEIGHTS.CLI +
-        mcpProgress * WEIGHTS.MCP +
-        hooksProgress * WEIGHTS.HOOKS +
-        packagesProgress * WEIGHTS.PACKAGES +
-        avgProgress * WEIGHTS.DDD);
-    return {
-        overall,
-        cli: { commands: cliCommands, target: TARGETS.CLI_COMMANDS, progress: cliProgress },
-        mcp: { tools: mcpTools, target: TARGETS.MCP_TOOLS, progress: mcpProgress },
-        hooks: { subcommands: hooksSubcommands, target: TARGETS.HOOKS_SUBCOMMANDS, progress: hooksProgress },
-        packages: {
-            total: modules.length,
-            withDDD: explicitDDD + utilityDDD,
-            target: TARGETS.PACKAGES,
-            progress: packagesProgress,
-            list: modules.map(m => m.name),
-        },
-        ddd: { explicit: explicitDDD, utility: utilityDDD, progress: avgProgress },
-        codebase: { totalFiles: totalStats.files, totalLines: totalStats.lines },
-        lastUpdated: now,
-        source: 'V3ProgressService',
-    };
+            cliProgress = Math.min(100, Math.round((cliCommands / TARGETS.CLI_COMMANDS) * 100));
+            mcpProgress = Math.min(100, Math.round((mcpTools / TARGETS.MCP_TOOLS) * 100));
+            hooksProgress = Math.min(100, Math.round((hooksSubcommands / TARGETS.HOOKS_SUBCOMMANDS) * 100));
+            packagesProgress = Math.min(100, Math.round((modules.length / TARGETS.PACKAGES) * 100));
+            overall = Math.round(cliProgress * WEIGHTS.CLI +
+                mcpProgress * WEIGHTS.MCP +
+                hooksProgress * WEIGHTS.HOOKS +
+                packagesProgress * WEIGHTS.PACKAGES +
+                avgProgress * WEIGHTS.DDD);
+            return [2 /*return*/, {
+                    overall: overall,
+                    cli: { commands: cliCommands, target: TARGETS.CLI_COMMANDS, progress: cliProgress },
+                    mcp: { tools: mcpTools, target: TARGETS.MCP_TOOLS, progress: mcpProgress },
+                    hooks: { subcommands: hooksSubcommands, target: TARGETS.HOOKS_SUBCOMMANDS, progress: hooksProgress },
+                    packages: {
+                        total: modules.length,
+                        withDDD: explicitDDD + utilityDDD,
+                        target: TARGETS.PACKAGES,
+                        progress: packagesProgress,
+                        list: modules.map(function (m) { return m.name; })
+                    },
+                    ddd: { explicit: explicitDDD, utility: utilityDDD, progress: avgProgress },
+                    codebase: { totalFiles: totalStats.files, totalLines: totalStats.lines },
+                    lastUpdated: now,
+                    source: 'V3ProgressService'
+                }];
+        });
+    });
 }
-async function syncProgress() {
-    const metrics = await calculateProgress();
-    // Persist to file
-    const metricsDir = join(PROJECT_ROOT, '.claude-flow/metrics');
-    if (!existsSync(metricsDir)) {
-        mkdirSync(metricsDir, { recursive: true });
-    }
-    const outputPath = join(metricsDir, 'v3-progress.json');
-    writeFileSync(outputPath, JSON.stringify({
-        domains: { completed: Math.floor(metrics.packages.withDDD / 3), total: 5 },
-        ddd: {
-            progress: metrics.ddd.progress,
-            modules: metrics.packages.total,
-            totalFiles: metrics.codebase.totalFiles,
-            totalLines: metrics.codebase.totalLines,
-        },
-        swarm: { activeAgents: 0, totalAgents: 15 },
-        lastUpdated: metrics.lastUpdated,
-        source: 'V3ProgressService',
-    }, null, 2));
-    return metrics;
+function syncProgress() {
+    return __awaiter(this, void 0, Promise, function () {
+        var metrics, metricsDir, outputPath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, calculateProgress()];
+                case 1:
+                    metrics = _a.sent();
+                    metricsDir = join(PROJECT_ROOT, '.claude-flow/metrics');
+                    if (!existsSync(metricsDir)) {
+                        mkdirSync(metricsDir, { recursive: true });
+                    }
+                    outputPath = join(metricsDir, 'v3-progress.json');
+                    writeFileSync(outputPath, JSON.stringify({
+                        domains: { completed: Math.floor(metrics.packages.withDDD / 3), total: 5 },
+                        ddd: {
+                            progress: metrics.ddd.progress,
+                            modules: metrics.packages.total,
+                            totalFiles: metrics.codebase.totalFiles,
+                            totalLines: metrics.codebase.totalLines
+                        },
+                        swarm: { activeAgents: 0, totalAgents: 15 },
+                        lastUpdated: metrics.lastUpdated,
+                        source: 'V3ProgressService'
+                    }, null, 2));
+                    return [2 /*return*/, metrics];
+            }
+        });
+    });
 }
 function getSummary(metrics) {
-    const lines = [
+    var lines = [
         '═══════════════════════════════════════════════════',
         '           V3 Implementation Progress',
         '═══════════════════════════════════════════════════',
         '',
-        `  Overall Progress: ${metrics.overall}%`,
+        "  Overall Progress: " + metrics.overall + "%",
         '',
-        `  CLI Commands:     ${metrics.cli.progress}% (${metrics.cli.commands}/${metrics.cli.target})`,
-        `  MCP Tools:        ${metrics.mcp.progress}% (${metrics.mcp.tools}/${metrics.mcp.target})`,
-        `  Hooks:            ${metrics.hooks.progress}% (${metrics.hooks.subcommands}/${metrics.hooks.target})`,
-        `  Packages:         ${metrics.packages.progress}% (${metrics.packages.total}/${metrics.packages.target})`,
-        `  DDD Structure:    ${metrics.ddd.progress}%`,
+        "  CLI Commands:     " + metrics.cli.progress + "% (" + metrics.cli.commands + "/" + metrics.cli.target + ")",
+        "  MCP Tools:        " + metrics.mcp.progress + "% (" + metrics.mcp.tools + "/" + metrics.mcp.target + ")",
+        "  Hooks:            " + metrics.hooks.progress + "% (" + metrics.hooks.subcommands + "/" + metrics.hooks.target + ")",
+        "  Packages:         " + metrics.packages.progress + "% (" + metrics.packages.total + "/" + metrics.packages.target + ")",
+        "  DDD Structure:    " + metrics.ddd.progress + "%",
         '',
-        `  Codebase: ${metrics.codebase.totalFiles} files, ${metrics.codebase.totalLines.toLocaleString()} lines`,
+        "  Codebase: " + metrics.codebase.totalFiles + " files, " + metrics.codebase.totalLines.toLocaleString() + " lines",
         '',
-        `  Last Updated: ${metrics.lastUpdated}`,
+        "  Last Updated: " + metrics.lastUpdated,
         '═══════════════════════════════════════════════════',
     ];
     return lines.join('\n');
@@ -229,7 +274,7 @@ function getSummary(metrics) {
 /**
  * progress/check - Get current V3 implementation progress
  */
-const progressCheck = {
+var progressCheck = {
     name: 'progress_check',
     description: 'Get current V3 implementation progress percentage and metrics',
     inputSchema: {
@@ -237,82 +282,104 @@ const progressCheck = {
         properties: {
             detailed: {
                 type: 'boolean',
-                description: 'Include detailed breakdown by category',
-            },
+                description: 'Include detailed breakdown by category'
+            }
         },
-        required: [],
-    },
-    handler: async (params) => {
-        const detailed = params.detailed;
-        const metrics = await calculateProgress();
-        if (detailed) {
-            return {
-                overall: metrics.overall,
-                cli: metrics.cli,
-                mcp: metrics.mcp,
-                hooks: metrics.hooks,
-                packages: metrics.packages,
-                ddd: metrics.ddd,
-                codebase: metrics.codebase,
-                lastUpdated: metrics.lastUpdated,
-            };
-        }
-        return {
-            progress: metrics.overall,
-            summary: `V3 Implementation: ${metrics.overall}% complete`,
-            breakdown: {
-                cli: `${metrics.cli.progress}%`,
-                mcp: `${metrics.mcp.progress}%`,
-                hooks: `${metrics.hooks.progress}%`,
-                packages: `${metrics.packages.progress}%`,
-                ddd: `${metrics.ddd.progress}%`,
-            },
-        };
+        required: []
     },
+    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
+        var detailed, metrics;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    detailed = params.detailed;
+                    return [4 /*yield*/, calculateProgress()];
+                case 1:
+                    metrics = _a.sent();
+                    if (detailed) {
+                        return [2 /*return*/, {
+                                overall: metrics.overall,
+                                cli: metrics.cli,
+                                mcp: metrics.mcp,
+                                hooks: metrics.hooks,
+                                packages: metrics.packages,
+                                ddd: metrics.ddd,
+                                codebase: metrics.codebase,
+                                lastUpdated: metrics.lastUpdated
+                            }];
+                    }
+                    return [2 /*return*/, {
+                            progress: metrics.overall,
+                            summary: "V3 Implementation: " + metrics.overall + "% complete",
+                            breakdown: {
+                                cli: metrics.cli.progress + "%",
+                                mcp: metrics.mcp.progress + "%",
+                                hooks: metrics.hooks.progress + "%",
+                                packages: metrics.packages.progress + "%",
+                                ddd: metrics.ddd.progress + "%"
+                            }
+                        }];
+            }
+        });
+    }); }
 };
 /**
  * progress/sync - Calculate and persist V3 progress
  */
-const progressSync = {
+var progressSync = {
     name: 'progress_sync',
     description: 'Calculate and persist V3 progress metrics to file',
     inputSchema: {
         type: 'object',
         properties: {},
-        required: [],
-    },
-    handler: async () => {
-        const metrics = await syncProgress();
-        return {
-            progress: metrics.overall,
-            message: `Progress synced: ${metrics.overall}%`,
-            persisted: true,
-            lastUpdated: metrics.lastUpdated,
-        };
+        required: []
     },
+    handler: function () { return __awaiter(void 0, void 0, void 0, function () {
+        var metrics;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, syncProgress()];
+                case 1:
+                    metrics = _a.sent();
+                    return [2 /*return*/, {
+                            progress: metrics.overall,
+                            message: "Progress synced: " + metrics.overall + "%",
+                            persisted: true,
+                            lastUpdated: metrics.lastUpdated
+                        }];
+            }
+        });
+    }); }
 };
 /**
  * progress/summary - Get human-readable progress summary
  */
-const progressSummary = {
+var progressSummary = {
     name: 'progress_summary',
     description: 'Get human-readable V3 implementation progress summary',
     inputSchema: {
         type: 'object',
         properties: {},
-        required: [],
-    },
-    handler: async () => {
-        const metrics = await calculateProgress();
-        return {
-            summary: getSummary(metrics),
-        };
+        required: []
     },
+    handler: function () { return __awaiter(void 0, void 0, void 0, function () {
+        var metrics;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, calculateProgress()];
+                case 1:
+                    metrics = _a.sent();
+                    return [2 /*return*/, {
+                            summary: getSummary(metrics)
+                        }];
+            }
+        });
+    }); }
 };
 /**
  * progress/watch - Watch progress (status check)
  */
-const progressWatch = {
+var progressWatch = {
     name: 'progress_watch',
     description: 'Get current watch status for progress monitoring',
     inputSchema: {
@@ -320,25 +387,32 @@ const progressWatch = {
         properties: {
             action: {
                 type: 'string',
-                enum: ['status'],
-                description: 'Action to perform (status only for MCP)',
-            },
+                "enum": ['status'],
+                description: 'Action to perform (status only for MCP)'
+            }
         },
-        required: [],
-    },
-    handler: async () => {
-        const metrics = await calculateProgress();
-        return {
-            hasMetrics: true,
-            lastProgress: metrics.overall,
-            lastUpdated: metrics.lastUpdated,
-        };
+        required: []
     },
+    handler: function () { return __awaiter(void 0, void 0, void 0, function () {
+        var metrics;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, calculateProgress()];
+                case 1:
+                    metrics = _a.sent();
+                    return [2 /*return*/, {
+                            hasMetrics: true,
+                            lastProgress: metrics.overall,
+                            lastUpdated: metrics.lastUpdated
+                        }];
+            }
+        });
+    }); }
 };
 /**
  * All progress tools
  */
-export const progressTools = [
+export var progressTools = [
     progressCheck,
     progressSync,
     progressSummary,