monomind 1.18.9 → 1.18.10

package/packages/@monomind/cli/dist/src/commands/progress.js

@@ -1,261 +0,0 @@
-/**
- * v1 Progress CLI Command
- *
- * Check and manage v1 implementation progress.
- *
- * @module @monoes/cli/commands/progress
- */
-import { output } from '../output.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-function progressBar(percent, width = 20) {
-    const filled = Math.round((percent / 100) * width);
-    const empty = width - filled;
-    const bar = output.success('█'.repeat(filled)) + output.dim('░'.repeat(empty));
-    return `[${bar}] ${percent}%`;
-}
-// Check subcommand
-const checkCommand = {
-    name: 'check',
-    description: 'Check current progress (default)',
-    options: [
-        {
-            name: 'detailed',
-            short: 'd',
-            description: 'Show detailed breakdown',
-            type: 'boolean',
-            default: false,
-        },
-    ],
-    action: async (ctx) => {
-        const detailed = ctx.flags.detailed;
-        const spinner = output.createSpinner({ text: 'Checking v1 progress...' });
-        try {
-            spinner.start();
-            const result = (await callMCPTool('progress_check', { detailed }));
-            spinner.stop();
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            const progressValue = result.overall ?? result.progress ?? 0;
-            output.writeln();
-            output.writeln(output.bold('v1 Implementation Progress'));
-            output.writeln();
-            output.writeln(progressBar(progressValue, 30));
-            output.writeln();
-            if (detailed && result.cli) {
-                output.writeln(output.highlight('CLI Commands:') +
-                    `     ${result.cli.progress}% (${result.cli.commands}/${result.cli.target})`);
-                output.writeln(output.highlight('MCP Tools:') +
-                    `        ${result.mcp?.progress ?? 0}% (${result.mcp?.tools ?? 0}/${result.mcp?.target ?? 0})`);
-                output.writeln(output.highlight('Hooks:') +
-                    `            ${result.hooks?.progress ?? 0}% (${result.hooks?.subcommands ?? 0}/${result.hooks?.target ?? 0})`);
-                output.writeln(output.highlight('Packages:') +
-                    `         ${result.packages?.progress ?? 0}% (${result.packages?.total ?? 0}/${result.packages?.target ?? 0})`);
-                output.writeln(output.highlight('DDD Structure:') +
-                    `    ${result.ddd?.progress ?? 0}% (${result.packages?.withDDD ?? 0}/${result.packages?.total ?? 0})`);
-                output.writeln();
-                if (result.codebase) {
-                    output.writeln(output.dim(`Codebase: ${result.codebase.totalFiles} files, ${result.codebase.totalLines.toLocaleString()} lines`));
-                }
-            }
-            else if (result.breakdown) {
-                output.writeln('Breakdown:');
-                for (const [category, value] of Object.entries(result.breakdown)) {
-                    output.writeln(`  ${output.highlight(category)}: ${value}`);
-                }
-            }
-            if (result.lastUpdated) {
-                output.writeln(output.dim(`Last updated: ${result.lastUpdated}`));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Progress check failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// Sync subcommand
-const syncCommand = {
-    name: 'sync',
-    description: 'Calculate and persist progress',
-    action: async (ctx) => {
-        const spinner = output.createSpinner({ text: 'Syncing progress...' });
-        try {
-            spinner.start();
-            const result = (await callMCPTool('progress_sync', {}));
-            spinner.stop();
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printSuccess(`Progress synced: ${result.progress}%`);
-            output.writeln(output.dim(`  Persisted to .monomind/metrics/v1-progress.json`));
-            output.writeln(output.dim(`  Last updated: ${result.lastUpdated}`));
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Progress sync failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// Summary subcommand
-const summaryCommand = {
-    name: 'summary',
-    description: 'Show human-readable summary',
-    action: async (ctx) => {
-        const spinner = output.createSpinner({ text: 'Getting progress summary...' });
-        try {
-            spinner.start();
-            const result = (await callMCPTool('progress_summary', {}));
-            spinner.stop();
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(result.summary ?? '');
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Summary fetch failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// Watch subcommand
-const watchCommand = {
-    name: 'watch',
-    description: 'Watch for progress changes',
-    options: [
-        {
-            name: 'interval',
-            short: 'i',
-            description: 'Update interval in milliseconds',
-            type: 'number',
-            default: 5000,
-        },
-    ],
-    action: async (ctx) => {
-        const rawInterval = ctx.flags.interval || 5000;
-        const interval = Number.isFinite(rawInterval) ? Math.max(500, Math.min(rawInterval, 3_600_000)) : 5000; // min 500ms, max 1h
-        output.writeln(output.highlight(`Watching progress (interval: ${interval}ms). Press Ctrl+C to stop.`));
-        output.writeln();
-        let lastProgress = 0;
-        const check = async () => {
-            try {
-                const result = (await callMCPTool('progress_check', {}));
-                const currentProgress = result.overall ?? result.progress ?? 0;
-                if (currentProgress !== lastProgress) {
-                    output.writeln(`${output.warning('→')} Progress changed: ${lastProgress}% → ${output.success(currentProgress + '%')}`);
-                    lastProgress = currentProgress;
-                }
-                else {
-                    process.stdout.write(`\r${progressBar(currentProgress, 20)} ${output.dim(new Date().toLocaleTimeString())}`);
-                }
-            }
-            catch (error) {
-                output.printError(`Check failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        };
-        await check();
-        const timer = setInterval(check, interval);
-        // Handle Ctrl+C — use once so repeated calls don't accumulate SIGINT handlers
-        // (which would trigger MaxListenersExceededWarning and a memory leak).
-        process.once('SIGINT', () => {
-            clearInterval(timer);
-            output.writeln();
-            output.writeln(output.dim('Stopped watching.'));
-            process.exit(0);
-        });
-        // Keep running
-        return new Promise(() => { });
-    },
-};
-// Main progress command
-export const progressCommand = {
-    name: 'progress',
-    description: 'Check v1 implementation progress',
-    aliases: ['prog'],
-    subcommands: [checkCommand, syncCommand, summaryCommand, watchCommand],
-    options: [
-        {
-            name: 'detailed',
-            short: 'd',
-            description: 'Show detailed breakdown',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'sync',
-            short: 's',
-            description: 'Sync and persist progress',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'watch',
-            short: 'w',
-            description: 'Watch for changes',
-            type: 'boolean',
-            default: false,
-        },
-    ],
-    examples: [
-        {
-            command: 'monomind progress',
-            description: 'Check current progress',
-        },
-        {
-            command: 'monomind progress --detailed',
-            description: 'Show detailed breakdown',
-        },
-        {
-            command: 'monomind progress sync',
-            description: 'Sync and persist progress',
-        },
-        {
-            command: 'monomind progress watch',
-            description: 'Watch for changes',
-        },
-        {
-            command: 'monomind progress --json',
-            description: 'Output as JSON',
-        },
-    ],
-    action: async (ctx) => {
-        // Handle --sync flag
-        if (ctx.flags.sync) {
-            return (await syncCommand.action(ctx));
-        }
-        // Handle --watch flag
-        if (ctx.flags.watch) {
-            return (await watchCommand.action(ctx));
-        }
-        // Default to check
-        return (await checkCommand.action(ctx));
-    },
-};
-export default progressCommand;
-//# sourceMappingURL=progress.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/progress-tools.d.ts

@@ -1,14 +0,0 @@
-/**
- * V1 Progress MCP Tools
- *
- * Provides MCP tools for checking and syncing V1 implementation progress.
- *
- * @module @monomind/cli/mcp-tools/progress
- */
-import type { MCPTool } from './types.js';
-/**
- * All progress tools
- */
-export declare const progressTools: MCPTool[];
-export default progressTools;
-//# sourceMappingURL=progress-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/progress-tools.js

@@ -1,353 +0,0 @@
-/**
- * V1 Progress MCP Tools
- *
- * Provides MCP tools for checking and syncing V1 implementation progress.
- *
- * @module @monomind/cli/mcp-tools/progress
- */
-import { existsSync, readdirSync, readFileSync, writeFileSync, renameSync, mkdirSync, statSync } 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);
-// From dist/src/mcp-tools or src/mcp-tools, navigate to v1 directory
-// CLI is at packages/@monomind/cli, so go up 2 levels from cli to get to v1
-const CLI_ROOT = join(__dirname, '../../..');
-const MONOMIND_DIR = join(CLI_ROOT, '..'); // @monomind directory
-const PACKAGES_DIR = join(MONOMIND_DIR, '..'); // v1 directory
-const PROJECT_ROOT = join(PACKAGES_DIR, '..');
-// Utility/service packages follow DDD differently - their services ARE the application layer
-const UTILITY_PACKAGES = new Set([
-    'cli', 'hooks', 'mcp', 'shared', 'testing', 'agents', 'integration',
-    'embeddings', 'deployment', 'performance', 'providers'
-]);
-// Target metrics for 100% completion
-const TARGETS = {
-    CLI_COMMANDS: 28,
-    MCP_TOOLS: 100,
-    HOOKS_SUBCOMMANDS: 27, // 27 hooks documented in CLAUDE.md
-    PACKAGES: 17,
-};
-// Weight distribution for overall progress
-const WEIGHTS = {
-    CLI: 0.25,
-    MCP: 0.25,
-    HOOKS: 0.20,
-    PACKAGES: 0.15,
-    DDD: 0.15,
-};
-function countFilesAndLines(dir, ext = '.ts') {
-    let files = 0;
-    let 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);
-                if (entry.isDirectory() && !entry.name.includes('node_modules') && !entry.name.startsWith('.')) {
-                    walk(fullPath);
-                }
-                else if (entry.isFile() && entry.name.endsWith(ext)) {
-                    files++;
-                    try {
-                        // Skip files > 1 MB to avoid loading generated/minified bundles into memory.
-                        if (statSync(fullPath).size > 1024 * 1024)
-                            continue;
-                        const content = readFileSync(fullPath, 'utf-8');
-                        lines += content.split('\n').length;
-                    }
-                    catch (_e) { /* ignore */ }
-                }
-            }
-        }
-        catch (_e) { /* ignore */ }
-    }
-    walk(dir);
-    return { files, lines };
-}
-function calculateModuleProgress(moduleDir) {
-    if (!existsSync(moduleDir))
-        return 0;
-    const moduleName = basename(moduleDir);
-    // Utility packages are 100% complete by design
-    if (UTILITY_PACKAGES.has(moduleName)) {
-        return 100;
-    }
-    let progress = 0;
-    // Check for DDD structure
-    if (existsSync(join(moduleDir, 'src/domain')))
-        progress += 30;
-    if (existsSync(join(moduleDir, 'src/application')))
-        progress += 30;
-    if (existsSync(join(moduleDir, 'src')))
-        progress += 10;
-    if (existsSync(join(moduleDir, 'src/index.ts')) || existsSync(join(moduleDir, 'index.ts')))
-        progress += 10;
-    if (existsSync(join(moduleDir, '__tests__')) || existsSync(join(moduleDir, 'tests')))
-        progress += 10;
-    if (existsSync(join(moduleDir, 'package.json')))
-        progress += 10;
-    return Math.min(progress, 100);
-}
-async function calculateProgress() {
-    const now = new Date().toISOString();
-    // Count V1 modules
-    const modulesDir = join(PACKAGES_DIR, '@monomind');
-    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++;
-                }
-                else if (progress >= 60) {
-                    explicitDDD++;
-                }
-            }
-        }
-    }
-    const avgProgress = modules.length > 0 ? Math.round(totalProgress / modules.length) : 0;
-    const totalStats = countFilesAndLines(PACKAGES_DIR);
-    // Count CLI commands (from commands/index.ts)
-    let cliCommands = 28; // Default to known count
-    const commandsIndexPath = join(PACKAGES_DIR, '@monomind/cli/src/commands/index.ts');
-    if (existsSync(commandsIndexPath) && statSync(commandsIndexPath).size <= 1024 * 1024) {
-        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;
-            }
-        }
-        catch (_e) { /* ignore */ }
-    }
-    // Count MCP tools
-    let mcpTools = 100; // Approximate
-    const toolsIndexPath = join(PACKAGES_DIR, '@monomind/cli/src/mcp-tools/index.ts');
-    if (existsSync(toolsIndexPath) && statSync(toolsIndexPath).size <= 1024 * 1024) {
-        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(PACKAGES_DIR, '@monomind/cli/src/commands/hooks.ts');
-    if (existsSync(hooksPath) && statSync(hooksPath).size <= 1024 * 1024) {
-        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;
-            }
-        }
-        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: 'ProgressService',
-    };
-}
-async function syncProgress() {
-    const metrics = await calculateProgress();
-    // Persist to file
-    const metricsDir = join(PROJECT_ROOT, '.monomind/metrics');
-    if (!existsSync(metricsDir)) {
-        mkdirSync(metricsDir, { recursive: true });
-    }
-    const outputPath = join(metricsDir, 'v1-progress.json');
-    const outputTmp = outputPath + '.tmp';
-    writeFileSync(outputTmp, 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: 'ProgressService',
-    }, null, 2));
-    renameSync(outputTmp, outputPath);
-    return metrics;
-}
-function getSummary(metrics) {
-    const lines = [
-        '═══════════════════════════════════════════════════',
-        '           V1 Implementation Progress',
-        '═══════════════════════════════════════════════════',
-        '',
-        `  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}%`,
-        '',
-        `  Codebase: ${metrics.codebase.totalFiles} files, ${metrics.codebase.totalLines.toLocaleString()} lines`,
-        '',
-        `  Last Updated: ${metrics.lastUpdated}`,
-        '═══════════════════════════════════════════════════',
-    ];
-    return lines.join('\n');
-}
-/**
- * progress/check - Get current V1 implementation progress
- */
-const progressCheck = {
-    name: 'progress_check',
-    description: 'Get current V1 implementation progress percentage and metrics',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            detailed: {
-                type: 'boolean',
-                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: `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 V1 progress
- */
-const progressSync = {
-    name: 'progress_sync',
-    description: 'Calculate and persist V1 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,
-        };
-    },
-};
-/**
- * progress/summary - Get human-readable progress summary
- */
-const progressSummary = {
-    name: 'progress_summary',
-    description: 'Get human-readable V1 implementation progress summary',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-        required: [],
-    },
-    handler: async () => {
-        const metrics = await calculateProgress();
-        return {
-            summary: getSummary(metrics),
-        };
-    },
-};
-/**
- * progress/watch - Watch progress (status check)
- */
-const progressWatch = {
-    name: 'progress_watch',
-    description: 'Get current watch status for progress monitoring',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                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,
-        };
-    },
-};
-/**
- * All progress tools
- */
-export const progressTools = [
-    progressCheck,
-    progressSync,
-    progressSummary,
-    progressWatch,
-];
-export default progressTools;
-//# sourceMappingURL=progress-tools.js.map