monomind 2.7.12 → 2.7.14

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

@@ -1,244 +0,0 @@
-import { readdir, readFile } from 'fs/promises';
-import { join } from 'path';
-import { output } from '../output.js';
-const buildSubcommand = {
-    name: 'build',
-    description: 'AI-powered: open a URL, analyze DOM, generate an action JSON file',
-    options: [
-        { name: 'url', short: 'u', type: 'string', description: 'URL to analyze', required: true },
-        { name: 'task', short: 't', type: 'string', description: 'What you want the action to do', required: true },
-        { name: 'port', type: 'number', description: 'CDP port', default: 9222 },
-        { name: 'output', short: 'o', type: 'string', description: 'Output directory', default: '.monomind/actions' },
-    ],
-    action: async (ctx) => {
-        const url = ctx.flags.url;
-        const task = ctx.flags.task;
-        const port = ctx.flags.port ?? 9222;
-        const outDir = join(ctx.cwd, ctx.flags.output ?? '.monomind/actions');
-        if (!url || !task) {
-            output.printError('--url and --task are required');
-            return { success: false, exitCode: 1 };
-        }
-        const { isClaudeCodeAvailable } = await import('../routing/llm-caller.js');
-        if (!isClaudeCodeAvailable()) {
-            output.printError('Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: `Opening ${url}...`, spinner: 'dots' });
-        spinner.start();
-        try {
-            const browser = await import('@monoes/monobrowse');
-            const cdpPort = await browser.launchBrowser({ port, headless: false });
-            const { client, sessionId } = await browser.connectToTarget(cdpPort);
-            spinner.stop('Navigated. Analyzing DOM...');
-            const { analyzeAndBuild } = await import('../browser/action-builder/analyzer.js');
-            const action = await analyzeAndBuild({ url, task, client, sessionId, outputDir: outDir });
-            spinner.succeed(`Action generated: ${action.id}`);
-            output.writeln();
-            output.printBox([
-                `ID: ${action.id}`,
-                `Platform: ${action.platform}`,
-                `Steps: ${action.steps.length}`,
-                `Params: ${action.params.join(', ')}`,
-                `Saved to: ${outDir}/${action.id.replace(/[^a-z0-9_-]/gi, '_')}.json`,
-            ].join('\n'), 'Action Built');
-            client.close();
-            return { success: true, data: action };
-        }
-        catch (err) {
-            spinner.fail('Action build failed');
-            output.printError(err.message);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-const listSubcommand = {
-    name: 'list',
-    aliases: ['ls'],
-    description: 'List available actions (built-in + custom)',
-    action: async (ctx) => {
-        const customDir = join(ctx.cwd, '.monomind', 'actions');
-        let customFiles = [];
-        try {
-            customFiles = (await readdir(customDir)).filter(f => f.endsWith('.json'));
-        }
-        catch { }
-        const builtinActions = [
-            { id: 'linkedin:comment_post', platform: 'linkedin', name: 'Comment on Post', source: 'built-in' },
-            { id: 'linkedin:like_post', platform: 'linkedin', name: 'Like Post', source: 'built-in' },
-            { id: 'linkedin:send_connection', platform: 'linkedin', name: 'Send Connection Request', source: 'built-in' },
-            { id: 'linkedin:publish_post', platform: 'linkedin', name: 'Publish Post', source: 'built-in' },
-            { id: 'instagram:like_post', platform: 'instagram', name: 'Like Post', source: 'built-in' },
-            { id: 'instagram:comment_post', platform: 'instagram', name: 'Comment on Post', source: 'built-in' },
-            { id: 'instagram:follow_user', platform: 'instagram', name: 'Follow User', source: 'built-in' },
-            { id: 'x:like_post', platform: 'x', name: 'Like Post', source: 'built-in' },
-            { id: 'x:reply_post', platform: 'x', name: 'Reply to Post', source: 'built-in' },
-            { id: 'x:follow_user', platform: 'x', name: 'Follow User', source: 'built-in' },
-            { id: 'gemini:submit_prompt', platform: 'gemini', name: 'Submit Prompt', source: 'built-in' },
-        ];
-        const customActions = await Promise.all(customFiles.map(async (f) => {
-            try {
-                const raw = await readFile(join(customDir, f), 'utf8');
-                const def = JSON.parse(raw);
-                return { id: def.id, platform: def.platform ?? 'custom', name: def.name, source: 'custom' };
-            }
-            catch {
-                return null;
-            }
-        }));
-        const all = [...builtinActions, ...customActions.filter(Boolean)];
-        output.printTable({
-            columns: [
-                { key: 'id', header: 'Action ID', width: 30 },
-                { key: 'platform', header: 'Platform', width: 12 },
-                { key: 'name', header: 'Name', width: 25 },
-                { key: 'source', header: 'Source', width: 10 },
-            ],
-            data: all,
-        });
-        return { success: true };
-    },
-};
-const showSubcommand = {
-    name: 'show',
-    description: 'Print an action definition JSON',
-    action: async (ctx) => {
-        const actionId = ctx.args[0];
-        if (!actionId) {
-            output.printError('Action ID required');
-            return { success: false, exitCode: 1 };
-        }
-        const customDir = join(ctx.cwd, '.monomind', 'actions');
-        const filename = actionId.replace(/[^a-z0-9_-]/gi, '_') + '.json';
-        try {
-            const raw = await readFile(join(customDir, filename), 'utf8');
-            output.printJson(JSON.parse(raw));
-            return { success: true };
-        }
-        catch {
-            output.printError(`Action not found: ${actionId}. Check "monomind browse action list".`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-const runSubcommand = {
-    name: 'run',
-    description: 'Run a single action directly',
-    options: [
-        { name: 'account', short: 'a', type: 'string', description: 'Platform account username' },
-        { name: 'params', short: 'p', type: 'array', description: 'Params as key=value pairs' },
-        { name: 'port', type: 'number', description: 'CDP port', default: 9222 },
-    ],
-    action: async (ctx) => {
-        const actionId = ctx.args[0];
-        if (!actionId) {
-            output.printError('Action ID required. Usage: monomind browse action run <action-id>');
-            return { success: false, exitCode: 1 };
-        }
-        const port = ctx.flags.port ?? 9222;
-        const paramsRaw = ctx.flags.params ?? [];
-        const params = {};
-        for (const pair of paramsRaw) {
-            const eq = pair.indexOf('=');
-            if (eq > 0)
-                params[pair.slice(0, eq)] = pair.slice(eq + 1);
-        }
-        const customDir = join(ctx.cwd, '.monomind', 'actions');
-        const filename = actionId.replace(/[^a-z0-9_-]/gi, '_') + '.json';
-        let def;
-        try {
-            def = JSON.parse(await readFile(join(customDir, filename), 'utf8'));
-        }
-        catch {
-            output.printError(`Action not found: ${actionId}. Run "monomind browse action list" to see available actions.`);
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Running action: ${def.id} (${def.steps.length} steps)`);
-        try {
-            const { connectToTarget, openUrl, clickElement, fillElement, evaluateJs, findBySelector, waitFor } = await import('@monoes/monobrowse');
-            const { client, sessionId } = await connectToTarget(port);
-            const refs = new Map();
-            const interpolate = (s) => s.replace(/\{\{(\w+)\}\}/g, (_, k) => params[k] ?? `{{${k}}}`);
-            for (const step of def.steps) {
-                switch (step.type) {
-                    case 'navigate':
-                        await openUrl(client, sessionId, interpolate(step.url));
-                        output.writeln(output.dim(`  navigate -> ${step.url}`));
-                        break;
-                    case 'find':
-                        for (const sel of step.selectors ?? []) {
-                            const found = await findBySelector(client, sessionId, refs, interpolate(sel)).catch(() => null);
-                            if (found) {
-                                refs.set(step.as, found);
-                                break;
-                            }
-                        }
-                        output.writeln(output.dim(`  find -> ${step.as}`));
-                        break;
-                    case 'click': {
-                        const ref = refs.get(step.target);
-                        if (!ref)
-                            throw new Error(`Element "${step.target}" not found`);
-                        await clickElement(client, sessionId, ref);
-                        output.writeln(output.dim(`  click -> ${step.target}`));
-                        break;
-                    }
-                    case 'type': {
-                        const ref = refs.get(step.target);
-                        if (!ref)
-                            throw new Error(`Element "${step.target}" not found`);
-                        await fillElement(client, sessionId, ref, interpolate(step.text));
-                        output.writeln(output.dim(`  type -> ${step.target}`));
-                        break;
-                    }
-                    case 'wait':
-                        if (step.condition === 'network_idle')
-                            await waitFor(client, sessionId, { load: 'networkidle', timeout: step.timeout });
-                        else if (step.condition === 'selector')
-                            await waitFor(client, sessionId, { selector: step.selector, timeout: step.timeout });
-                        else if (step.condition === 'duration')
-                            await new Promise(r => setTimeout(r, step.timeout ?? 1000));
-                        output.writeln(output.dim(`  wait -> ${step.condition}`));
-                        break;
-                    case 'extract': {
-                        const ref = refs.get(step.target);
-                        if (!ref)
-                            throw new Error(`Element "${step.target}" not found`);
-                        const val = await evaluateJs(client, sessionId, `document.querySelector('[data-ref="${ref.ref}"]')?.textContent`);
-                        output.writeln(output.dim(`  extract -> ${step.as}: ${val}`));
-                        break;
-                    }
-                    case 'condition': {
-                        const result = await evaluateJs(client, sessionId, step.expression);
-                        if (result) {
-                            output.writeln(output.dim('  condition -> true branch'));
-                        }
-                        break;
-                    }
-                }
-            }
-            output.printSuccess(`Action ${def.id} completed successfully.`);
-            return { success: true };
-        }
-        catch (err) {
-            output.printError(`Action failed: ${err.message}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-export const browseActionCommand = {
-    name: 'action',
-    description: 'Manage and run browser actions',
-    subcommands: [buildSubcommand, runSubcommand, listSubcommand, showSubcommand],
-    action: async () => {
-        output.writeln(output.bold('browse action — usage:'));
-        output.printList([
-            'monomind browse action build --url <url> --task "description"',
-            'monomind browse action list',
-            'monomind browse action show <action-id>',
-        ]);
-        return { success: true };
-    },
-};
-export default browseActionCommand;
-//# sourceMappingURL=browse-action.js.map

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

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

package/packages/@monomind/cli/dist/src/commands/browse-platform.js

@@ -1,117 +0,0 @@
-import { output } from '../output.js';
-const SUPPORTED_PLATFORMS = ['linkedin', 'instagram', 'x', 'gemini'];
-const connectSubcommand = {
-    name: 'connect',
-    description: 'Open browser, log in to a platform, save session',
-    options: [
-        { name: 'port', type: 'number', description: 'CDP port', default: 9222 },
-    ],
-    action: async (ctx) => {
-        const platform = ctx.args[0];
-        if (!platform || !SUPPORTED_PLATFORMS.includes(platform)) {
-            output.printError(`Platform required: ${SUPPORTED_PLATFORMS.join(', ')}`);
-            return { success: false, exitCode: 1 };
-        }
-        const { getAdapter } = await import('../browser/adapters/index.js');
-        const { saveSession } = await import('../browser/workflow/store.js');
-        const browser = await import('@monoes/monobrowse');
-        const adapter = getAdapter(platform);
-        const port = ctx.flags.port ?? 9222;
-        output.printInfo(`Opening browser → navigating to ${adapter.loginURL()}`);
-        output.printInfo('Please log in. Detection is automatic — checking every 2s...');
-        const cdpPort = await browser.launchBrowser({ port, headless: false });
-        const { client, sessionId } = await browser.connectToTarget(cdpPort);
-        const cdpClient = client;
-        await cdpClient.send('Page.navigate', { url: adapter.loginURL() }, sessionId);
-        const page = {
-            client: cdpClient, sessionId,
-            async evaluate(fn) {
-                const result = await cdpClient.send('Runtime.evaluate', { expression: fn, returnByValue: true }, sessionId);
-                return result.result.value;
-            },
-            async url() {
-                const result = await cdpClient.send('Runtime.evaluate', { expression: 'window.location.href', returnByValue: true }, sessionId);
-                return result.result.value;
-            },
-        };
-        // Poll for login
-        let loggedIn = false;
-        for (let i = 0; i < 30; i++) {
-            await new Promise(r => setTimeout(r, 2000));
-            loggedIn = await adapter.isLoggedIn(page).catch(() => false);
-            if (loggedIn)
-                break;
-            process.stdout.write('.');
-        }
-        process.stdout.write('\n');
-        if (!loggedIn) {
-            output.printError('Login not detected after 60s. Please try again.');
-            client.close();
-            return { success: false, exitCode: 1 };
-        }
-        const username = await adapter.extractUsername(page).catch(() => 'unknown');
-        const cookieResult = await cdpClient.send('Network.getAllCookies', {}, sessionId);
-        const cookies = JSON.stringify(cookieResult.cookies);
-        const sessionId_ = `${platform}:${username}`;
-        await saveSession({ id: sessionId_, platform, username, cookies });
-        output.printSuccess(`Connected ${platform} as ${username} (session saved)`);
-        cdpClient.close();
-        return { success: true };
-    },
-};
-const listSubcommand = {
-    name: 'list',
-    aliases: ['ls'],
-    description: 'List connected platform accounts',
-    action: async () => {
-        const { listSessions } = await import('../browser/workflow/store.js');
-        const sessions = await listSessions();
-        if (sessions.length === 0) {
-            output.printInfo('No connected accounts. Use: monomind browse platform connect <platform>');
-            return { success: true };
-        }
-        output.printTable({
-            columns: [
-                { key: 'platform', header: 'Platform', width: 12 },
-                { key: 'username', header: 'Username', width: 25 },
-                { key: 'lastUsedAt', header: 'Last Used', width: 20,
-                    format: (v) => new Date(v).toLocaleString() },
-                { key: 'id', header: 'Session ID', width: 30 },
-            ],
-            data: sessions,
-        });
-        return { success: true };
-    },
-};
-const disconnectSubcommand = {
-    name: 'disconnect',
-    description: 'Remove a saved platform session',
-    action: async (ctx) => {
-        const sessionId = ctx.args[0];
-        if (!sessionId) {
-            output.printError('Session ID required. Use "monomind browse platform list" to see IDs.');
-            return { success: false, exitCode: 1 };
-        }
-        const { deleteSession } = await import('../browser/workflow/store.js');
-        await deleteSession(sessionId);
-        output.printSuccess(`Session removed: ${sessionId}`);
-        return { success: true };
-    },
-};
-export const browsePlatformCommand = {
-    name: 'platform',
-    description: 'Manage platform connections (linkedin, instagram, x, gemini)',
-    subcommands: [connectSubcommand, listSubcommand, disconnectSubcommand],
-    action: async () => {
-        output.writeln(output.bold('browse platform — usage:'));
-        output.printList([
-            'monomind browse platform connect <platform>',
-            'monomind browse platform list',
-            'monomind browse platform disconnect <session-id>',
-        ]);
-        output.writeln(`\nPlatforms: ${SUPPORTED_PLATFORMS.join(', ')}`);
-        return { success: true };
-    },
-};
-export default browsePlatformCommand;
-//# sourceMappingURL=browse-platform.js.map

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

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

package/packages/@monomind/cli/dist/src/commands/browse-workflow.js

@@ -1,183 +0,0 @@
-import { writeFile, mkdir } from 'fs/promises';
-import { join, resolve, isAbsolute } from 'path';
-import { output } from '../output.js';
-import { input } from '../prompt.js';
-const createSubcommand = {
-    name: 'create',
-    description: 'Scaffold a new workflow JSON file',
-    options: [
-        { name: 'output', short: 'o', type: 'string', description: 'Output directory', default: '.monomind/workflows' },
-    ],
-    action: async (ctx) => {
-        const name = ctx.args[0] ?? (ctx.interactive ? await input({ message: 'Workflow name:' }) : undefined);
-        if (!name || !/^[a-zA-Z0-9_-]{1,64}$/.test(name)) {
-            output.printError('Workflow name required (alphanumeric, dash, underscore, max 64 chars)');
-            return { success: false, exitCode: 1 };
-        }
-        const outDir = join(ctx.cwd, ctx.flags.output ?? '.monomind/workflows');
-        await mkdir(outDir, { recursive: true });
-        const filePath = join(outDir, `${name}.json`);
-        const template = {
-            id: name, name: name.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
-            nodes: [
-                { id: 'trigger', type: 'trigger.manual', config: {} },
-                { id: 'action1', type: 'action.linkedin.comment_post',
-                    config: { post_url: '{{$json.url}}', text: '{{$json.comment}}', account: '{{$env.LINKEDIN_USER}}' } },
-            ],
-            connections: [{ from: 'trigger', to: 'action1' }],
-        };
-        await writeFile(filePath, JSON.stringify(template, null, 2));
-        output.printSuccess(`Created ${filePath}`);
-        output.printInfo('Edit the file, then run: monomind browse workflow run ' + filePath);
-        return { success: true };
-    },
-};
-const runSubcommand = {
-    name: 'run',
-    description: 'Execute a workflow JSON file',
-    options: [
-        { name: 'no-dashboard', type: 'boolean', description: 'Skip opening web dashboard', default: false },
-        { name: 'port', type: 'number', description: 'Dashboard port', default: 4243 },
-        { name: 'items', short: 'i', type: 'string', description: 'JSON file of input items array' },
-    ],
-    action: async (ctx) => {
-        const rawPath = ctx.args[0];
-        if (!rawPath) {
-            output.printError('Workflow file required: monomind browse workflow run <file.json>');
-            return { success: false, exitCode: 1 };
-        }
-        const filePath = isAbsolute(rawPath) ? rawPath : resolve(ctx.cwd, rawPath);
-        const { readWorkflow } = await import('../browser/workflow/store.js');
-        const { runWorkflow } = await import('../browser/workflow/engine.js');
-        const { getDashboardServer } = await import('../browser/dashboard/server.js');
-        const wf = await readWorkflow(filePath).catch(e => { output.printError(e.message); return null; });
-        if (!wf)
-            return { success: false, exitCode: 1 };
-        // --items feeds the run's input set. Previously the flag was parsed and
-        // then dropped, so every run silently used the single empty default item.
-        let items;
-        const itemsFlag = ctx.flags.items;
-        if (itemsFlag) {
-            const itemsPath = isAbsolute(itemsFlag) ? itemsFlag : resolve(ctx.cwd, itemsFlag);
-            let parsed;
-            try {
-                const { readFile } = await import('fs/promises');
-                parsed = JSON.parse(await readFile(itemsPath, 'utf8'));
-            }
-            catch (e) {
-                output.printError(`Cannot read items file ${itemsPath}: ${e.message}`);
-                return { success: false, exitCode: 1 };
-            }
-            if (!Array.isArray(parsed)) {
-                output.printError(`Items file ${itemsPath} must contain a JSON array`);
-                return { success: false, exitCode: 1 };
-            }
-            // Accept both the engine's `{ data: {...} }` envelope and a bare array
-            // of objects, which is the shape people naturally write by hand.
-            items = parsed.map((entry) => {
-                const rec = entry;
-                return rec && typeof rec === 'object' && 'data' in rec && typeof rec.data === 'object' && rec.data !== null
-                    ? { data: rec.data }
-                    : { data: (rec ?? {}) };
-            });
-            output.printInfo(`Loaded ${items.length} input item(s) from ${itemsFlag}`);
-        }
-        const port = ctx.flags.port ?? 4243;
-        const dashboard = getDashboardServer(port);
-        if (!ctx.flags['no-dashboard']) {
-            output.printInfo(`Dashboard: http://localhost:${dashboard.port}`);
-            const { exec } = await import('child_process');
-            exec(`open http://localhost:${dashboard.port}`).unref();
-        }
-        output.writeln(output.bold(`Running: ${wf.name}`));
-        const spinner = output.createSpinner({ text: 'Executing...', spinner: 'dots' });
-        spinner.start();
-        const record = await runWorkflow(wf, {
-            onEvent: (ev) => dashboard.broadcast(ev),
-            ...(items ? { items } : {}),
-        });
-        if (record.status === 'completed') {
-            spinner.succeed(`Done — ${record.itemsProcessed} items in ${((record.completedAt - record.startedAt) / 1000).toFixed(1)}s`);
-        }
-        else {
-            spinner.fail(`${record.status}${record.error ? ': ' + record.error : ''}`);
-        }
-        return { success: record.status === 'completed' };
-    },
-};
-const listSubcommand = {
-    name: 'list',
-    aliases: ['ls'],
-    description: 'List recent workflow runs',
-    action: async (ctx) => {
-        const { listRuns } = await import('../browser/workflow/store.js');
-        const runs = await listRuns();
-        if (runs.length === 0) {
-            output.printInfo('No runs found');
-            return { success: true };
-        }
-        output.printTable({
-            columns: [
-                { key: 'id', header: 'Run ID', width: 12 },
-                { key: 'workflowName', header: 'Workflow', width: 20 },
-                { key: 'status', header: 'Status', width: 10 },
-                { key: 'itemsProcessed', header: 'Items', width: 8, align: 'right' },
-                { key: 'startedAt', header: 'Started', width: 20,
-                    format: (v) => new Date(v).toLocaleString() },
-            ],
-            data: runs,
-        });
-        return { success: true };
-    },
-};
-const statusSubcommand = {
-    name: 'status',
-    description: 'Show status of a specific run',
-    action: async (ctx) => {
-        const runId = ctx.args[0];
-        if (!runId) {
-            output.printError('Run ID required');
-            return { success: false, exitCode: 1 };
-        }
-        const { listRuns } = await import('../browser/workflow/store.js');
-        const runs = await listRuns();
-        const run = runs.find(r => r.id.startsWith(runId));
-        if (!run) {
-            output.printError(`Run not found: ${runId}`);
-            return { success: false, exitCode: 1 };
-        }
-        output.printBox([
-            `ID: ${run.id}`, `Workflow: ${run.workflowName}`, `Status: ${run.status}`,
-            `Items: ${run.itemsProcessed}/${run.itemsTotal}`,
-            `Started: ${new Date(run.startedAt).toLocaleString()}`,
-            run.completedAt ? `Completed: ${new Date(run.completedAt).toLocaleString()}` : '',
-            run.error ? `Error: ${run.error}` : '',
-        ].filter(Boolean).join('\n'), 'Run Status');
-        return { success: true };
-    },
-};
-const stopSubcommand = {
-    name: 'stop',
-    description: 'Stop a running workflow (sends abort signal)',
-    action: async (ctx) => {
-        output.printInfo('Stop is handled via the dashboard Stop button or Ctrl-C in the running terminal.');
-        return { success: true };
-    },
-};
-export const browseWorkflowCommand = {
-    name: 'workflow',
-    description: 'Browser workflow automation (create, run, list, status)',
-    subcommands: [createSubcommand, runSubcommand, listSubcommand, statusSubcommand, stopSubcommand],
-    action: async () => {
-        output.writeln(output.bold('browse workflow — usage:'));
-        output.printList([
-            'monomind browse workflow create <name>',
-            'monomind browse workflow run <file.json>',
-            'monomind browse workflow list',
-            'monomind browse workflow status <run-id>',
-        ]);
-        return { success: true };
-    },
-};
-export default browseWorkflowCommand;
-//# sourceMappingURL=browse-workflow.js.map

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

@@ -1,12 +0,0 @@
-declare const browseCommand: {
-    name: string;
-    description: string;
-    aliases?: string[];
-    options?: import("@monoes/monobrowse/cli/types").CommandOption[];
-    examples?: import("@monoes/monobrowse/cli/types").CommandExample[];
-    action?: import("@monoes/monobrowse/cli/types").CommandAction;
-    hidden?: boolean;
-    subcommands: import("../types.js").Command[];
-};
-export default browseCommand;
-//# sourceMappingURL=browse.d.ts.map

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

@@ -1,17 +0,0 @@
-import browseBase from '@monoes/monobrowse/cli/commands';
-import { browseWorkflowCommand } from './browse-workflow.js';
-import { browseActionCommand } from './browse-action.js';
-import { browsePlatformCommand } from './browse-platform.js';
-const REPLACED = new Set(['workflow', 'action', 'platform']);
-// Augment the base browse command with workflow/action/platform subcommands
-const browseCommand = {
-    ...browseBase,
-    subcommands: [
-        ...(browseBase.subcommands ?? []).filter(s => !REPLACED.has(s.name)),
-        browseWorkflowCommand,
-        browseActionCommand,
-        browsePlatformCommand,
-    ],
-};
-export default browseCommand;
-//# sourceMappingURL=browse.js.map

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

@@ -1,45 +0,0 @@
-/**
- * CLI Cleanup Command
- * Removes project artifacts created by monomind/monomind
- *
- * github.com/monoes/monomind
- */
-import type { Command } from '../types.js';
-/** A single stale-scratch candidate returned by {@link findStaleScratch}. */
-interface StaleScratchItem {
-    path: string;
-    description: string;
-    size: number;
-}
-/**
- * Find prunable entries under the per-project data base (default
- * ~/.monomind/projects). Exported for tests — `baseDir`/`now` injectable.
- *
- * Classification per dir:
- * - `origin.json` present and its recorded path still exists → keep the dir,
- *   but flag a leftover `lancedb/` subdir (dead since the SQLite engine swap).
- * - `origin.json` present, recorded path gone → orphaned → prune.
- * - no `origin.json` (pre-2.3.1 dirs can't prove their origin) → prune only
- *   when untouched for {@link UNKNOWN_DIR_MAX_AGE_MS} — or immediately with
- *   `--aggressive`, which treats unprovable dirs as junk (safe: every live
- *   project rewrites origin.json on its next memory access).
- */
-export declare function findOrphanedProjectData(baseDir: string, now: number, aggressive: boolean): StaleScratchItem[];
-/**
- * Find stale mastermind scratch under `.monomind/taskdev/` and `.monomind/loops/`.
- * Exported for tests. Never returns `progress.md` (the taskdev recovery ledger),
- * directories, or loop JSON it cannot parse — deleting the unclassifiable loses data.
- *
- * A loop JSON is only ever classified as abandoned when it has a real, positive,
- * numeric `nextRunAt` timestamp that is more than a day in the past. Live producers
- * write `nextRunAt: 0` (real /do loops) or `nextRunAt: null` (dashboard) — those,
- * along with missing/non-numeric values, are never eligible for deletion regardless
- * of `status`, since a crashed daemon can leave a stale `status: 'running'` behind.
- */
-export declare function findStaleScratch(cwd: string, now: number): StaleScratchItem[];
-/**
- * Cleanup command definition
- */
-export declare const cleanupCommand: Command;
-export default cleanupCommand;
-//# sourceMappingURL=cleanup.d.ts.map