monomind 1.18.13 → 1.19.0

package/packages/@monomind/cli/dist/src/commands/hooks-extended-commands.js

@@ -5,114 +5,6 @@
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-// Token Optimizer command
-export const tokenOptimizeCommand = {
-    name: 'token-optimize',
-    description: 'Token optimization via memory-based context retrieval (30-50% savings)',
-    options: [
-        { name: 'query', short: 'q', type: 'string', description: 'Query for compact context retrieval' },
-        { name: 'agents', short: 'A', type: 'number', description: 'Agent count for optimal config', default: '6' },
-        { name: 'report', short: 'r', type: 'boolean', description: 'Generate optimization report' },
-        { name: 'stats', short: 's', type: 'boolean', description: 'Show token savings statistics' },
-    ],
-    examples: [
-        { command: 'monomind hooks token-optimize --stats', description: 'Show token savings stats' },
-        { command: 'monomind hooks token-optimize -q "auth patterns"', description: 'Get compact context' },
-        { command: 'monomind hooks token-optimize -A 8 --report', description: 'Config for 8 agents + report' },
-    ],
-    action: async (ctx) => {
-        const query = ctx.flags['query'];
-        const agentCount = parseInt(ctx.flags['agents'] || '6', 10);
-        const showReport = ctx.flags['report'];
-        const showStats = ctx.flags['stats'];
-        const spinner = output.createSpinner({ text: 'Checking memory integration...', spinner: 'dots' });
-        spinner.start();
-        // Inline TokenOptimizer (self-contained, no external imports)
-        const stats = {
-            totalTokensSaved: 0,
-            editsOptimized: 0,
-            cacheHits: 0,
-            cacheMisses: 0,
-            memoriesRetrieved: 0,
-        };
-        try {
-            spinner.succeed('Memory-based token optimization active');
-            output.writeln();
-            // Anti-drift config (hardcoded optimal values from research)
-            const config = {
-                batchSize: 4,
-                cacheSizeMB: 50,
-                topology: 'hierarchical',
-                expectedSuccessRate: 0.95,
-            };
-            output.printBox(`Anti-Drift Swarm Config\n\n` +
-                `Agents: ${agentCount}\n` +
-                `Topology: ${config.topology}\n` +
-                `Batch Size: ${config.batchSize}\n` +
-                `Cache: ${config.cacheSizeMB}MB\n` +
-                `Success Rate: ${(config.expectedSuccessRate * 100)}%`);
-            if (query) {
-                output.writeln();
-                output.printInfo(`Context retrieval for: "${query}" — use monomind memory search`);
-            }
-            // Simulate some token savings for demo
-            stats.totalTokensSaved += 200;
-            stats.cacheHits = 2;
-            stats.cacheMisses = 1;
-            // Show stats
-            if (showStats || showReport) {
-                output.writeln();
-                const total = stats.cacheHits + stats.cacheMisses;
-                const hitRate = total > 0 ? (stats.cacheHits / total * 100).toFixed(1) : '0';
-                const savings = (stats.totalTokensSaved / 1000 * 0.01).toFixed(2);
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 20 },
-                    ],
-                    data: [
-                        { metric: 'Tokens Saved', value: stats.totalTokensSaved.toLocaleString() },
-                        { metric: 'Edits Optimized', value: String(stats.editsOptimized) },
-                        { metric: 'Cache Hit Rate', value: `${hitRate}%` },
-                        { metric: 'Memories Retrieved', value: String(stats.memoriesRetrieved) },
-                        { metric: 'Est. Monthly Savings', value: `$${savings}` },
-                    ],
-                });
-            }
-            // Full report
-            if (showReport) {
-                output.writeln();
-                const total = stats.cacheHits + stats.cacheMisses;
-                const hitRate = total > 0 ? (stats.cacheHits / total * 100).toFixed(1) : '0';
-                const savings = (stats.totalTokensSaved / 1000 * 0.01).toFixed(2);
-                output.writeln(`## Token Optimization Report
-
-| Metric | Value |
-|--------|-------|
-| Tokens Saved | ${stats.totalTokensSaved.toLocaleString()} |
-| Edits Optimized | ${stats.editsOptimized} |
-| Cache Hit Rate | ${hitRate}% |
-| Memories Retrieved | ${stats.memoriesRetrieved} |
-| Est. Monthly Savings | $${savings} |
-| Memories Retrieved | ${stats.memoriesRetrieved} |`);
-            }
-            return { success: true, data: { config, stats } };
-        }
-        catch (error) {
-            spinner.fail('TokenOptimizer failed');
-            const err = error;
-            output.printError(`Error: ${err.message}`);
-            // Fallback info
-            output.writeln();
-            output.printInfo('Fallback anti-drift config:');
-            output.writeln('  topology: hierarchical');
-            output.writeln('  maxAgents: 8');
-            output.writeln('  strategy: specialized');
-            output.writeln('  batchSize: 4');
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 // Model Router command - intelligent model selection (haiku/sonnet/opus)
 export const modelRouteCommand = {
     name: 'model-route',
@@ -301,205 +193,6 @@ export const modelStatsCommand = {
         }
     }
 };
