agent-mp 0.1.0 → 0.2.0

package/dist/index.js

@@ -3,32 +3,93 @@ import { Command } from 'commander';
 import * as path from 'path';
 import * as os from 'os';
 import * as fs from 'fs/promises';
-import { runRepl } from './commands/repl.js';
+import * as readline from 'readline';
+import chalk from 'chalk';
+import { AGENT_HOME } from './utils/config.js';
+import { runRepl, runRole } from './commands/repl.js';
+import { setupCommand } from './commands/setup.js';
+import { getLastSessionForDir, listSessions, loadSession } from './utils/sessions.js';
 const program = new Command();
 program
     .name('agent-mp')
     .description('Deterministic multi-agent CLI orchestrator')
-    .version('0.1.0');
-program
-    .option('--reset-coordinator', 'Reset coordinator selection to choose a different CLI')
-    .option('--reset-auth', 'Reset all authentication data');
-program.action(async (options) => {
+    .version('0.1.0')
+    .argument('[task...]', 'Task description or arguments')
+    .option('--continue', 'Resume the last session in the current directory')
+    .option('--resume [id]', 'Resume any saved session by ID (omit ID to pick from list)')
+    .option('--rol <role>', 'Run a specific role directly: orchestrator | implementor | reviewer | coordinator')
+    .option('--reset-coordinator', 'Clear coordinator selection (re-pick on next run)')
+    .option('--reset-auth', 'Wipe all auth credentials and start fresh')
+    .addHelpText('after', `
+Setup subcommands:
+  agent-mp setup init            Full interactive wizard (login + roles + project)
+  agent-mp setup config-multi    Reconfigure all roles at once
+  agent-mp setup orch            Reconfigure orchestrator only
+  agent-mp setup impl            Reconfigure implementor only
+  agent-mp setup rev             Reconfigure reviewer only
+  agent-mp setup explorer        Reconfigure explorer only
+  agent-mp setup proposer        Reconfigure proposer (deliberation)
+  agent-mp setup critic          Reconfigure critic (deliberation)
+  agent-mp setup status          Show current configuration
+
+REPL commands (type inside the session):
+  /help              Show all REPL commands
+  /status            Show roles, auth, and tasks
+  /auth-status       Show login status
+  /setup orch|impl|rev|explorer   Reconfigure a role without leaving the REPL
+  /config-multi      Reconfigure all roles at once
+  /run <task>        Full cycle: orchestrator → implementor → reviewer
+  /run orch <task>   Run only orchestrator
+  /run impl <id>     Run only implementor
+  /run rev <id>      Run only reviewer
+  /login             Login (OAuth)
+  /logout            Logout and clear credentials
+  /models [cli]      List available models
+  /tasks             List all tasks
+  /clear             Clear screen
+  /exit              Exit
+
+Examples:
+  agent-mp                          Start interactive REPL
+  agent-mp --continue               Resume last session in this directory
+  agent-mp --resume                 Pick a saved session from a list
+  agent-mp --resume 2026-04-07_14-30-00   Resume a specific session
+  agent-mp --rol orchestrator "build login system"
+  agent-mp setup orch               Change the orchestrator CLI/model
+`);
+// ── Role-specific binary detection ───────────────────────────────────────────
+const ROLE_BINS = {
+    'agent-orch': 'orchestrator',
+    'agent-impl': 'implementor',
+    'agent-rev': 'reviewer',
+    'agent-explorer': 'explorer',
+};
+const binName = path.basename(process.argv[1]).replace(/\.(js|ts|mjs)$/, '');
+const nativeRole = ROLE_BINS[binName];
+if (nativeRole) {
+    // Role-specific CLI: accept task as positional arg or prompt for it
+    const taskArg = process.argv.slice(2).filter(a => !a.startsWith('-')).join(' ').trim();
+    if (!taskArg) {
+        console.error(chalk.red(`  Usage: ${binName} "<task description or task-id>"`));
+        process.exit(1);
+    }
+    await runRole(nativeRole, taskArg);
+    process.exit(0);
+}
+// ─────────────────────────────────────────────────────────────────────────────
+program.action(async (task, options) => {
     if (options.resetCoordinator || options.resetAuth) {
-        const configDir = path.join(os.homedir(), '.agent-cli');
-        const authFile = path.join(configDir, 'auth.json');
-        const qwenAgentHome = path.join(os.homedir(), '.qwen-agent');
-        const corporateCreds = path.join(qwenAgentHome, 'oauth_creds.json');
+        const authFile = path.join(AGENT_HOME, 'auth.json');
+        const qwenCreds = path.join(AGENT_HOME, 'oauth_creds.json');
         try {
             if (options.resetCoordinator) {
-                // Remove auth file completely to force coordinator re-selection
                 await fs.unlink(authFile).catch(() => { });
-                // Also remove corporate credentials
-                await fs.unlink(corporateCreds).catch(() => { });
+                await fs.unlink(qwenCreds).catch(() => { });
                 console.log('✓ Coordinator reset. Run agent-mp to select a coordinator.');
             }
             if (options.resetAuth) {
-                await fs.rm(configDir, { recursive: true, force: true });
-                await fs.rm(qwenAgentHome, { recursive: true, force: true });
+                await fs.rm(AGENT_HOME, { recursive: true, force: true });
+                await fs.rm(path.join(os.homedir(), '.qwen-agent'), { recursive: true, force: true }).catch(() => { });
                 console.log('✓ All authentication data cleared. Run agent-mp to start fresh.');
             }
         }
@@ -38,6 +99,73 @@ program.action(async (options) => {
         }
         process.exit(0);
     }
+    // --continue: resume last session for current dir
+    if (options.continue) {
+        const session = await getLastSessionForDir(process.cwd());
+        if (!session) {
+            console.log(chalk.yellow('  No previous session found for this directory. Starting fresh.'));
+            runRepl();
+        }
+        else {
+            const date = new Date(session.updatedAt).toLocaleString();
+            console.log(chalk.dim(`  Resuming last session: ${session.id} (${date}, ${session.messages.length} messages)`));
+            runRepl(session);
+        }
+        return;
+    }
+    // --resume [id]: pick or load a specific session
+    if (options.resume !== undefined) {
+        const id = typeof options.resume === 'string' ? options.resume : '';
+        if (id) {
+            const session = await loadSession(id);
+            if (!session) {
+                console.log(chalk.red(`  Session not found: ${id}`));
+                process.exit(1);
+            }
+            runRepl(session);
+        }
+        else {
+            // Show picker
+            const sessions = await listSessions();
+            if (sessions.length === 0) {
+                console.log(chalk.yellow('  No sessions saved yet. Starting fresh.'));
+                runRepl();
+                return;
+            }
+            console.log(chalk.bold.cyan('\n  Saved Sessions\n'));
+            sessions.slice(0, 20).forEach((s, i) => {
+                const date = new Date(s.updatedAt).toLocaleString();
+                const msgs = s.messages.length;
+                const dir = s.dir.replace(os.homedir(), '~');
+                console.log(chalk.dim(`  ${String(i + 1).padStart(2)}. [${date}] ${dir} — ${msgs} messages  (${s.id})`));
+            });
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise((resolve) => rl.question(chalk.bold('\n  Pick session #: '), resolve));
+            rl.close();
+            const num = parseInt(answer.trim());
+            if (isNaN(num) || num < 1 || num > sessions.length) {
+                console.log(chalk.red('  Invalid selection. Starting fresh.'));
+                runRepl();
+                return;
+            }
+            const chosen = sessions[num - 1];
+            console.log(chalk.dim(`  Resuming: ${chosen.id}`));
+            runRepl(chosen);
+        }
+        return;
+    }
+    // --rol flag: run specific role directly
+    if (options.rol) {
+        if (!task || task.length === 0) {
+            console.error('Error: --rol requires an argument (task description or task ID)');
+            process.exit(1);
+        }
+        const arg = task.join(' ');
+        await runRole(options.rol, arg);
+        return;
+    }
+    // Default: start fresh REPL
     runRepl();
 });
+setupCommand(program);
 program.parse();

package/dist/types.d.ts

@@ -1,3 +1,9 @@
+export interface CliRole {
+    cli: string;
+    model: string;
+    cmd: string;
+    fallback?: CliRole;
+}
 export interface AgentConfig {
     project: string;
     description: string;
@@ -15,17 +21,12 @@ export interface AgentConfig {
         stop_on: string;
         output_dir: string;
     };
-    fallbacks: Record<string, CliRole[]>;
+    fallback_global?: CliRole;
     structure: {
         approved_dirs: string[];
         forbidden_dirs: string[];
     };
 }
-export interface CliRole {
-    cli: string;
-    model: string;
-    cmd: string;
-}
 export interface TaskPlan {
     task_id: string;
     description: string;

package/dist/ui/input.d.ts

@@ -0,0 +1,24 @@
+export declare class FixedInput {
+    private buf;
+    private history;
+    private histIdx;
+    private origLog;
+    private get rows();
+    get cols(): number;
+    private get scrollBottom();
+    private _contentRows;
+    setup(): void;
+    teardown(): void;
+    redrawBox(): void;
+    suspend(): () => void;
+    readLine(): Promise<string>;
+    println(text: string): void;
+    printSeparator(): void;
+    /** Set DECSTBM once — only called in setup() and on resize, never during typing. */
+    private _setScrollRegion;
+    /** Blank every row in the reserved area. */
+    private _clearReserved;
+    private _drawBox;
+    /** Split text into visual lines: split on \n, then wrap each segment. */
+    private _wrapText;
+}

package/dist/ui/input.js

@@ -0,0 +1,244 @@
+import chalk from 'chalk';
+// ─── Midas brand colors ──────────────────────────────────────────────────────
+const T = (s) => chalk.rgb(0, 185, 180)(s); // teal  — borders
+const B = (s) => chalk.rgb(30, 110, 185)(s); // blue  — prompt arrow
+const PREFIX = T('│') + B(' > ');
+const PREFIX_CONT = T('│') + B('   '); // continuation lines
+const PREFIX_COLS = 4; // visual width of "│ > " and "│   "
+// Maximum content rows the box can grow to (Shift+Enter / word-wrap).
+// The reserved area at the bottom is MAX_CONTENT_ROWS + 2 (borders).
+const MAX_CONTENT_ROWS = 4;
+const RESERVED_ROWS = MAX_CONTENT_ROWS + 2; // 6
+// ─── FixedInput ──────────────────────────────────────────────────────────────
+// Keeps an input box pinned to the physical bottom of the terminal.
+// The box starts as 3 rows (border + 1 content + border) and grows up to
+// RESERVED_ROWS when the user types multiline text (Shift+Enter) or the
+// text wraps.  The scroll region is set ONCE at setup (and on resize) to
+// [1 .. rows-RESERVED_ROWS] so DECSTBM never fires during normal typing.
+export class FixedInput {
+    buf = '';
+    history = [];
+    histIdx = -1;
+    origLog;
+    get rows() { return process.stdout.rows || 24; }
+    get cols() { return process.stdout.columns || 80; }
+    // The scroll region always ends here — everything below is reserved for the box.
+    get scrollBottom() { return this.rows - RESERVED_ROWS; }
+    // How many content rows the current buffer needs (1 .. MAX_CONTENT_ROWS).
+    _contentRows() {
+        const w = this.cols - PREFIX_COLS - 2;
+        if (w <= 0)
+            return 1;
+        if (!this.buf)
+            return 1;
+        let n = 0;
+        for (const seg of this.buf.split('\n'))
+            n += Math.max(1, Math.ceil((seg.length || 1) / w));
+        return Math.min(n, MAX_CONTENT_ROWS);
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────────────
+    setup() {
+        this.origLog = console.log;
+        console.log = (...args) => {
+            const text = args.map(a => (typeof a === 'string' ? a : String(a))).join(' ');
+            this.println(text);
+        };
+        this._setScrollRegion();
+        process.stdout.write(`\x1b[${this.scrollBottom};1H`);
+        this._clearReserved();
+        this._drawBox();
+        process.stdout.on('resize', () => {
+            this._setScrollRegion();
+            this._clearReserved();
+            this._drawBox();
+        });
+    }
+    teardown() {
+        console.log = this.origLog;
+        process.stdout.write('\x1b[r'); // reset scroll region
+        process.stdout.write('\x1b[?25h'); // show cursor
+        process.stdout.write(`\x1b[${this.rows};1H\n`);
+    }
+    redrawBox() { this._drawBox(); }
+    suspend() {
+        console.log = this.origLog;
+        process.stdout.write('\x1b[r');
+        this._clearReserved();
+        process.stdout.write(`\x1b[${this.scrollBottom};1H`);
+        return () => {
+            console.log = (...args) => {
+                const text = args.map(a => (typeof a === 'string' ? a : String(a))).join(' ');
+                this.println(text);
+            };
+            this._setScrollRegion();
+            this._clearReserved();
+            this._drawBox();
+        };
+    }
+    // ── Input ──────────────────────────────────────────────────────────────────
+    readLine() {
+        this.buf = '';
+        this.histIdx = -1;
+        this._drawBox();
+        return new Promise((resolve) => {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            const done = (line) => {
+                process.stdin.removeListener('data', onData);
+                if (process.stdin.isTTY)
+                    process.stdin.setRawMode(false);
+                this.buf = '';
+                this._drawBox();
+                resolve(line);
+            };
+            const onData = (data) => {
+                const hex = data.toString('hex');
+                const key = data.toString();
+                // ── Shift+Enter → insert newline into buffer ──────────────────
+                // Different terminals send different sequences:
+                if (hex === '5c0d' || // \\\r   (GNOME Terminal, ThinkPad, many Linux)
+                    key === '\x0a' || // LF     (Ctrl+J, some terminals)
+                    hex === '1b5b31333b327e' || // \x1b[13;2~  xterm
+                    hex === '1b5b31333b3275' || // \x1b[13;2u  kitty
+                    hex === '1b4f4d' // \x1bOM       DECNKP
+                ) {
+                    this.buf += '\n';
+                    this._drawBox();
+                    // ── Enter → submit ────────────────────────────────────────────
+                }
+                else if (key === '\r') {
+                    const line = this.buf;
+                    if (line.trim()) {
+                        this.history.unshift(line);
+                        if (this.history.length > 200)
+                            this.history.pop();
+                    }
+                    done(line);
+                }
+                else if (key === '\x7f' || key === '\x08') { // Backspace
+                    if (this.buf.length > 0) {
+                        this.buf = this.buf.slice(0, -1);
+                        this._drawBox();
+                    }
+                }
+                else if (key === '\x03') { // Ctrl+C
+                    this.teardown();
+                    process.exit(0);
+                }
+                else if (key === '\x04') { // Ctrl+D
+                    done('/exit');
+                }
+                else if (key === '\x15') { // Ctrl+U
+                    this.buf = '';
+                    this._drawBox();
+                }
+                else if (hex === '1b5b41') { // Arrow ↑
+                    if (this.histIdx + 1 < this.history.length) {
+                        this.histIdx++;
+                        this.buf = this.history[this.histIdx];
+                        this._drawBox();
+                    }
+                }
+                else if (hex === '1b5b42') { // Arrow ↓
+                    if (this.histIdx > 0) {
+                        this.histIdx--;
+                        this.buf = this.history[this.histIdx];
+                    }
+                    else {
+                        this.histIdx = -1;
+                        this.buf = '';
+                    }
+                    this._drawBox();
+                }
+                else if (key.length >= 1 && key.charCodeAt(0) >= 32 && !key.startsWith('\x1b')) {
+                    this.buf += key;
+                    this._drawBox();
+                }
+            };
+            process.stdin.on('data', onData);
+        });
+    }
+    // ── Output helpers ─────────────────────────────────────────────────────────
+    println(text) {
+        process.stdout.write(`\x1b[${this.scrollBottom};1H`);
+        process.stdout.write(text + '\n');
+        this._drawBox();
+    }
+    printSeparator() {
+        this.println(chalk.rgb(0, 120, 116)('─'.repeat(this.cols - 1)));
+    }
+    // ── Private drawing ────────────────────────────────────────────────────────
+    /** Set DECSTBM once — only called in setup() and on resize, never during typing. */
+    _setScrollRegion() {
+        const sb = this.scrollBottom;
+        if (sb >= 1)
+            process.stdout.write(`\x1b[1;${sb}r`);
+    }
+    /** Blank every row in the reserved area. */
+    _clearReserved() {
+        for (let r = this.scrollBottom + 1; r <= this.rows; r++)
+            process.stdout.write(`\x1b[${r};1H\x1b[2K`);
+    }
+    _drawBox() {
+        const cols = this.cols;
+        const cRows = this._contentRows();
+        const cWidth = cols - PREFIX_COLS - 2;
+        // The box occupies the bottom of the terminal:
+        //   topBorder    = rows - cRows - 1
+        //   content rows = rows - cRows  ...  rows - 1
+        //   bottomBorder = rows
+        const topBorder = this.rows - cRows - 1;
+        // Hide cursor while repainting
+        process.stdout.write('\x1b[?25l');
+        // Clear entire reserved area (removes stale content from previous draws)
+        this._clearReserved();
+        // ── Top border ───────────────────────────────────────────────
+        process.stdout.write(`\x1b[${topBorder};1H`);
+        process.stdout.write(T('╭') + T('─'.repeat(cols - 2)));
+        process.stdout.write(`\x1b[${cols}G` + T('╮'));
+        // ── Content rows ─────────────────────────────────────────────
+        const wrapped = this._wrapText(this.buf, cWidth);
+        const showStart = Math.max(0, wrapped.length - cRows);
+        const visible = wrapped.slice(showStart);
+        for (let i = 0; i < cRows; i++) {
+            const row = topBorder + 1 + i;
+            let line = visible[i] ?? '';
+            // Show overflow indicator when content is clipped above
+            if (i === 0 && showStart > 0)
+                line = '… ' + line.slice(0, Math.max(0, cWidth - 2));
+            else
+                line = line.slice(0, cWidth);
+            const pfx = (i === 0) ? PREFIX : PREFIX_CONT;
+            process.stdout.write(`\x1b[${row};1H`);
+            process.stdout.write(pfx + line);
+            process.stdout.write(`\x1b[${cols}G` + T('│'));
+        }
+        // ── Bottom border ────────────────────────────────────────────
+        process.stdout.write(`\x1b[${this.rows};1H`);
+        process.stdout.write(T('╰') + T('─'.repeat(cols - 2)));
+        process.stdout.write(`\x1b[${cols}G` + T('╯'));
+        // ── Position cursor at end of last visible line ──────────────
+        const lastLine = visible[visible.length - 1] ?? '';
+        const cursorRow = topBorder + cRows; // last content row
+        const cursorCol = PREFIX_COLS + 1 + lastLine.length;
+        process.stdout.write(`\x1b[${cursorRow};${cursorCol}H`);
+        process.stdout.write('\x1b[?25h');
+    }
+    /** Split text into visual lines: split on \n, then wrap each segment. */
+    _wrapText(text, maxWidth) {
+        if (!text)
+            return [''];
+        if (maxWidth <= 0)
+            return [''];
+        const result = [];
+        for (const seg of text.split('\n')) {
+            if (seg.length === 0) {
+                result.push('');
+                continue;
+            }
+            for (let i = 0; i < seg.length; i += maxWidth)
+                result.push(seg.slice(i, i + maxWidth));
+        }
+        return result;
+    }
+}

package/dist/ui/theme.d.ts

@@ -0,0 +1,99 @@
+export declare const theme: {
+    heading: import("chalk").ChalkInstance;
+    emphasis: import("chalk").ChalkInstance;
+    strong: import("chalk").ChalkInstance;
+    inlineCode: import("chalk").ChalkInstance;
+    link: import("chalk").ChalkInstance;
+    quote: import("chalk").ChalkInstance;
+    banner: import("chalk").ChalkInstance;
+    bannerAccent: import("chalk").ChalkInstance;
+    spinnerActive: import("chalk").ChalkInstance;
+    spinnerDone: import("chalk").ChalkInstance;
+    spinnerFailed: import("chalk").ChalkInstance;
+    toolCallBorder: import("chalk").ChalkInstance;
+    toolCallName: import("chalk").ChalkInstance;
+    toolCallSuccess: import("chalk").ChalkInstance;
+    toolCallError: import("chalk").ChalkInstance;
+    dim: import("chalk").ChalkInstance;
+    section: import("chalk").ChalkInstance;
+    success: import("chalk").ChalkInstance;
+    error: import("chalk").ChalkInstance;
+    warning: import("chalk").ChalkInstance;
+    info: import("chalk").ChalkInstance;
+    codeBlockBg: string;
+    codeBlockBorder: import("chalk").ChalkInstance;
+    diffAdd: import("chalk").ChalkInstance;
+    diffRemove: import("chalk").ChalkInstance;
+    teal: import("chalk").ChalkInstance;
+    tealDim: import("chalk").ChalkInstance;
+    midasBlue: import("chalk").ChalkInstance;
+};
+export declare function renderBanner(): string;
+export interface WelcomePanelOpts {
+    version: string;
+    cliName: string;
+    activeModel: string;
+    user: string;
+    project: string;
+    stack: string;
+    roles?: {
+        orchestrator?: string;
+        implementor?: string;
+        reviewer?: string;
+    };
+}
+export declare function renderWelcomePanel(opts: WelcomePanelOpts): string;
+export declare function renderSeparator(): string;
+export declare function renderInputBoxTop(): string;
+export declare function renderInputBoxBottom(): string;
+/** The prompt string that sits on the │ > line */
+export declare function inputPromptStr(): string;
+export declare function renderHelpHint(): string;
+export interface SectionRow {
+    key: string;
+    value: string;
+    keyColor?: (s: string) => string;
+    valueColor?: (s: string) => string;
+}
+export declare function renderSectionBox(title: string, rows: SectionRow[]): string;
+export declare function renderMultiSectionBox(sections: Array<{
+    title: string;
+    rows: SectionRow[];
+}>): string;
+export declare class Spinner {
+    private frame;
+    private label;
+    private interval;
+    private started;
+    constructor(label: string);
+    start(label?: string): void;
+    private tick;
+    private render;
+    succeed(label?: string): void;
+    fail(label?: string): void;
+    private stop;
+}
+export declare function boxTop(label: string): string;
+export declare function boxLine(content: string): string;
+export declare function boxBottom(): string;
+export declare function box(label: string, content: string): string;
+export declare function statusReport(section: string, entries: Array<[string, string]>): string;
+export declare function multiReport(sections: Array<[string, Array<[string, string]>]>): string;
+export declare const emoji: {
+    thinking: string;
+    done: string;
+    failed: string;
+    read: string;
+    write: string;
+    edit: string;
+    search: string;
+    plan: string;
+    review: string;
+    run: string;
+    warning: string;
+    info: string;
+    success: string;
+    error: string;
+    login: string;
+    logout: string;
+};