monomind 1.9.16 → 1.10.0

package/packages/@monomind/cli/dist/src/orchestration/routing-modes.js

@@ -1,180 +0,0 @@
-/**
- * Three-Mode Team Routing — Task 22
- *
- * Provides three orchestration modes:
- *  - route:       single-agent dispatch
- *  - coordinate:  planner → fan-out → synthesizer
- *  - collaborate: iterative A↔B with shared scratchpad
- */
-import { SharedScratchpad } from '../../../shared/src/scratchpad.js';
-// ---------------------------------------------------------------------------
-// Abstract executor
-// ---------------------------------------------------------------------------
-const SLUG_RE = /^[a-z0-9][a-z0-9\-]{0,63}$/;
-const MAX_TASK_BYTES = 64 * 1024;
-function assertSlug(value, name) {
-    if (!SLUG_RE.test(value))
-        throw new Error(`Invalid agent slug for ${name}: ${JSON.stringify(value)}`);
-}
-function assertTask(task) {
-    if (!task || task.trim().length === 0)
-        throw new Error('task must not be empty');
-    if (task.length > MAX_TASK_BYTES)
-        throw new Error(`task exceeds maximum length (${MAX_TASK_BYTES} bytes)`);
-}
-export class ModeExecutor {
-    dispatcher;
-    constructor(dispatcher) {
-        this.dispatcher = dispatcher;
-    }
-}
-// ---------------------------------------------------------------------------
-// Route mode — single dispatch
-// ---------------------------------------------------------------------------
-export class RouteModeExecutor extends ModeExecutor {
-    async execute(config) {
-        assertSlug(config.agentSlug, 'agentSlug');
-        assertTask(config.task);
-        const start = Date.now();
-        const result = await this.dispatcher.dispatch(config.agentSlug, config.task);
-        return {
-            mode: 'route',
-            output: result.output,
-            agentsInvolved: [config.agentSlug],
-            iterationCount: 1,
-            tokenUsage: result.tokenUsage ?? { input: 0, output: 0 },
-            latencyMs: Date.now() - start,
-        };
-    }
-}
-// ---------------------------------------------------------------------------
-// Coordinate mode — planner → fan-out → synthesizer
-// ---------------------------------------------------------------------------
-/**
- * Extract a subtasks array from the planner output.
- * Accepts either a raw array or JSON containing a `subtasks` key.
- */
-export function parsePlan(output) {
-    if (Array.isArray(output))
-        return output.map(String);
-    const raw = typeof output === 'string' ? output : JSON.stringify(output);
-    try {
-        const parsed = JSON.parse(raw);
-        if (Array.isArray(parsed))
-            return parsed.map(String);
-        if (parsed !== null && typeof parsed === 'object' && Array.isArray(parsed.subtasks))
-            return parsed.subtasks.map(String);
-    }
-    catch {
-        // not JSON — treat the whole string as a single subtask
-    }
-    return [raw];
-}
-export class CoordinateModeExecutor extends ModeExecutor {
-    async execute(config) {
-        assertTask(config.task);
-        const start = Date.now();
-        const plannerSlug = config.plannerSlug ?? 'planner';
-        const synthesizerSlug = config.synthesizerSlug ?? 'hierarchical-coordinator';
-        assertSlug(plannerSlug, 'plannerSlug');
-        assertSlug(synthesizerSlug, 'synthesizerSlug');
-        const maxSubtasks = config.maxSubtasks ?? 8;
-        const totalTokens = { input: 0, output: 0 };
-        const agents = [plannerSlug];
-        // 1. Call planner
-        const planResult = await this.dispatcher.dispatch(plannerSlug, config.task);
-        this.addTokens(totalTokens, planResult.tokenUsage);
-        // 2. Parse subtasks & cap
-        const subtasks = parsePlan(planResult.output).slice(0, maxSubtasks);
-        // 3. Fan-out
-        const fanOutResults = await Promise.all(subtasks.map((subtask, i) => {
-            const workerSlug = `worker-${i}`;
-            agents.push(workerSlug);
-            return this.dispatcher.dispatch(workerSlug, subtask);
-        }));
-        for (const r of fanOutResults)
-            this.addTokens(totalTokens, r.tokenUsage);
-        // 4. Synthesize
-        agents.push(synthesizerSlug);
-        const synthesisContext = JSON.stringify(fanOutResults.map((r) => r.output));
-        const synthResult = await this.dispatcher.dispatch(synthesizerSlug, 'Synthesize the following results', synthesisContext);
-        this.addTokens(totalTokens, synthResult.tokenUsage);
-        return {
-            mode: 'coordinate',
-            output: synthResult.output,
-            agentsInvolved: agents,
-            iterationCount: 1 + subtasks.length + 1, // planner + workers + synthesizer
-            tokenUsage: totalTokens,
-            latencyMs: Date.now() - start,
-        };
-    }
-    addTokens(total, usage) {
-        if (usage) {
-            total.input += usage.input;
-            total.output += usage.output;
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Collaborate mode — iterative A↔B with shared scratchpad
-// ---------------------------------------------------------------------------
-export class CollaborateModeExecutor extends ModeExecutor {
-    async execute(config) {
-        assertTask(config.task);
-        assertSlug(config.agentA, 'agentA');
-        assertSlug(config.agentB, 'agentB');
-        const start = Date.now();
-        // Cap iterations: each iteration costs 2 LLM dispatches; an unbounded value
-        // turns this into an unbounded token-cost / OOM vector.
-        const maxIterations = Math.max(1, Math.min(config.maxIterations ?? 5, 20));
-        // Reject empty/short convergence phrase — empty string would make
-        // String(bResult.output).includes('') return true on iteration 1, bypassing
-        // the entire iterative review and locking in whatever Agent B produced.
-        const rawPhrase = (config.convergencePhrase ?? 'APPROVED').trim();
-        const convergencePhrase = rawPhrase.length >= 3 ? rawPhrase : 'APPROVED';
-        const pad = new SharedScratchpad();
-        const totalTokens = { input: 0, output: 0 };
-        let lastOutput;
-        for (let i = 0; i < maxIterations; i++) {
-            // Agent A
-            const aResult = await this.dispatcher.dispatch(config.agentA, config.task, pad.read());
-            pad.append(config.agentA, String(aResult.output));
-            this.addTokens(totalTokens, aResult.tokenUsage);
-            // Agent B
-            const bResult = await this.dispatcher.dispatch(config.agentB, config.task, pad.read());
-            pad.append(config.agentB, String(bResult.output));
-            this.addTokens(totalTokens, bResult.tokenUsage);
-            lastOutput = bResult.output;
-            // Convergence check — require the phrase as a stand-alone token so that
-            // an attacker who controls Agent A's output cannot embed `APPROVED` in
-            // prose and force premature convergence on iteration 1.
-            const escaped = convergencePhrase.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const convergenceRe = new RegExp(`(^|\\W)${escaped}(\\W|$)`);
-            if (convergenceRe.test(String(bResult.output))) {
-                return {
-                    mode: 'collaborate',
-                    output: lastOutput,
-                    agentsInvolved: [config.agentA, config.agentB],
-                    iterationCount: i + 1,
-                    tokenUsage: totalTokens,
-                    latencyMs: Date.now() - start,
-                };
-            }
-        }
-        return {
-            mode: 'collaborate',
-            output: lastOutput,
-            agentsInvolved: [config.agentA, config.agentB],
-            iterationCount: maxIterations,
-            tokenUsage: totalTokens,
-            latencyMs: Date.now() - start,
-        };
-    }
-    addTokens(total, usage) {
-        if (usage) {
-            total.input += usage.input;
-            total.output += usage.output;
-        }
-    }
-}
-//# sourceMappingURL=routing-modes.js.map

package/packages/@monomind/cli/dist/src/output.d.ts

@@ -1,133 +0,0 @@
-/**
- * CLI Output Formatter
- * Advanced output formatting with tables, progress bars, and colors
- */
-import type { TableOptions, ProgressOptions, SpinnerOptions } from './types.js';
-declare const COLORS: {
-    readonly reset: "\u001B[0m";
-    readonly bold: "\u001B[1m";
-    readonly dim: "\u001B[2m";
-    readonly italic: "\u001B[3m";
-    readonly underline: "\u001B[4m";
-    readonly black: "\u001B[30m";
-    readonly red: "\u001B[31m";
-    readonly green: "\u001B[32m";
-    readonly yellow: "\u001B[33m";
-    readonly blue: "\u001B[34m";
-    readonly magenta: "\u001B[35m";
-    readonly cyan: "\u001B[36m";
-    readonly white: "\u001B[37m";
-    readonly gray: "\u001B[90m";
-    readonly brightRed: "\u001B[91m";
-    readonly brightGreen: "\u001B[92m";
-    readonly brightYellow: "\u001B[93m";
-    readonly brightBlue: "\u001B[94m";
-    readonly brightMagenta: "\u001B[95m";
-    readonly brightCyan: "\u001B[96m";
-    readonly brightWhite: "\u001B[97m";
-    readonly bgBlack: "\u001B[40m";
-    readonly bgRed: "\u001B[41m";
-    readonly bgGreen: "\u001B[42m";
-    readonly bgYellow: "\u001B[43m";
-    readonly bgBlue: "\u001B[44m";
-    readonly bgMagenta: "\u001B[45m";
-    readonly bgCyan: "\u001B[46m";
-    readonly bgWhite: "\u001B[47m";
-};
-type ColorName = keyof typeof COLORS;
-export type VerbosityLevel = 'quiet' | 'normal' | 'verbose' | 'debug';
-export declare class OutputFormatter {
-    private colorEnabled;
-    private outputStream;
-    private errorStream;
-    private verbosity;
-    constructor(options?: {
-        color?: boolean;
-        verbosity?: VerbosityLevel;
-    });
-    /**
-     * Set verbosity level
-     * - quiet: Only errors and direct results
-     * - normal: Errors, warnings, info, and results
-     * - verbose: All of normal + debug messages
-     * - debug: All output including trace
-     */
-    setVerbosity(level: VerbosityLevel): void;
-    getVerbosity(): VerbosityLevel;
-    isQuiet(): boolean;
-    isVerbose(): boolean;
-    isDebug(): boolean;
-    private supportsColor;
-    color(text: string, ...colors: ColorName[]): string;
-    bold(text: string): string;
-    dim(text: string): string;
-    success(text: string): string;
-    error(text: string): string;
-    warning(text: string): string;
-    info(text: string): string;
-    highlight(text: string): string;
-    write(text: string): void;
-    writeln(text?: string): void;
-    writeError(text: string): void;
-    writeErrorln(text?: string): void;
-    printSuccess(message: string): void;
-    printError(message: string, details?: string): void;
-    printWarning(message: string): void;
-    printInfo(message: string): void;
-    printDebug(message: string): void;
-    printTrace(message: string): void;
-    table(options: TableOptions): string;
-    printTable(options: TableOptions): void;
-    private calculateColumnWidths;
-    private createBorderLine;
-    private alignText;
-    private truncate;
-    private stripAnsi;
-    createProgress(options: ProgressOptions): Progress;
-    progressBar(current: number, total: number, width?: number): string;
-    createSpinner(options: SpinnerOptions): Spinner;
-    json(data: unknown, pretty?: boolean): string;
-    printJson(data: unknown, pretty?: boolean): void;
-    list(items: string[], bullet?: string): string;
-    printList(items: string[], bullet?: string): void;
-    numberedList(items: string[]): string;
-    printNumberedList(items: string[]): void;
-    box(content: string, title?: string): string;
-    printBox(content: string, title?: string): void;
-    setColorEnabled(enabled: boolean): void;
-    isColorEnabled(): boolean;
-}
-export declare class Progress {
-    private current;
-    private total;
-    private width;
-    private startTime;
-    private formatter;
-    private showPercentage;
-    private showETA;
-    private lastRender;
-    constructor(formatter: OutputFormatter, options: ProgressOptions);
-    update(current: number): void;
-    increment(amount?: number): void;
-    render(): void;
-    finish(): void;
-    private formatTime;
-}
-export declare class Spinner {
-    private formatter;
-    private text;
-    private frames;
-    private interval;
-    private frameIndex;
-    private static readonly SPINNERS;
-    constructor(formatter: OutputFormatter, options: SpinnerOptions);
-    start(): void;
-    stop(message?: string): void;
-    succeed(message?: string): void;
-    fail(message?: string): void;
-    private render;
-    setText(text: string): void;
-}
-export declare const output: OutputFormatter;
-export {};
-//# sourceMappingURL=output.d.ts.map