monomind 2.7.11 → 2.7.13

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

@@ -1,236 +0,0 @@
-/**
- * CLI Commands Index
- * Central registry for all CLI commands
- */
-const loadedCommands = new Map();
-// =============================================================================
-// Command Imports
-// =============================================================================
-import { initCommand } from './init.js';
-import { startCommand } from './start.js';
-import { statusCommand } from './status.js';
-import { taskCommand } from './task.js';
-import { sessionCommand } from './session.js';
-import { agentCommand } from './agent.js';
-import { swarmCommand } from './swarm.js';
-import { memoryCommand } from './memory.js';
-import { mcpCommand } from './mcp.js';
-import { hooksCommand } from './hooks.js';
-import { doctorCommand } from './doctor.js';
-import { performanceCommand } from './performance.js';
-import { securityCommand } from './security.js';
-import browseCommand from './browse.js';
-import { configCommand } from './config.js';
-import { completionsCommand } from './completions.js';
-import { analyzeCommand } from './analyze.js';
-import { routeCommand } from './route.js';
-import { providersCommand } from './providers.js';
-import updateCommand from './update.js';
-import { guidanceCommand } from './guidance.js';
-import { cleanupCommand } from './cleanup.js';
-import { autopilotCommand } from './autopilot.js';
-import { monographCommand } from './monograph.js';
-import tokensCommand from './tokens.js';
-import { platformsCommand } from './platforms.js';
-import { designCommand } from './design-detect.js';
-import { searchUniversalCommand } from './search-universal.js';
-import { reportCrashCommand } from './report-crash.js';
-import { crashReportingCommand } from './crash-reporting.js';
-import { docCommand } from './doc.js';
-import { orgCommand } from './org.js';
-// Populate command cache
-loadedCommands.set('init', initCommand);
-loadedCommands.set('start', startCommand);
-loadedCommands.set('status', statusCommand);
-loadedCommands.set('task', taskCommand);
-loadedCommands.set('session', sessionCommand);
-loadedCommands.set('agent', agentCommand);
-loadedCommands.set('swarm', swarmCommand);
-loadedCommands.set('memory', memoryCommand);
-loadedCommands.set('mcp', mcpCommand);
-loadedCommands.set('hooks', hooksCommand);
-loadedCommands.set('doctor', doctorCommand);
-loadedCommands.set('performance', performanceCommand);
-loadedCommands.set('security', securityCommand);
-loadedCommands.set('guidance', guidanceCommand);
-loadedCommands.set('cleanup', cleanupCommand);
-loadedCommands.set('autopilot', autopilotCommand);
-loadedCommands.set('monograph', monographCommand);
-loadedCommands.set('tokens', tokensCommand);
-loadedCommands.set('platforms', platformsCommand);
-loadedCommands.set('browse', browseCommand);
-loadedCommands.set('config', configCommand);
-loadedCommands.set('completions', completionsCommand);
-loadedCommands.set('analyze', analyzeCommand);
-loadedCommands.set('route', routeCommand);
-loadedCommands.set('providers', providersCommand);
-loadedCommands.set('update', updateCommand);
-loadedCommands.set('design', designCommand);
-loadedCommands.set('search', searchUniversalCommand);
-loadedCommands.set('report-crash', reportCrashCommand);
-loadedCommands.set('crash-reporting', crashReportingCommand);
-loadedCommands.set('doc', docCommand);
-loadedCommands.set('org', orgCommand);
-// =============================================================================
-// Exports
-// =============================================================================
-export { initCommand } from './init.js';
-export { startCommand } from './start.js';
-export { statusCommand } from './status.js';
-export { taskCommand } from './task.js';
-export { sessionCommand } from './session.js';
-export { agentCommand } from './agent.js';
-export { swarmCommand } from './swarm.js';
-export { memoryCommand } from './memory.js';
-export { mcpCommand } from './mcp.js';
-export { hooksCommand } from './hooks.js';
-export { doctorCommand } from './doctor.js';
-export { performanceCommand } from './performance.js';
-export { securityCommand } from './security.js';
-export { guidanceCommand } from './guidance.js';
-export { cleanupCommand } from './cleanup.js';
-export { autopilotCommand } from './autopilot.js';
-export { monographCommand } from './monograph.js';
-export { platformsCommand } from './platforms.js';
-export { designCommand } from './design-detect.js';
-export { searchUniversalCommand } from './search-universal.js';
-export { reportCrashCommand } from './report-crash.js';
-export { crashReportingCommand } from './crash-reporting.js';
-export { docCommand } from './doc.js';
-/**
- * All registered commands
- */
-export const commands = [
-    initCommand,
-    startCommand,
-    statusCommand,
-    taskCommand,
-    sessionCommand,
-    agentCommand,
-    swarmCommand,
-    orgCommand,
-    memoryCommand,
-    mcpCommand,
-    hooksCommand,
-    doctorCommand,
-    performanceCommand,
-    securityCommand,
-    guidanceCommand,
-    cleanupCommand,
-    autopilotCommand,
-    monographCommand,
-    platformsCommand,
-    designCommand,
-    searchUniversalCommand,
-    docCommand,
-    crashReportingCommand,
-    browseCommand,
-    configCommand,
-    completionsCommand,
-    analyzeCommand,
-    routeCommand,
-    providersCommand,
-    updateCommand,
-    tokensCommand,
-    reportCrashCommand,
-];
-/**
- * Commands organized by category for help display
- */
-export const commandsByCategory = {
-    primary: [
-        initCommand,
-        startCommand,
-        statusCommand,
-        agentCommand,
-        swarmCommand,
-        orgCommand,
-        memoryCommand,
-        docCommand,
-        taskCommand,
-        sessionCommand,
-        mcpCommand,
-        hooksCommand,
-    ],
-    advanced: [
-        securityCommand,
-        performanceCommand,
-        guidanceCommand,
-        autopilotCommand,
-        designCommand,
-    ],
-    utility: [
-        configCommand,
-        doctorCommand,
-        completionsCommand,
-        reportCrashCommand,
-        crashReportingCommand,
-    ],
-    analysis: [
-        analyzeCommand,
-        routeCommand,
-        monographCommand,
-        tokensCommand,
-        searchUniversalCommand,
-    ],
-    management: [
-        providersCommand,
-        updateCommand,
-        cleanupCommand,
-        platformsCommand,
-        browseCommand,
-    ],
-};
-/**
- * Command registry map for quick lookup
- */
-export const commandRegistry = new Map();
-// Register core commands and their aliases
-for (const cmd of commands) {
-    commandRegistry.set(cmd.name, cmd);
-    if (cmd.aliases) {
-        for (const alias of cmd.aliases) {
-            commandRegistry.set(alias, cmd);
-        }
-    }
-}
-export function getCommand(name) {
-    return loadedCommands.get(name) || commandRegistry.get(name);
-}
-export async function getCommandAsync(name) {
-    return loadedCommands.get(name) || commandRegistry.get(name);
-}
-export function hasCommand(name) {
-    return loadedCommands.has(name) || commandRegistry.has(name);
-}
-export function getCommandNames() {
-    const names = new Set([
-        ...Array.from(commandRegistry.keys()),
-        ...Array.from(loadedCommands.keys()),
-    ]);
-    return Array.from(names);
-}
-export function getUniqueCommands() {
-    return commands.filter(cmd => !cmd.hidden);
-}
-export async function loadAllCommands() {
-    return [...commands];
-}
-/**
- * Setup commands in a CLI instance
- */
-export function setupCommands(cli) {
-    for (const cmd of commands) {
-        cli.command(cmd);
-    }
-}
-/**
- * Setup all commands (async variant)
- */
-export async function setupAllCommands(cli) {
-    const allCommands = await loadAllCommands();
-    for (const cmd of allCommands) {
-        cli.command(cmd);
-    }
-}
-//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/commands/init-subcommands.d.ts

