monomind 1.9.16 → 1.10.0

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

@@ -1,119 +0,0 @@
-/**
- * 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';
-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 { daemonCommand } from './daemon.js';
-export { doctorCommand } from './doctor.js';
-export { embeddingsCommand } from './embeddings.js';
-export { neuralCommand } from './neural.js';
-export { performanceCommand } from './performance.js';
-export { securityCommand } from './security.js';
-export { ruvectorCommand } from './ruvector/index.js';
-export { hiveMindCommand } from './hive-mind.js';
-export { guidanceCommand } from './guidance.js';
-export { applianceCommand } from './appliance.js';
-export { cleanupCommand } from './cleanup.js';
-export { autopilotCommand } from './autopilot.js';
-export { monographCommand } from './monograph.js';
-export declare function getConfigCommand(): Promise<Command | undefined>;
-export declare function getMigrateCommand(): 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 getPluginsCommand(): Promise<Command | undefined>;
-export declare function getDeploymentCommand(): Promise<Command | undefined>;
-export declare function getClaimsCommand(): Promise<Command | undefined>;
-export declare function getEmbeddingsCommand(): 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 getProgressCommand(): Promise<Command | undefined>;
-export declare function getIssuesCommand(): Promise<Command | undefined>;
-export declare function getRuvectorCommand(): Promise<Command | undefined>;
-export declare function getGuidanceCommand(): Promise<Command | undefined>;
-export declare function getApplianceCommand(): Promise<Command | undefined>;
-export declare function getCleanupCommand(): Promise<Command | undefined>;
-export declare function getAutopilotCommand(): Promise<Command | undefined>;
-export declare function getMonographCommand(): Promise<Command | undefined>;
-/**
- * Core commands loaded synchronously (available immediately)
- * Advanced commands loaded on-demand for faster startup
- */
-export declare const commands: Command[];
-/**
- * Commands organized by category for help display
- */
-export declare const commandsByCategory: {
-    primary: Command[];
-    advanced: Command[];
-    utility: Command[];
-    analysis: Command[];
-    management: Command[];
-};
-/**
- * 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
- */
-export declare function setupCommands(cli: {
-    command: (cmd: Command) => void;
-}): void;
-/**
- * Setup all commands including lazy-loaded (async)
- */
-export declare function setupAllCommands(cli: {
-    command: (cmd: Command) => void;
-}): Promise<void>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,404 +0,0 @@
-/**
- * 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.
- */
-/**
- * Command loaders - commands are only imported when needed
- * This reduces initial bundle parse time by ~200ms
- */
-const commandLoaders = {
-    // P1 Core Commands (frequently used - load first)
-    init: () => import('./init.js'),
-    start: () => import('./start.js'),
-    status: () => import('./status.js'),
-    task: () => import('./task.js'),
-    session: () => import('./session.js'),
-    // Original Commands
-    agent: () => import('./agent.js'),
-    swarm: () => import('./swarm.js'),
-    memory: () => import('./memory.js'),
-    mcp: () => import('./mcp.js'),
-    config: () => import('./config.js'),
-    migrate: () => import('./migrate.js'),
-    hooks: () => import('./hooks.js'),
-    workflow: () => import('./workflow.js'),
-    'hive-mind': () => import('./hive-mind.js'),
-    process: () => import('./process.js'),
-    daemon: () => import('./daemon.js'),
-    // Advanced Commands (less frequently used - lazy load)
-    neural: () => import('./neural.js'),
-    security: () => import('./security.js'),
-    performance: () => import('./performance.js'),
-    providers: () => import('./providers.js'),
-    plugins: () => import('./plugins.js'),
-    deployment: () => import('./deployment.js'),
-    claims: () => import('./claims.js'),
-    embeddings: () => import('./embeddings.js'),
-    // P0 Commands
-    completions: () => import('./completions.js'),
-    doctor: () => import('./doctor.js'),
-    // Analysis Commands
-    analyze: () => import('./analyze.js'),
-    // Q-Learning Routing Commands
-    route: () => import('./route.js'),
-    // Progress Commands
-    progress: () => import('./progress.js'),
-    // Issue Claims Commands (ADR-016)
-    issues: () => import('./issues.js'),
-    // Auto-update System (ADR-025)
-    update: () => import('./update.js'),
-    // RuVector PostgreSQL Bridge
-    ruvector: () => import('./ruvector/index.js'),
-    // Benchmark Suite (Pre-training, Neural, Memory)
-    benchmark: () => import('./benchmark.js'),
-    // Guidance Control Plane
-    guidance: () => import('./guidance.js'),
-    // RVFA Appliance Management
-    appliance: () => import('./appliance.js'),
-    'appliance-advanced': () => import('./appliance-advanced.js'),
-    'transfer-store': () => import('./transfer-store.js'),
-    cleanup: () => import('./cleanup.js'),
-    autopilot: () => import('./autopilot.js'),
-    tokens: () => import('./tokens.js'),
-    monograph: () => import('./monograph.js'),
-    replay: () => import('./replay.js'),
-};
-// Cache for loaded commands
-const loadedCommands = new Map();
-/**
- * Load a command lazily
- */
-async function loadCommand(name) {
-    if (loadedCommands.has(name)) {
-        return loadedCommands.get(name);
-    }
-    const loader = commandLoaders[name];
-    if (!loader)
-        return undefined;
-    try {
-        const module = await loader();
-        // Try to find the command export (either default or named)
-        const command = (module.default || module[`${name}Command`] || Object.values(module).find((v) => typeof v === 'object' && v !== null && 'name' in v && 'description' in v));
-        if (command) {
-            loadedCommands.set(name, command);
-            return command;
-        }
-    }
-    catch (error) {
-        // Silently fail for missing optional commands
-        if (process.env.DEBUG) {
-            console.error(`Failed to load command ${name}:`, error);
-        }
-    }
-    return undefined;
-}
-// =============================================================================
-// Synchronous Imports for Core Commands (needed immediately at startup)
-// These are the most commonly used commands that need instant access
-// =============================================================================
-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 { daemonCommand } from './daemon.js';
-import { doctorCommand } from './doctor.js';
-import { embeddingsCommand } from './embeddings.js';
-import { neuralCommand } from './neural.js';
-import { performanceCommand } from './performance.js';
-import { securityCommand } from './security.js';
-import { ruvectorCommand } from './ruvector/index.js';
-import { hiveMindCommand } from './hive-mind.js';
-// Additional commands for categorized help display
-import { configCommand } from './config.js';
-import { completionsCommand } from './completions.js';
-import { migrateCommand } from './migrate.js';
-import { workflowCommand } from './workflow.js';
-import { analyzeCommand } from './analyze.js';
-import { routeCommand } from './route.js';
-import { progressCommand } from './progress.js';
-import { providersCommand } from './providers.js';
-import { pluginsCommand } from './plugins.js';
-import { deploymentCommand } from './deployment.js';
-import { claimsCommand } from './claims.js';
-import { issuesCommand } from './issues.js';
-import updateCommand from './update.js';
-import { processCommand } from './process.js';
-import { guidanceCommand } from './guidance.js';
-import { applianceCommand } from './appliance.js';
-import { cleanupCommand } from './cleanup.js';
-import { autopilotCommand } from './autopilot.js';
-import { monographCommand } from './monograph.js';
-import replayCommand from './replay.js';
-import { benchmarkCommand } from './benchmark.js';
-import storeCommand from './transfer-store.js';
-import tokensCommand from './tokens.js';
-// Pre-populate cache with core commands
-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('daemon', daemonCommand);
-loadedCommands.set('doctor', doctorCommand);
-loadedCommands.set('embeddings', embeddingsCommand);
-loadedCommands.set('neural', neuralCommand);
-loadedCommands.set('performance', performanceCommand);
-loadedCommands.set('security', securityCommand);
-loadedCommands.set('ruvector', ruvectorCommand);
-loadedCommands.set('hive-mind', hiveMindCommand);
-loadedCommands.set('guidance', guidanceCommand);
-loadedCommands.set('cleanup', cleanupCommand);
-loadedCommands.set('autopilot', autopilotCommand);
-loadedCommands.set('monograph', monographCommand);
-loadedCommands.set('replay', replayCommand);
-loadedCommands.set('benchmark', benchmarkCommand);
-loadedCommands.set('transfer-store', storeCommand);
-loadedCommands.set('tokens', tokensCommand);
-// =============================================================================
-// Exports (maintain backwards compatibility)
-// =============================================================================
-// Export synchronously loaded commands
-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 { daemonCommand } from './daemon.js';
-export { doctorCommand } from './doctor.js';
-export { embeddingsCommand } from './embeddings.js';
-export { neuralCommand } from './neural.js';
-export { performanceCommand } from './performance.js';
-export { securityCommand } from './security.js';
-export { ruvectorCommand } from './ruvector/index.js';
-export { hiveMindCommand } from './hive-mind.js';
-export { guidanceCommand } from './guidance.js';
-export { applianceCommand } from './appliance.js';
-export { cleanupCommand } from './cleanup.js';
-export { autopilotCommand } from './autopilot.js';
-export { monographCommand } from './monograph.js';
-// Lazy-loaded command re-exports (for backwards compatibility, but async-only)
-export async function getConfigCommand() { return loadCommand('config'); }
-export async function getMigrateCommand() { return loadCommand('migrate'); }
-export async function getWorkflowCommand() { return loadCommand('workflow'); }
-export async function getHiveMindCommand() { return loadCommand('hive-mind'); }
-export async function getProcessCommand() { return loadCommand('process'); }
-export async function getTaskCommand() { return loadCommand('task'); }
-export async function getSessionCommand() { return loadCommand('session'); }
-export async function getNeuralCommand() { return loadCommand('neural'); }
-export async function getSecurityCommand() { return loadCommand('security'); }
-export async function getPerformanceCommand() { return loadCommand('performance'); }
-export async function getProvidersCommand() { return loadCommand('providers'); }
-export async function getPluginsCommand() { return loadCommand('plugins'); }
-export async function getDeploymentCommand() { return loadCommand('deployment'); }
-export async function getClaimsCommand() { return loadCommand('claims'); }
-export async function getEmbeddingsCommand() { return loadCommand('embeddings'); }
-export async function getCompletionsCommand() { return loadCommand('completions'); }
-export async function getAnalyzeCommand() { return loadCommand('analyze'); }
-export async function getRouteCommand() { return loadCommand('route'); }
-export async function getProgressCommand() { return loadCommand('progress'); }
-export async function getIssuesCommand() { return loadCommand('issues'); }
-export async function getRuvectorCommand() { return loadCommand('ruvector'); }
-export async function getGuidanceCommand() { return loadCommand('guidance'); }
-export async function getApplianceCommand() { return loadCommand('appliance'); }
-export async function getCleanupCommand() { return loadCommand('cleanup'); }
-export async function getAutopilotCommand() { return loadCommand('autopilot'); }
-export async function getMonographCommand() { return loadCommand('monograph'); }
-/**
- * Core commands loaded synchronously (available immediately)
- * Advanced commands loaded on-demand for faster startup
- */
-export const commands = [
-    // Core commands (synchronously loaded)
-    initCommand,
-    startCommand,
-    statusCommand,
-    taskCommand,
-    sessionCommand,
-    agentCommand,
-    swarmCommand,
-    memoryCommand,
-    mcpCommand,
-    hooksCommand,
-    daemonCommand,
-    doctorCommand,
-    embeddingsCommand,
-    neuralCommand,
-    performanceCommand,
-    securityCommand,
-    ruvectorCommand,
-    hiveMindCommand,
-    guidanceCommand,
-    cleanupCommand,
-    autopilotCommand,
-    monographCommand,
-];
-/**
- * Commands organized by category for help display
- */
-export const commandsByCategory = {
-    primary: [
-        initCommand,
-        startCommand,
-        statusCommand,
-        agentCommand,
-        swarmCommand,
-        memoryCommand,
-        taskCommand,
-        sessionCommand,
-        mcpCommand,
-        hooksCommand,
-    ],
-    advanced: [
-        neuralCommand,
-        securityCommand,
-        performanceCommand,
-        embeddingsCommand,
-        hiveMindCommand,
-        ruvectorCommand,
-        guidanceCommand,
-        autopilotCommand,
-        benchmarkCommand,
-    ],
-    utility: [
-        configCommand,
-        doctorCommand,
-        daemonCommand,
-        completionsCommand,
-        migrateCommand,
-        workflowCommand,
-    ],
-    analysis: [
-        analyzeCommand,
-        routeCommand,
-        progressCommand,
-        monographCommand,
-        replayCommand,
-        tokensCommand,
-    ],
-    management: [
-        providersCommand,
-        pluginsCommand,
-        deploymentCommand,
-        claimsCommand,
-        issuesCommand,
-        updateCommand,
-        processCommand,
-        applianceCommand,
-        storeCommand,
-    ],
-};
-/**
- * Command registry map for quick lookup
- * Supports both sync (core commands) and async (lazy-loaded) commands
- */
-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);
-        }
-    }
-}
-/**
- * Get command by name (sync for core commands, returns undefined for lazy commands)
- * Use getCommandAsync for lazy-loaded commands
- */
-export function getCommand(name) {
-    return loadedCommands.get(name) || commandRegistry.get(name);
-}
-/**
- * Get command by name (async - supports lazy loading)
- */
-export async function getCommandAsync(name) {
-    // Check already-loaded commands first
-    const cached = loadedCommands.get(name);
-    if (cached)
-        return cached;
-    // Check sync registry
-    const synced = commandRegistry.get(name);
-    if (synced)
-        return synced;
-    // Try lazy loading
-    return loadCommand(name);
-}
-/**
- * Check if command exists (sync check for core commands)
- */
-export function hasCommand(name) {
-    return loadedCommands.has(name) || commandRegistry.has(name) || name in commandLoaders;
-}
-/**
- * Get all command names (including aliases and lazy-loadable)
- */
-export function getCommandNames() {
-    const names = new Set([
-        ...Array.from(commandRegistry.keys()),
-        ...Array.from(loadedCommands.keys()),
-        ...Object.keys(commandLoaders),
-    ]);
-    return Array.from(names);
-}
-/**
- * Get all unique commands (excluding aliases)
- */
-export function getUniqueCommands() {
-    return commands.filter(cmd => !cmd.hidden);
-}
-/**
- * Load all commands (populates lazy-loaded commands)
- * Use this when you need all commands available synchronously
- */
-export async function loadAllCommands() {
-    const allCommands = [...commands];
-    for (const name of Object.keys(commandLoaders)) {
-        if (!loadedCommands.has(name)) {
-            const cmd = await loadCommand(name);
-            if (cmd && !allCommands.includes(cmd)) {
-                allCommands.push(cmd);
-            }
-        }
-    }
-    return allCommands;
-}
-/**
- * Setup commands in a CLI instance
- */
-export function setupCommands(cli) {
-    for (const cmd of commands) {
-        cli.command(cmd);
-    }
-}
-/**
- * Setup all commands including lazy-loaded (async)
- */
-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.d.ts

@@ -1,8 +0,0 @@
-/**
- * CLI Init Command
- * Comprehensive initialization for Monomind with Claude Code integration
- */
-import type { Command } from '../types.js';
-export declare const initCommand: Command;
-export default initCommand;
-//# sourceMappingURL=init.d.ts.map