monomind 1.10.0 → 1.10.2

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

@@ -0,0 +1,180 @@
+/**
+ * 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

@@ -0,0 +1,133 @@
+/**
+ * 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