@@ -1,8 +0,0 @@
-/**
- * Init subcommands: check, skills, hooks
- */
-import type { Command } from '../types.js';
-export declare const checkCommand: Command;
-export declare const skillsCommand: Command;
-export declare const hooksCommand: Command;
-//# sourceMappingURL=init-subcommands.d.ts.map

package/packages/@monomind/cli/dist/src/commands/init-subcommands.js

@@ -1,156 +0,0 @@
-/**
- * Init subcommands: check, skills, hooks
- */
-import { output } from '../output.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { executeInit, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, } from '../init/index.js';
-function isInitialized(cwd) {
-    const claudePath = path.join(cwd, '.claude', 'settings.json');
-    const monomindPath = path.join(cwd, '.monomind', 'config.yaml');
-    return {
-        claude: fs.existsSync(claudePath),
-        monomind: fs.existsSync(monomindPath),
-    };
-}
-export const checkCommand = {
-    name: 'check',
-    description: 'Check if MonoMind is initialized',
-    action: async (ctx) => {
-        const initialized = isInitialized(ctx.cwd);
-        const result = {
-            initialized: initialized.claude || initialized.monomind,
-            claude: initialized.claude,
-            monomind: initialized.monomind,
-            paths: {
-                claudeSettings: initialized.claude ? path.join(ctx.cwd, '.claude', 'settings.json') : null,
-                monomindConfig: initialized.monomind ? path.join(ctx.cwd, '.monomind', 'config.yaml') : null,
-            },
-        };
-        if (ctx.flags.format === 'json') {
-            output.printJson(result);
-            return { success: true, data: result };
-        }
-        if (result.initialized) {
-            output.printSuccess('MonoMind is initialized');
-            if (initialized.claude) {
-                output.printInfo(`  Claude Code: .claude/settings.json`);
-            }
-            if (initialized.monomind) {
-                output.printInfo(`  Runtime: .monomind/config.yaml`);
-            }
-        }
-        else {
-            output.printWarning('MonoMind is not initialized in this directory');
-            output.printInfo('Run "monomind init" to initialize');
-        }
-        return { success: true, data: result };
-    },
-};
-export const skillsCommand = {
-    name: 'skills',
-    description: 'Initialize only skills',
-    options: [
-        { name: 'all', description: 'Install all skills', type: 'boolean', default: false },
-        { name: 'core', description: 'Install core skills', type: 'boolean', default: true },
-        { name: 'memory', description: 'Install memory skills', type: 'boolean', default: false },
-        { name: 'github', description: 'Install GitHub skills', type: 'boolean', default: false },
-    ],
-    action: async (ctx) => {
-        const options = {
-            ...MINIMAL_INIT_OPTIONS,
-            targetDir: ctx.cwd,
-            force: ctx.flags.force,
-            components: {
-                settings: false,
-                skills: true,
-                commands: false,
-                agents: false,
-                helpers: false,
-                statusline: false,
-                mcp: false,
-                runtime: false,
-                claudeMd: false,
-                graphify: false,
-            },
-            skills: {
-                all: ctx.flags.all,
-                core: ctx.flags.core,
-                memory: ctx.flags.memory,
-                github: ctx.flags.github,
-                browser: false,
-                advanced: false,
-            },
-        };
-        const spinner = output.createSpinner({ text: 'Installing skills...' });
-        spinner.start();
-        const result = await executeInit(options);
-        if (result.success) {
-            spinner.succeed(`Installed ${result.summary.skillsCount} skills`);
-        }
-        else {
-            spinner.fail('Failed to install skills');
-            for (const error of result.errors) {
-                output.printError(error);
-            }
-        }
-        return { success: result.success, data: result };
-    },
-};
-export const hooksCommand = {
-    name: 'hooks',
-    description: 'Initialize only hooks configuration',
-    options: [
-        { name: 'all', description: 'Enable all hooks', type: 'boolean', default: true },
-        { name: 'minimal', description: 'Enable only essential hooks', type: 'boolean', default: false },
-    ],
-    action: async (ctx) => {
-        const minimal = ctx.flags.minimal;
-        const options = {
-            ...DEFAULT_INIT_OPTIONS,
-            targetDir: ctx.cwd,
-            force: ctx.flags.force,
-            components: {
-                settings: true,
-                skills: false,
-                commands: false,
-                agents: false,
-                helpers: false,
-                statusline: false,
-                mcp: false,
-                runtime: false,
-                claudeMd: false,
-                graphify: false,
-            },
-            hooks: minimal
-                ? {
-                    preToolUse: true,
-                    postToolUse: true,
-                    userPromptSubmit: false,
-                    sessionStart: false,
-                    stop: false,
-                    preCompact: false,
-                    notification: false,
-                    teammateIdle: false,
-                    taskCompleted: false,
-                    timeout: 5000,
-                    continueOnError: true,
-                }
-                : DEFAULT_INIT_OPTIONS.hooks,
-        };
-        const spinner = output.createSpinner({ text: 'Creating hooks configuration...' });
-        spinner.start();
-        const result = await executeInit(options);
-        if (result.success) {
-            spinner.succeed(`Created settings.json with ${result.summary.hooksEnabled} hooks enabled`);
-        }
-        else {
-            spinner.fail('Failed to create hooks configuration');
-            for (const error of result.errors) {
-                output.printError(error);
-            }
-        }
-        return { success: result.success, data: result };
-    },
-};
-//# sourceMappingURL=init-subcommands.js.map

