monomind 2.7.11 → 2.7.13

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

@@ -1,217 +0,0 @@
-/**
- * CLI Analyze Command
- * Code analysis, diff classification, AST analysis, and change risk assessment
- *
- * Features:
- * - AST analysis using monovector (tree-sitter) with graceful fallback
- * - Symbol extraction (functions, classes, variables, types)
- * - Cyclomatic complexity scoring
- * - Diff classification and risk assessment
- *
- * github.com/monoes/monomind
- */
-import { output } from '../output.js';
-import * as path from 'path';
-import * as fs from 'fs/promises';
-import { writeFile } from 'fs/promises';
-import { diffCommand, codeCommand } from './analyze-diff.js';
-import { astCommand } from './analyze-ast.js';
-import { complexityAstCommand, symbolsCommand } from './analyze-symbols.js';
-import { importsCommand, depsCommand } from './analyze-imports.js';
-// AST analyzer module was never shipped — always falls back to the regex path.
-export async function getASTAnalyzer() {
-    return null;
-}
-/**
- * Write analysis output to a file, constraining the path to the current working
- * directory to prevent path traversal attacks via --output /etc/cron.d/x or
- * similar. Throws if the resolved path escapes cwd.
- */
-export async function safeWriteOutputFile(outputFile, data) {
-    const projectRoot = path.resolve(process.cwd());
-    const fullPath = path.resolve(process.cwd(), outputFile);
-    if (!fullPath.startsWith(projectRoot + path.sep) && fullPath !== projectRoot) {
-        throw new Error(`Output path must resolve within the project directory: ${projectRoot}`);
-    }
-    await writeFile(fullPath, data);
-}
-/**
- * Helper: Scan directory for source files
- */
-export async function scanSourceFiles(dir, maxDepth = 10) {
-    const files = [];
-    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-    const excludeDirs = ['node_modules', 'dist', 'build', '.git', 'coverage', '__pycache__'];
-    async function scan(currentDir, depth) {
-        if (depth > maxDepth)
-            return;
-        try {
-            const entries = await fs.readdir(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    if (!excludeDirs.includes(entry.name)) {
-                        await scan(fullPath, depth + 1);
-                    }
-                }
-                else if (entry.isFile()) {
-                    const ext = path.extname(entry.name);
-                    if (extensions.includes(ext)) {
-                        files.push(fullPath);
-                    }
-                }
-            }
-        }
-        catch {
-            // Skip directories we can't read
-        }
-    }
-    await scan(dir, 0);
-    return files;
-}
-/**
- * Fallback analysis when monovector is not available
- */
-export function fallbackAnalyze(code, filePath) {
-    const lines = code.split('\n');
-    const functions = [];
-    const classes = [];
-    const imports = [];
-    const exports = [];
-    // Extract functions
-    const funcPattern = /(?:export\s+)?(?:async\s+)?function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>|^\s*(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{/gm;
-    let match;
-    while ((match = funcPattern.exec(code)) !== null) {
-        const name = match[1] || match[2] || match[3];
-        if (name && !['if', 'while', 'for', 'switch'].includes(name)) {
-            const lineNum = code.substring(0, match.index).split('\n').length;
-            functions.push({ name, startLine: lineNum, endLine: lineNum + 10 });
-        }
-    }
-    // Extract classes
-    const classPattern = /(?:export\s+)?class\s+(\w+)/gm;
-    while ((match = classPattern.exec(code)) !== null) {
-        const lineNum = code.substring(0, match.index).split('\n').length;
-        classes.push({ name: match[1], startLine: lineNum, endLine: lineNum + 20 });
-    }
-    // Extract imports
-    const importPattern = /import\s+(?:.*\s+from\s+)?['"]([^'"]+)['"]/gm;
-    while ((match = importPattern.exec(code)) !== null) {
-        imports.push(match[1]);
-    }
-    const requirePattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm;
-    while ((match = requirePattern.exec(code)) !== null) {
-        imports.push(match[1]);
-    }
-    // Extract exports
-    const exportPattern = /export\s+(?:default\s+)?(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/gm;
-    while ((match = exportPattern.exec(code)) !== null) {
-        exports.push(match[1]);
-    }
-    // Calculate complexity
-    const nonEmptyLines = lines.filter(l => l.trim().length > 0).length;
-    const commentLines = lines.filter(l => /^\s*(\/\/|\/\*|\*|#)/.test(l)).length;
-    const decisionPoints = (code.match(/\b(if|else|for|while|switch|case|catch|&&|\|\||\?)\b/g) || []).length;
-    let cognitive = 0;
-    let nestingLevel = 0;
-    for (const line of lines) {
-        const opens = (line.match(/\{/g) || []).length;
-        const closes = (line.match(/\}/g) || []).length;
-        if (/\b(if|for|while|switch)\b/.test(line)) {
-            cognitive += 1 + nestingLevel;
-        }
-        nestingLevel = Math.max(0, nestingLevel + opens - closes);
-    }
-    // Detect language
-    const ext = path.extname(filePath).toLowerCase();
-    const language = ext === '.ts' || ext === '.tsx' ? 'typescript' :
-        ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs' ? 'javascript' :
-            ext === '.py' ? 'python' : 'unknown';
-    return {
-        filePath,
-        language,
-        functions,
-        classes,
-        imports,
-        exports,
-        complexity: {
-            cyclomatic: decisionPoints + 1,
-            cognitive,
-            loc: nonEmptyLines,
-            commentDensity: lines.length > 0 ? commentLines / lines.length : 0,
-        },
-    };
-}
-// Main analyze command
-export const analyzeCommand = {
-    name: 'analyze',
-    description: 'Code analysis, diff classification, and change risk assessment',
-    aliases: ['an'],
-    subcommands: [
-        diffCommand,
-        codeCommand,
-        depsCommand,
-        astCommand,
-        complexityAstCommand,
-        symbolsCommand,
-        importsCommand,
-    ],
-    options: [
-        {
-            name: 'format',
-            short: 'f',
-            description: 'Output format: text, json, table',
-            type: 'string',
-            default: 'text',
-        },
-        {
-            name: 'embedding-device',
-            description: 'Embedding device: auto, cpu, cuda, dml, wasm (default: auto)',
-            type: 'string',
-            default: 'auto',
-            choices: ['auto', 'cpu', 'dml', 'cuda', 'wasm'],
-        },
-    ],
-    examples: [
-        { command: 'monomind analyze ast src/', description: 'Analyze code with AST parsing' },
-        { command: 'monomind analyze complexity src/ --threshold 15', description: 'Find high-complexity files' },
-        { command: 'monomind analyze symbols src/ --type function', description: 'Extract all functions' },
-        { command: 'monomind analyze imports src/ --external', description: 'List npm dependencies' },
-        { command: 'monomind analyze diff --risk', description: 'Analyze diff with risk assessment' },
-        { command: 'monomind analyze deps --security', description: 'Check dependency vulnerabilities' },
-    ],
-    action: async (_ctx) => {
-        // If no subcommand, show help
-        output.writeln();
-        output.writeln(output.bold('Analyze Commands'));
-        output.writeln(output.dim('-'.repeat(50)));
-        output.writeln();
-        output.writeln(output.bold('Available subcommands:'));
-        output.writeln();
-        output.writeln(`  ${output.highlight('diff')}         Analyze git diff for change risk and classification`);
-        output.writeln(`  ${output.highlight('code')}         Static code analysis and quality assessment`);
-        output.writeln(`  ${output.highlight('deps')}         Analyze project dependencies`);
-        output.writeln(`  ${output.highlight('ast')}          AST analysis with symbol extraction and complexity`);
-        output.writeln(`  ${output.highlight('complexity')}   Analyze cyclomatic and cognitive complexity`);
-        output.writeln(`  ${output.highlight('symbols')}      Extract functions, classes, and types`);
-        output.writeln(`  ${output.highlight('imports')}      Analyze import dependencies`);
-        output.writeln();
-        output.writeln(output.bold('AST Analysis Examples:'));
-        output.writeln();
-        output.writeln(`  ${output.dim('monomind analyze ast src/')}                  # Full AST analysis`);
-        output.writeln(`  ${output.dim('monomind analyze ast src/index.ts -c')}       # Include complexity`);
-        output.writeln(`  ${output.dim('monomind analyze complexity src/ -t 15')}     # Flag high complexity`);
-        output.writeln(`  ${output.dim('monomind analyze symbols src/ --type fn')}    # Extract functions`);
-        output.writeln(`  ${output.dim('monomind analyze imports src/ --external')}   # Only npm imports`);
-        output.writeln();
-        output.writeln(output.bold('Diff Analysis Examples:'));
-        output.writeln();
-        output.writeln(`  ${output.dim('monomind analyze diff --risk')}              # Risk assessment`);
-        output.writeln(`  ${output.dim('monomind analyze diff HEAD~1 --classify')}   # Classify changes`);
-        output.writeln(`  ${output.dim('monomind analyze diff main..feature')}       # Compare branches`);
-        output.writeln();
-        return { success: true };
-    },
-};
-export default analyzeCommand;
-//# sourceMappingURL=analyze.js.map

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

@@ -1,15 +0,0 @@
-/**
- * CLI Autopilot Command
- * Persistent swarm completion — keeps agents working until ALL tasks are done.
- *
- * ADR-072: Autopilot Integration
- */
-import type { Command } from '../types.js';
-export declare function autopilotCheck(): Promise<{
-    allowStop: boolean;
-    reason: string;
-    continueWith?: string;
-}>;
-export declare const autopilotCommand: Command;
-export default autopilotCommand;
-//# sourceMappingURL=autopilot.d.ts.map

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

@@ -1,370 +0,0 @@
-/**
- * CLI Autopilot Command
- * Persistent swarm completion — keeps agents working until ALL tasks are done.
- *
- * ADR-072: Autopilot Integration
- */
-import { output } from '../output.js';
-import { loadState, saveState, appendLog, loadLog, discoverTasks, getProgress, calculateReward, tryLoadLearning, validateNumber, validateTaskSources, LOG_FILE, } from '../autopilot-state.js';
-import { writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-// ── Check Handler (for Stop hook) ─────────────────────────────
-export async function autopilotCheck() {
-    const state = loadState();
-    if (!state.enabled) {
-        return { allowStop: true, reason: 'Autopilot disabled' };
-    }
-    // Safety: max iterations
-    if (state.iterations >= state.maxIterations) {
-        state.enabled = false;
-        saveState(state);
-        appendLog({ ts: Date.now(), event: 'max-iterations-reached', iterations: state.iterations });
-        return { allowStop: true, reason: `Max iterations (${state.maxIterations}) reached` };
-    }
-    // Safety: timeout
-    const elapsed = Date.now() - state.startTime;
-    if (elapsed > state.timeoutMinutes * 60000) {
-        state.enabled = false;
-        saveState(state);
-        appendLog({ ts: Date.now(), event: 'timeout-reached', elapsed: Math.round(elapsed / 60000) });
-        return { allowStop: true, reason: `Timeout (${state.timeoutMinutes} min) reached` };
-    }
-    // Discover tasks
-    const tasks = discoverTasks(state.taskSources);
-    if (tasks.length === 0) {
-        return { allowStop: true, reason: 'No tasks discovered from any source' };
-    }
-    const progress = getProgress(tasks);
-    if (progress.incomplete.length === 0) {
-        const reward = calculateReward(state.iterations, elapsed);
-        state.enabled = false;
-        saveState(state);
-        appendLog({ ts: Date.now(), event: 'all-tasks-complete', total: progress.total, iterations: state.iterations, durationMs: elapsed, reward });
-        return { allowStop: true, reason: `All ${progress.total} tasks complete (${state.iterations} iterations, reward: ${reward})` };
-    }
-    // Stall detection
-    const recentHistory = state.history.slice(-5);
-    const isStalled = recentHistory.length >= 5 && recentHistory.every(h => h.completed === progress.completed);
-    if (isStalled && state.history.length >= 10) {
-        state.enabled = false;
-        saveState(state);
-        appendLog({ ts: Date.now(), event: 'stall-auto-disable', iterations: state.iterations, completed: progress.completed });
-        return { allowStop: true, reason: `Stalled: no progress in 10 iterations (${progress.completed}/${progress.total} complete)` };
-    }
-    // Re-engage
-    state.iterations++;
-    state.lastCheck = Date.now();
-    state.history.push({ ts: Date.now(), iteration: state.iterations, completed: progress.completed, total: progress.total });
-    saveState(state);
-    const stallWarning = isStalled
-        ? '\nWARNING: No progress in 5 iterations. Consider breaking tasks into smaller subtasks or trying a different approach.'
-        : '';
-    const taskList = progress.incomplete.slice(0, 5).map(t => `- ${t.subject} (${t.status})`).join('\n');
-    const moreCount = progress.incomplete.length > 5 ? `\n... and ${progress.incomplete.length - 5} more` : '';
-    const continuePrompt = [
-        `AUTOPILOT: ${progress.completed}/${progress.total} tasks complete (${progress.percent}%).`,
-        `Iteration ${state.iterations}/${state.maxIterations}.`,
-        `Remaining tasks:\n${taskList}${moreCount}`,
-        stallWarning,
-        `Continue working on the remaining tasks. Do not stop until all are complete.`,
-    ].join('\n');
-    appendLog({ ts: Date.now(), event: 're-engaging', iteration: state.iterations, completed: progress.completed, remaining: progress.incomplete.length });
-    return { allowStop: false, reason: `${progress.incomplete.length}/${progress.total} tasks remaining (iteration ${state.iterations}/${state.maxIterations})`, continueWith: continuePrompt };
-}
-// ── Subcommands ───────────────────────────────────────────────
-const statusCommand = {
-    name: 'status',
-    description: 'Show autopilot state, iterations, and task progress',
-    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON' }],
-    action: async (ctx) => {
-        const state = loadState();
-        const tasks = discoverTasks(state.taskSources);
-        const progress = getProgress(tasks);
-        const elapsed = state.enabled ? Date.now() - state.startTime : 0;
-        if (ctx.flags?.json) {
-            output.printJson({
-                enabled: state.enabled, sessionId: state.sessionId, iterations: state.iterations,
-                maxIterations: state.maxIterations, timeoutMinutes: state.timeoutMinutes, elapsedMs: elapsed,
-                tasks: { completed: progress.completed, total: progress.total, percent: progress.percent },
-                taskSources: state.taskSources,
-            });
-            return { success: true };
-        }
-        output.writeln(`Autopilot: ${state.enabled ? '✓ ENABLED' : '✗ DISABLED'}`);
-        output.writeln(`Session: ${state.sessionId.slice(0, 8)}...`);
-        output.writeln(`Iterations: ${state.iterations}/${state.maxIterations}`);
-        output.writeln(`Timeout: ${state.timeoutMinutes} min`);
-        output.writeln(`Elapsed: ${Math.round(elapsed / 60000)} min`);
-        output.writeln(`Tasks: ${progress.completed}/${progress.total} (${progress.percent}%)`);
-        output.writeln(`Sources: ${state.taskSources.join(', ')}`);
-        if (progress.incomplete.length > 0 && progress.incomplete.length <= 10) {
-            output.writeln('\nRemaining tasks:');
-            for (const t of progress.incomplete) {
-                output.writeln(`  - [${t.source}] ${t.subject} (${t.status})`);
-            }
-        }
-        return { success: true };
-    },
-};
-const enableCommand = {
-    name: 'enable',
-    description: 'Enable persistent completion',
-    action: async () => {
-        const state = loadState();
-        state.enabled = true;
-        state.startTime = Date.now();
-        state.iterations = 0;
-        saveState(state);
-        appendLog({ ts: Date.now(), event: 'enabled', sessionId: state.sessionId, maxIterations: state.maxIterations });
-        output.writeln(output.success(`Autopilot enabled (max ${state.maxIterations} iterations, ${state.timeoutMinutes} min timeout)`));
-        return { success: true };
-    },
-};
-const disableCommand = {
-    name: 'disable',
-    description: 'Disable re-engagement loop',
-    action: async () => {
-        const state = loadState();
-        const wasEnabled = state.enabled;
-        state.enabled = false;
-        saveState(state);
-        if (wasEnabled)
-            appendLog({ ts: Date.now(), event: 'disabled', iterations: state.iterations });
-        output.writeln('Autopilot disabled');
-        return { success: true };
-    },
-};
-const configCommand = {
-    name: 'config',
-    description: 'Configure max iterations, timeout, and task sources',
-    options: [
-        { name: 'max-iterations', type: 'string', description: 'Max re-engagement iterations (1-1000)' },
-        { name: 'timeout', type: 'string', description: 'Timeout in minutes (1-1440)' },
-        { name: 'task-sources', type: 'string', description: 'Comma-separated task sources' },
-    ],
-    action: async (ctx) => {
-        const state = loadState();
-        const maxIter = ctx.flags?.['max-iterations'];
-        const timeout = ctx.flags?.timeout;
-        const sources = ctx.flags?.['task-sources'];
-        if (maxIter)
-            state.maxIterations = validateNumber(maxIter, 1, 1000, state.maxIterations);
-        if (timeout)
-            state.timeoutMinutes = validateNumber(timeout, 1, 1440, state.timeoutMinutes);
-        if (sources) {
-            // Cap total sources string length before splitting to prevent O(n) split on huge input
-            const cappedSources = sources.length > 512 ? sources.slice(0, 512) : sources;
-            state.taskSources = validateTaskSources(cappedSources.split(',').map(s => s.trim()).filter(Boolean));
-        }
-        saveState(state);
-        appendLog({ ts: Date.now(), event: 'config-updated', maxIterations: state.maxIterations, timeoutMinutes: state.timeoutMinutes, taskSources: state.taskSources });
-        output.writeln(`Config updated: maxIterations=${state.maxIterations}, timeout=${state.timeoutMinutes}min, sources=${state.taskSources.join(',')}`);
-        return { success: true };
-    },
-};
-const resetCommand = {
-    name: 'reset',
-    description: 'Reset iteration counter and timer',
-    action: async () => {
-        const state = loadState();
-        state.iterations = 0;
-        state.startTime = Date.now();
-        state.history = [];
-        state.lastCheck = null;
-        saveState(state);
-        appendLog({ ts: Date.now(), event: 'reset' });
-        output.writeln('Autopilot state reset (iterations=0, timer restarted)');
-        return { success: true };
-    },
-};
-const logCommand = {
-    name: 'log',
-    description: 'View autopilot event log',
-    options: [
-        { name: 'last', type: 'string', description: 'Show last N entries' },
-        { name: 'json', type: 'boolean', description: 'Output as JSON' },
-        { name: 'clear', type: 'boolean', description: 'Clear the log' },
-    ],
-    action: async (ctx) => {
-        if (ctx.flags?.clear) {
-            try {
-                writeFileSync(resolve(LOG_FILE), '[]');
-            }
-            catch { /* ignore */ }
-            output.writeln('Autopilot log cleared');
-            return { success: true };
-        }
-        const log = loadLog();
-        const lastRaw = ctx.flags?.last;
-        const last = lastRaw ? validateNumber(lastRaw, 1, 10000, 50) : undefined;
-        const entries = last ? log.slice(-last) : log;
-        if (ctx.flags?.json) {
-            output.printJson(entries);
-            return { success: true };
-        }
-        if (entries.length === 0) {
-            output.writeln('No autopilot events logged');
-            return { success: true };
-        }
-        for (const e of entries) {
-            const time = new Date(e.ts).toISOString().slice(11, 19);
-            const details = Object.entries(e).filter(([k]) => k !== 'ts' && k !== 'event').map(([k, v]) => `${k}=${v}`).join(' ');
-            output.writeln(`[${time}] ${e.event} ${details}`);
-        }
-        return { success: true };
-    },
-};
-const learnCommand = {
-    name: 'learn',
-    description: 'Discover success patterns from past completions',
-    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON' }],
-    action: async (ctx) => {
-        const learning = await tryLoadLearning();
-        if (!learning) {
-            output.writeln('Learning not available (memory backend not initialized). Autopilot still works for task completion tracking.');
-            return { success: true };
-        }
-        const metrics = await learning.getMetrics();
-        const patterns = await learning.discoverSuccessPatterns();
-        if (ctx.flags?.json) {
-            output.printJson({ metrics, patterns });
-            return { success: true };
-        }
-        output.writeln(`Episodes: ${metrics.episodes}`);
-        output.writeln(`Patterns: ${metrics.patterns}`);
-        output.writeln(`Trajectories: ${metrics.trajectories}`);
-        if (patterns.length > 0) {
-            output.writeln('\nDiscovered patterns:');
-            for (const p of patterns) {
-                output.writeln(`  - ${p.pattern} (freq: ${p.frequency}, reward: ${p.avgReward.toFixed(2)})`);
-            }
-        }
-        return { success: true };
-    },
-};
-const historyCommand = {
-    name: 'history',
-    description: 'Search past completion episodes',
-    options: [
-        { name: 'query', type: 'string', description: 'Search query', required: true },
-        { name: 'limit', type: 'string', description: 'Max results (default 10)' },
-        { name: 'json', type: 'boolean', description: 'Output as JSON' },
-    ],
-    action: async (ctx) => {
-        const rawQuery = (ctx.flags?.query || '');
-        const limit = validateNumber(ctx.flags?.limit, 1, 100, 10);
-        if (!rawQuery) {
-            output.writeln('Usage: autopilot history --query "search terms" [--limit N]');
-            return { success: false, message: 'Missing --query' };
-        }
-        if (rawQuery.length > 1024) {
-            output.writeln('Error: --query too long (max 1024 characters)');
-            return { success: false, message: 'Query too long' };
-        }
-        const query = rawQuery;
-        const learning = await tryLoadLearning();
-        if (!learning) {
-            output.writeln('Learning not available. No history to search.');
-            return { success: true };
-        }
-        const results = await learning.recallSimilarTasks(query, limit);
-        if (ctx.flags?.json) {
-            output.printJson(results);
-        }
-        else if (results.length === 0) {
-            output.writeln(`No matching episodes for: "${query}"`);
-        }
-        else {
-            output.printJson(results);
-        }
-        return { success: true };
-    },
-};
-const predictCommand = {
-    name: 'predict',
-    description: 'Predict optimal next action',
-    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON' }],
-    action: async (ctx) => {
-        const state = loadState();
-        const learning = await tryLoadLearning();
-        if (learning) {
-            const prediction = await learning.predictNextAction(state);
-            if (ctx.flags?.json) {
-                output.printJson(prediction);
-            }
-            else {
-                output.writeln(`Action: ${prediction?.action || 'unknown'}`);
-                output.writeln(`Confidence: ${prediction?.confidence || 0}`);
-                if (prediction?.alternatives?.length > 0)
-                    output.writeln(`Alternatives: ${prediction.alternatives.join(', ')}`);
-            }
-            return { success: true };
-        }
-        // Heuristic fallback
-        const tasks = discoverTasks(state.taskSources);
-        const progress = getProgress(tasks);
-        if (progress.incomplete.length === 0) {
-            output.writeln('All tasks complete. No action needed.');
-            return { success: true };
-        }
-        const next = progress.incomplete[0];
-        const result = { action: `Work on: ${next.subject}`, confidence: 0.5, remaining: progress.incomplete.length };
-        if (ctx.flags?.json) {
-            output.printJson(result);
-        }
-        else {
-            output.writeln(`Action: ${result.action}`);
-            output.writeln(`Confidence: ${result.confidence} (heuristic — learning not available)`);
-            output.writeln(`Remaining: ${result.remaining} tasks`);
-        }
-        return { success: true };
-    },
-};
-const checkCommand = {
-    name: 'check',
-    description: 'Run completion check (used by stop hook)',
-    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON' }],
-    action: async (ctx) => {
-        const result = await autopilotCheck();
-        if (ctx.flags?.json) {
-            output.printJson(result);
-        }
-        else {
-            output.writeln(`${result.allowStop ? 'ALLOW STOP' : 'CONTINUE'}: ${result.reason}`);
-        }
-        return { success: true };
-    },
-};
-// ── Main Command ──────────────────────────────────────────────
-export const autopilotCommand = {
-    name: 'autopilot',
-    description: 'Persistent swarm completion — keeps agents working until ALL tasks are done',
-    aliases: ['ap'],
-    subcommands: [statusCommand, enableCommand, disableCommand, configCommand, resetCommand, logCommand, learnCommand, historyCommand, predictCommand, checkCommand],
-    examples: [
-        { command: 'monomind autopilot status', description: 'Show current state and progress' },
-        { command: 'monomind autopilot enable', description: 'Enable persistent completion' },
-        { command: 'monomind autopilot config --max-iterations 100 --timeout 180', description: 'Configure limits' },
-        { command: 'monomind autopilot predict', description: 'Get recommended next action' },
-    ],
-    action: async () => {
-        output.writeln(output.bold('Autopilot — Persistent Swarm Completion'));
-        output.writeln(output.dim('Keeps agents working until ALL tasks are done'));
-        output.writeln();
-        output.printList([
-            'status    — Show state, iterations, and task progress',
-            'enable    — Enable persistent completion',
-            'disable   — Disable re-engagement loop',
-            'config    — Configure max iterations, timeout, sources',
-            'reset     — Reset iteration counter and timer',
-            'log       — View autopilot event log',
-            'learn     — Discover success patterns',
-            'history   — Search past completion episodes',
-            'predict   — Predict optimal next action',
-            'check     — Run completion check (stop hook)',
-        ]);
-        return { success: true };
-    },
-};
-export default autopilotCommand;
-//# sourceMappingURL=autopilot.js.map

package/packages/@monomind/cli/dist/src/commands/browse-action.d.ts

@@ -1,4 +0,0 @@
-import type { Command } from '../types.js';
-export declare const browseActionCommand: Command;
-export default browseActionCommand;
-//# sourceMappingURL=browse-action.d.ts.map