-// Teammate Idle command - Agent Teams integration
-export const teammateIdleCommand = {
-    name: 'teammate-idle',
-    description: 'Handle idle teammate in Agent Teams - auto-assign tasks or notify lead',
-    options: [
-        {
-            name: 'auto-assign',
-            short: 'a',
-            description: 'Automatically assign pending tasks to idle teammate',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'check-task-list',
-            short: 'c',
-            description: 'Check shared task list for available work',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'teammate-id',
-            short: 't',
-            description: 'ID of the idle teammate',
-            type: 'string'
-        },
-        {
-            name: 'team-name',
-            description: 'Team name for context',
-            type: 'string'
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks teammate-idle --auto-assign true', description: 'Auto-assign tasks to idle teammate' },
-        { command: 'monomind hooks teammate-idle -t worker-1 --check-task-list', description: 'Check tasks for specific teammate' }
-    ],
-    action: async (ctx) => {
-        const autoAssign = ctx.flags['auto-assign'] !== false;
-        const checkTaskList = ctx.flags['check-task-list'] !== false;
-        const teammateId = ctx.flags['teammate-id'];
-        const teamName = ctx.flags['team-name'];
-        if (ctx.flags.format !== 'json') {
-            output.printInfo(`Teammate idle hook triggered${teammateId ? ` for: ${output.highlight(teammateId)}` : ''}`);
-        }
-        try {
-            const result = await callMCPTool('hooks_teammate-idle', {
-                autoAssign,
-                checkTaskList,
-                teammateId,
-                teamName,
-                timestamp: Date.now(),
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            if (result.action === 'assigned' && result.taskAssigned) {
-                output.printSuccess(`Task assigned: ${result.taskAssigned.subject}`);
-                output.printList([
-                    `Task ID: ${result.taskAssigned.taskId}`,
-                    `Priority: ${result.taskAssigned.priority}`,
-                    `Pending tasks remaining: ${result.pendingTasks}`
-                ]);
-            }
-            else if (result.action === 'waiting') {
-                output.printInfo('No pending tasks available - teammate waiting for work');
-            }
-            else {
-                output.printInfo(`Team lead notified: ${result.message}`);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            // Graceful fallback - don't fail hard, just report
-            if (ctx.flags.format === 'json') {
-                output.printJson({ success: true, action: 'waiting', message: 'Teammate idle - no MCP server' });
-            }
-            else {
-                output.printInfo('Teammate idle - awaiting task assignment');
-            }
-            return { success: true };
-        }
-    }
-};
-// Task Completed command - Agent Teams integration
-export const taskCompletedCommand = {
-    name: 'task-completed',
-    description: 'Handle task completion in Agent Teams - train patterns and notify lead',
-    options: [
-        {
-            name: 'task-id',
-            short: 'i',
-            description: 'ID of the completed task',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'train-patterns',
-            short: 'p',
-            description: 'Train neural patterns from successful task',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'notify-lead',
-            short: 'n',
-            description: 'Notify team lead of task completion',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'success',
-            short: 's',
-            description: 'Whether the task succeeded',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'quality',
-            short: 'q',
-            description: 'Quality score (0-1)',
-            type: 'number'
-        },
-        {
-            name: 'teammate-id',
-            short: 't',
-            description: 'ID of the teammate that completed the task',
-            type: 'string'
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks task-completed -i task-123 --train-patterns', description: 'Complete task and train patterns' },
-        { command: 'monomind hooks task-completed -i task-456 --notify-lead --quality 0.95', description: 'Complete with quality score' }
-    ],
-    action: async (ctx) => {
-        const taskId = ctx.args[0] || ctx.flags['task-id'];
-        const trainPatterns = ctx.flags['train-patterns'] !== false;
-        const notifyLead = ctx.flags['notify-lead'] !== false;
-        const success = ctx.flags.success !== false;
-        const quality = ctx.flags.quality;
-        const teammateId = ctx.flags['teammate-id'];
-        if (!taskId) {
-            output.printError('Task ID is required. Use --task-id or -i flag.');
-            return { success: false, exitCode: 1 };
-        }
-        if (ctx.flags.format !== 'json') {
-            output.printInfo(`Task completed: ${output.highlight(taskId)}`);
-        }
-        try {
-            const result = await callMCPTool('hooks_task-completed', {
-                taskId,
-                trainPatterns,
-                notifyLead,
-                success,
-                quality,
-                teammateId,
-                timestamp: Date.now(),
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printSuccess(`Task ${taskId} marked complete`);
-            output.writeln();
-            output.writeln(output.bold('Completion Metrics'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 20, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Patterns Learned', value: result.patternsLearned },
-                    { metric: 'Quality Score', value: quality ? `${(quality * 100).toFixed(0)}%` : 'N/A' },
-                    { metric: 'Lead Notified', value: result.leadNotified ? 'Yes' : 'No' },
-                    { metric: 'Learning Updates', value: result.metrics?.learningUpdates || 0 }
-                ]
-            });
-            if (result.nextTask) {
-                output.writeln();
-                output.printInfo(`Next available task: ${result.nextTask.subject}`);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            // Graceful fallback
-            if (ctx.flags.format === 'json') {
-                output.printJson({ success: true, taskId, message: 'Task completed - patterns pending' });
-            }
-            else {
-                output.printSuccess(`Task ${taskId} completed`);
-                if (trainPatterns) {
-                    output.printInfo('Pattern training queued for next sync');
-                }
-            }
-            return { success: true };
-        }
-    }
-};
 // Notify subcommand
 export const notifyCommand = {
     name: 'notify',

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

@@ -14,7 +14,7 @@ import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { intelligenceCommand, workerCommand } from './hooks-workers.js';
 import { coverageRouteCommand, coverageSuggestCommand, coverageGapsCommand, statuslineCommand, } from './hooks-coverage-commands.js';
-import { tokenOptimizeCommand, modelRouteCommand, modelOutcomeCommand, modelStatsCommand, teammateIdleCommand, taskCompletedCommand, notifyCommand, } from './hooks-extended-commands.js';
+import { modelRouteCommand, modelOutcomeCommand, modelStatsCommand, notifyCommand, } from './hooks-extended-commands.js';
 import { preEditCommand, postEditCommand, preCommandCommand, postCommandCommand, } from './hooks-core-commands.js';
 import { routeCommand, explainCommand, pretrainCommand, buildAgentsCommand, metricsCommand, transferCommand, listCommand, } from './hooks-routing-commands.js';
 // Pre-task subcommand
@@ -428,8 +428,6 @@ export const hooksCommand = {
         coverageRouteCommand,
         coverageSuggestCommand,
         coverageGapsCommand,
-        // Token optimization
-        tokenOptimizeCommand,
         // Model routing (tiny-dancer integration)
         modelRouteCommand,
         modelOutcomeCommand,
@@ -439,9 +437,6 @@ export const hooksCommand = {
         sessionStartCommand,
         preBashCommand,
         postBashCommand,
-        // Agent Teams integration
-        teammateIdleCommand,
-        taskCompletedCommand,
     ],
     options: [],
     examples: [
@@ -476,19 +471,13 @@ export const hooksCommand = {
             `${output.highlight('transfer')}        - Transfer patterns from another project`,
             `${output.highlight('list')}            - List all registered hooks`,
             `${output.highlight('worker')}          - Background worker management (12 workers)`,
-            `${output.highlight('progress')}        - Check implementation progress`,
             `${output.highlight('statusline')}      - Generate dynamic statusline display`,
             `${output.highlight('coverage-route')}  - Route tasks based on coverage gaps (monovector)`,
             `${output.highlight('coverage-suggest')}- Suggest coverage improvements`,
             `${output.highlight('coverage-gaps')}   - List all coverage gaps with agents`,
-            `${output.highlight('token-optimize')} - Token optimization (30-50% savings)`,
             `${output.highlight('model-route')}    - Route to optimal model (haiku/sonnet/opus)`,
             `${output.highlight('model-outcome')}  - Record model routing outcome`,
             `${output.highlight('model-stats')}    - View model routing statistics`,
-            '',
-            output.bold('Agent Teams:'),
-            `${output.highlight('teammate-idle')}  - Handle idle teammate (auto-assign tasks)`,
-            `${output.highlight('task-completed')} - Handle task completion (train patterns)`
         ]);
         output.writeln();
         output.writeln('Run "monomind hooks <subcommand> --help" for subcommand help');

package/packages/@monomind/cli/dist/src/commands/index.d.ts

@@ -1,12 +1,6 @@
 /**
  * CLI Commands Index
  * Central registry for all CLI commands
- *
- * NOTE: All commands are synchronously imported at module load time (lines below).
- * The commandLoaders/loadCommand infrastructure provides an async fallback for
- * commands looked up via getCommandAsync() but does NOT reduce startup time since
- * all modules are already imported synchronously for the commands array and
- * commandsByCategory exports.
  */
 import type { Command } from '../types.js';
 export { initCommand } from './init.js';
@@ -21,7 +15,6 @@ export { mcpCommand } from './mcp.js';
 export { hooksCommand } from './hooks.js';
 export { daemonCommand } from './daemon.js';
 export { doctorCommand } from './doctor.js';
-export { neuralCommand } from './neural.js';
 export { performanceCommand } from './performance.js';
 export { securityCommand } from './security.js';
 export { hiveMindCommand } from './hive-mind.js';
@@ -37,29 +30,9 @@ export { scanCommand } from './scan.js';
 export { reportCrashCommand } from './report-crash.js';
 export { crashReportingCommand } from './crash-reporting.js';
 export { docCommand } from './doc.js';
-export declare function getConfigCommand(): Promise<Command | undefined>;
-export declare function getWorkflowCommand(): Promise<Command | undefined>;
-export declare function getHiveMindCommand(): Promise<Command | undefined>;
-export declare function getProcessCommand(): Promise<Command | undefined>;
-export declare function getTaskCommand(): Promise<Command | undefined>;
-export declare function getSessionCommand(): Promise<Command | undefined>;
-export declare function getNeuralCommand(): Promise<Command | undefined>;
-export declare function getSecurityCommand(): Promise<Command | undefined>;
-export declare function getPerformanceCommand(): Promise<Command | undefined>;
-export declare function getProvidersCommand(): Promise<Command | undefined>;
-export declare function getDeploymentCommand(): Promise<Command | undefined>;
-export declare function getClaimsCommand(): Promise<Command | undefined>;
-export declare function getCompletionsCommand(): Promise<Command | undefined>;
-export declare function getAnalyzeCommand(): Promise<Command | undefined>;
-export declare function getRouteCommand(): Promise<Command | undefined>;
-export declare function getIssuesCommand(): Promise<Command | undefined>;
-export declare function getGuidanceCommand(): Promise<Command | undefined>;
-export declare function getCleanupCommand(): Promise<Command | undefined>;
-export declare function getAutopilotCommand(): Promise<Command | undefined>;
-export declare function getMonographCommand(): Promise<Command | undefined>;
+export { neuralCommand } from './neural.js';
 /**
- * Core commands loaded synchronously (available immediately)
- * Advanced commands loaded on-demand for faster startup
+ * All registered commands
  */
 export declare const commands: Command[];
 /**
@@ -74,34 +47,13 @@ export declare const commandsByCategory: {
 };
 /**
  * Command registry map for quick lookup
- * Supports both sync (core commands) and async (lazy-loaded) commands
  */
 export declare const commandRegistry: Map<string, Command>;
-/**
- * Get command by name (sync for core commands, returns undefined for lazy commands)
- * Use getCommandAsync for lazy-loaded commands
- */
 export declare function getCommand(name: string): Command | undefined;
-/**
- * Get command by name (async - supports lazy loading)
- */
 export declare function getCommandAsync(name: string): Promise<Command | undefined>;
-/**
- * Check if command exists (sync check for core commands)
- */
 export declare function hasCommand(name: string): boolean;
-/**
- * Get all command names (including aliases and lazy-loadable)
- */
 export declare function getCommandNames(): string[];
-/**
- * Get all unique commands (excluding aliases)
- */
 export declare function getUniqueCommands(): Command[];
-/**
- * Load all commands (populates lazy-loaded commands)
- * Use this when you need all commands available synchronously
- */
 export declare function loadAllCommands(): Promise<Command[]>;
 /**
  * Setup commands in a CLI instance
@@ -110,7 +62,7 @@ export declare function setupCommands(cli: {
     command: (cmd: Command) => void;
 }): void;
 /**
- * Setup all commands including lazy-loaded (async)
+ * Setup all commands (async variant)
  */
 export declare function setupAllCommands(cli: {
     command: (cmd: Command) => void;