package/packages/@monomind/cli/dist/src/commands/init-upgrade.d.ts

@@ -1,6 +0,0 @@
-/**
- * Init upgrade subcommand — update helpers without losing user data
- */
-import type { Command } from '../types.js';
-export declare const upgradeCommand: Command;
-//# sourceMappingURL=init-upgrade.d.ts.map

package/packages/@monomind/cli/dist/src/commands/init-upgrade.js

@@ -1,203 +0,0 @@
-/**
- * Init upgrade subcommand — update helpers without losing user data
- */
-import { output } from '../output.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { executeUpgrade, executeUpgradeWithMissing, findMonomindProjects, } from '../init/index.js';
-export const upgradeCommand = {
-    name: 'upgrade',
-    description: 'Update statusline and helpers while preserving existing data',
-    options: [
-        {
-            name: 'verbose',
-            short: 'v',
-            description: 'Show detailed output',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'add-missing',
-            short: 'a',
-            description: 'Add any new skills, agents, and commands that are missing',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'settings',
-            short: 's',
-            description: 'Merge new settings (Agent Teams, hooks) into existing settings.json',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'all',
-            description: 'Upgrade all known monomind projects on this machine (scans ~/Desktop, ~/projects, etc.)',
-            type: 'boolean',
-            default: false,
-        },
-    ],
-    action: async (ctx) => {
-        const addMissing = (ctx.flags['add-missing'] || ctx.flags.addMissing);
-        const upgradeSettings = (ctx.flags.settings);
-        const upgradeAll = (ctx.flags.all);
-        if (upgradeAll) {
-            output.writeln();
-            output.writeln(output.bold('Upgrading all monomind projects'));
-            output.writeln(output.dim('Scanning ~/Desktop, ~/projects, ~/code… (this may take a moment)'));
-            output.writeln();
-            const projects = findMonomindProjects();
-            if (projects.length === 0) {
-                output.printInfo('No monomind projects found. Install monomind in a project first: npx monomind init');
-                return { success: true, exitCode: 0 };
-            }
-            output.printInfo(`Found ${projects.length} project(s). Upgrading…`);
-            output.writeln();
-            let succeeded = 0;
-            let failed = 0;
-            // Try to read control URL for dashboard progress events (best-effort)
-            let controlUrl = 'http://localhost:4242';
-            try {
-                const ctrlPath = path.join(process.cwd(), '.monomind', 'control.json');
-                if (fs.existsSync(ctrlPath) && fs.statSync(ctrlPath).size <= 4096) {
-                    const ctrlCfg = JSON.parse(fs.readFileSync(ctrlPath, 'utf-8'));
-                    // Only allow localhost/127.0.0.1 URLs to prevent SSRF via attacker-controlled control.json
-                    if (typeof ctrlCfg.url === 'string' && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(ctrlCfg.url)) {
-                        controlUrl = ctrlCfg.url;
-                    }
-                }
-            }
-            catch { }
-            const emitUpgradeProgress = async (projDir, status, current, total) => {
-                try {
-                    const { default: http } = await import('http');
-                    const payload = JSON.stringify({ type: 'upgrade:progress', project: projDir, status, current, total, ts: Date.now() });
-                    const url = new URL(controlUrl + '/api/mastermind/event');
-                    const req = http.request({ hostname: url.hostname, port: parseInt(url.port || '4242'), path: url.pathname, method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) } });
-                    req.write(payload);
-                    req.end();
-                    req.on('error', () => { });
-                }
-                catch { }
-            };
-            for (const projDir of projects) {
-                const projIdx = projects.indexOf(projDir) + 1;
-                const spinner = output.createSpinner({ text: `[${projIdx}/${projects.length}] ${projDir}` });
-                spinner.start();
-                try {
-                    const res = addMissing
-                        ? await executeUpgradeWithMissing(projDir, upgradeSettings)
-                        : await executeUpgrade(projDir, upgradeSettings);
-                    if (res.success) {
-                        spinner.succeed(projDir + ' (' + res.updated.length + ' updated)');
-                        succeeded++;
-                        emitUpgradeProgress(projDir, 'success', projIdx, projects.length);
-                    }
-                    else {
-                        spinner.fail(projDir + ' — ' + (res.errors[0] || 'unknown error'));
-                        failed++;
-                        emitUpgradeProgress(projDir, 'failed', projIdx, projects.length);
-                    }
-                }
-                catch (e) {
-                    spinner.fail(projDir + ' — ' + (e instanceof Error ? e.message : String(e)));
-                    failed++;
-                    emitUpgradeProgress(projDir, 'failed', projIdx, projects.length);
-                }
-            }
-            output.writeln();
-            output.printInfo(`Done: ${succeeded} upgraded, ${failed} failed out of ${projects.length} projects.`);
-            return { success: failed === 0, exitCode: failed > 0 ? 1 : 0 };
-        }
-        output.writeln();
-        output.writeln(output.bold('Upgrading MonoMind'));
-        if (addMissing && upgradeSettings) {
-            output.writeln(output.dim('Updates helpers, settings, and adds any missing skills/agents/commands'));
-        }
-        else if (addMissing) {
-            output.writeln(output.dim('Updates helpers and adds any missing skills/agents/commands'));
-        }
-        else if (upgradeSettings) {
-            output.writeln(output.dim('Updates helpers and merges new settings (Agent Teams, hooks)'));
-        }
-        else {
-            output.writeln(output.dim('Updates helpers while preserving your existing data'));
-        }
-        output.writeln();
-        const spinnerText = upgradeSettings
-            ? 'Upgrading helpers and settings...'
-            : (addMissing ? 'Upgrading and adding missing assets...' : 'Upgrading...');
-        const spinner = output.createSpinner({ text: spinnerText });
-        spinner.start();
-        try {
-            const result = addMissing
-                ? await executeUpgradeWithMissing(ctx.cwd, upgradeSettings)
-                : await executeUpgrade(ctx.cwd, upgradeSettings);
-            if (!result.success) {
-                spinner.fail('Upgrade failed');
-                for (const error of result.errors) {
-                    output.printError(error);
-                }
-                return { success: false, exitCode: 1 };
-            }
-            spinner.succeed('Upgrade complete!');
-            output.writeln();
-            if (result.updated.length > 0) {
-                output.printBox(result.updated.map(f => `✓ ${f}`).join('\n'), 'Updated (latest version)');
-                output.writeln();
-            }
-            if (result.created.length > 0) {
-                output.printBox(result.created.map(f => `+ ${f}`).join('\n'), 'Created (new files)');
-                output.writeln();
-            }
-            if (result.preserved.length > 0 && ctx.flags.verbose) {
-                output.printBox(result.preserved.map(f => `• ${f}`).join('\n'), 'Preserved (existing data kept)');
-                output.writeln();
-            }
-            else if (result.preserved.length > 0) {
-                output.printInfo(`Preserved ${result.preserved.length} existing data files`);
-                output.writeln();
-            }
-            if (result.addedSkills && result.addedSkills.length > 0) {
-                output.printBox(result.addedSkills.map(s => `+ ${s}`).join('\n'), `Added Skills (${result.addedSkills.length} new)`);
-                output.writeln();
-            }
-            if (result.addedAgents && result.addedAgents.length > 0) {
-                output.printBox(result.addedAgents.map(a => `+ ${a}`).join('\n'), `Added Agents (${result.addedAgents.length} new)`);
-                output.writeln();
-            }
-            if (result.addedCommands && result.addedCommands.length > 0) {
-                output.printBox(result.addedCommands.map(c => `+ ${c}`).join('\n'), `Added Commands (${result.addedCommands.length} new)`);
-                output.writeln();
-            }
-            if (result.settingsUpdated && result.settingsUpdated.length > 0) {
-                output.printBox(result.settingsUpdated.map(s => `+ ${s}`).join('\n'), 'Settings Updated');
-                output.writeln();
-            }
-            output.printSuccess('Your statusline helper has been updated to the latest version');
-            output.printInfo('Existing metrics and learning data were preserved');
-            if (upgradeSettings && result.settingsUpdated && result.settingsUpdated.length > 0) {
-                output.printSuccess('Settings.json updated with new Agent Teams configuration');
-            }
-            if (addMissing) {
-                const totalAdded = (result.addedSkills?.length || 0) + (result.addedAgents?.length || 0) + (result.addedCommands?.length || 0);
-                if (totalAdded > 0) {
-                    output.printSuccess(`Added ${totalAdded} missing assets to your project`);
-                }
-                else {
-                    output.printInfo('All skills, agents, and commands are already up to date');
-                }
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Upgrade failed');
-            output.printError(`Failed to upgrade: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-//# sourceMappingURL=init-upgrade.js.map

package/packages/@monomind/cli/dist/src/commands/init-wizard.d.ts

@@ -1,6 +0,0 @@
-/**
- * Init wizard subcommand — interactive setup
- */
-import type { Command } from '../types.js';
-export declare const wizardCommand: Command;
-//# sourceMappingURL=init-wizard.d.ts.map