agent-rev 0.1.0

package/dist/core/prompts.d.ts

@@ -0,0 +1,11 @@
+import { TaskPlan } from '../types.js';
+export declare function orchestratorSystem(): string;
+export declare function orchestratorUser(taskId: string, task: string, context: string): string;
+export declare function implementorSystem(approved: string[], forbidden: string[]): string;
+export declare function implementorUser(taskId: string, plan: TaskPlan): string;
+export declare function reviewerSystem(): string;
+export declare function reviewerUser(taskId: string, plan: TaskPlan, progressSummary: string): string;
+export declare function proposerSystem(): string;
+export declare function proposerUser(task: string, question: string, prevRounds: string): string;
+export declare function criticSystem(): string;
+export declare function criticUser(task: string, question: string, proposal: string, prevCritiques: string): string;

package/dist/core/prompts.js

@@ -0,0 +1,126 @@
+export function orchestratorSystem() {
+    return `Sos el ORCHESTRATOR de un sistema multi-agente. Tu UNICO trabajo es planificar.
+
+REGLAS:
+- NO ejecutar codigo
+- NO crear archivos fuera de .agent/tasks/
+- NO instalar dependencias
+- NO modificar archivos existentes
+- Solo planificar y escribir JSON
+
+Tu output debe ser SOLO JSON valido, sin markdown, sin explicaciones.`;
+}
+export function orchestratorUser(taskId, task, context) {
+    return `TAREA: ${task}
+ID: ${taskId}
+
+CONTEXTO:
+${context}
+
+Responde SOLO con este JSON:
+{
+  "plan": {
+    "task_id": "${taskId}",
+    "description": "${task}",
+    "steps": [
+      {"num": 1, "description": "paso detallado", "files": ["ruta/archivo"], "status": "pending"}
+    ],
+    "acceptance_criteria": ["criterio verificable 1", "criterio verificable 2"],
+    "deliberation": {"needed": false, "question": ""}
+  },
+  "progress": {
+    "task_id": "${taskId}",
+    "created_at": "${new Date().toISOString()}",
+    "steps": [],
+    "status": "planned"
+  }
+}
+
+Cada step debe ser atomico. Los criterios deben ser verificables.`;
+}
+export function implementorSystem(approved, forbidden) {
+    return `Sos el IMPLEMENTOR. Tu UNICO trabajo es ejecutar el plan.
+
+REGLAS:
+- NO modificar plan.json
+- NO crear archivos no contemplados en el plan
+- Seguir el plan exactamente
+- Actualizar progress.json con timestamps
+
+APROBADOS: ${approved.join(', ')}
+PROHIBIDOS: ${forbidden.join(', ')}
+
+Tu output debe ser SOLO JSON valido con el progress actualizado.`;
+}
+export function implementorUser(taskId, plan) {
+    return `EJECUTA ESTE PLAN:
+Task: ${taskId}
+${JSON.stringify(plan, null, 2)}
+
+Por cada step completado, cambia status a "completed" y agrega completed_at.
+Al terminar todos los steps, status = "completed".
+
+Responde SOLO con el JSON de progress actualizado.`;
+}
+export function reviewerSystem() {
+    return `Sos el REVIEWER. Tu UNICO trabajo es validar.
+
+REGLAS:
+- NO modificar codigo
+- NO implementar correcciones
+- Solo validar y reportar
+
+Tu output debe ser SOLO JSON valido.`;
+}
+export function reviewerUser(taskId, plan, progressSummary) {
+    return `VALIDA ESTA TAREA:
+Task: ${taskId}
+
+PLAN:
+${JSON.stringify({ description: plan.description, criteria: plan.acceptance_criteria }, null, 2)}
+
+PROGRESO:
+${progressSummary}
+
+Responde SOLO con:
+{
+  "result": {
+    "task_id": "${taskId}",
+    "criteria": [{"criterion": "...", "status": "PASS", "notes": "..."}],
+    "verdict": "PASS",
+    "explanation": "..."
+  },
+  "validation": {
+    "status": "PASS",
+    "reviewed_at": "${new Date().toISOString()}",
+    "reviewer": "reviewer"
+  }
+}
+
+Verdict = "PASS" si TODOS los criterios se cumplen, "FAIL" si alguno falla.`;
+}
+export function proposerSystem() {
+    return `Sos el PROPOSER en un debate tecnico. Generas propuestas con justificacion tecnica.
+Responde SOLO con JSON valido.`;
+}
+export function proposerUser(task, question, prevRounds) {
+    return `TAREA: ${task}
+PREGUNTA: ${question}
+${prevRounds ? 'RONDAS ANTERIORES:\n' + prevRounds : 'Primera ronda.'}
+
+Responde SOLO con:
+{"proposal": "...", "justification": "...", "trade_offs": ["..."], "accept": false}`;
+}
+export function criticSystem() {
+    return `Sos el CRITIC en un debate tecnico. Buscas debilidades, edge cases y errores.
+Responde SOLO con JSON valido.`;
+}
+export function criticUser(task, question, proposal, prevCritiques) {
+    return `TAREA: ${task}
+PREGUNTA: ${question}
+PROPUESTA: ${proposal}
+${prevCritiques ? 'CRITICAS ANTERIORES:\n' + prevCritiques : ''}
+
+Responde SOLO con:
+{"analysis": "...", "weaknesses": ["..."], "edge_cases": ["..."], "suggestions": ["..."], "verdict": "ACCEPT"}`;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs/promises';
+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')
+    .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 authFile = path.join(AGENT_HOME, 'auth.json');
+        const qwenCreds = path.join(AGENT_HOME, 'oauth_creds.json');
+        try {
+            if (options.resetCoordinator) {
+                await fs.unlink(authFile).catch(() => { });
+                await fs.unlink(qwenCreds).catch(() => { });
+                console.log('✓ Coordinator reset. Run agent-mp to select a coordinator.');
+            }
+            if (options.resetAuth) {
+                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.');
+            }
+        }
+        catch (err) {
+            console.error('Error resetting:', err.message);
+            process.exit(1);
+        }
+        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/providers/index.d.ts

@@ -0,0 +1,2 @@
+import { RoleConfig, ChatResponse } from '../types.js';
+export declare function chat(role: RoleConfig, systemPrompt: string, userPrompt: string): Promise<ChatResponse>;

package/dist/providers/index.js

@@ -0,0 +1,120 @@
+import OpenAI from 'openai';
+import { Anthropic } from '@anthropic-ai/sdk';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { loadAuth } from '../commands/auth.js';
+function detectProvider(model) {
+    const m = model.toLowerCase();
+    if (m.startsWith('gpt') || m.startsWith('o1') || m.startsWith('o3') || m.startsWith('o4'))
+        return 'openai';
+    if (m.startsWith('claude'))
+        return 'anthropic';
+    if (m.startsWith('gemini'))
+        return 'google';
+    if (m.includes('/'))
+        return 'opencode';
+    return 'openai';
+}
+async function getAuthToken(provider) {
+    // 1. Check env vars
+    const envKey = process.env[`${provider.toUpperCase()}_API_KEY`];
+    if (envKey)
+        return envKey;
+    // 2. Check OAuth auth store
+    try {
+        const auth = await loadAuth();
+        const entry = auth.entries.find((e) => e.provider === provider) ||
+            auth.entries.find((e) => e.provider === auth.activeProvider);
+        if (entry?.accessToken)
+            return entry.accessToken;
+        if (entry?.apiKey)
+            return entry.apiKey;
+    }
+    catch { }
+    return undefined;
+}
+async function buildClient(role) {
+    const provider = role.provider || detectProvider(role.model);
+    const token = await getAuthToken(provider);
+    switch (provider) {
+        case 'openai':
+            return { type: 'openai', client: new OpenAI({ apiKey: token }) };
+        case 'anthropic':
+            return { type: 'anthropic', client: new Anthropic({ apiKey: token }) };
+        case 'google':
+            return { type: 'google', client: new GoogleGenerativeAI(token || '') };
+        case 'opencode': {
+            // Opencode uses an OpenAI-compatible API
+            const baseURL = process.env.OPENCODE_BASE_URL || 'https://api.opencode.ai/v1';
+            return { type: 'opencode', client: new OpenAI({ apiKey: token || '', baseURL }) };
+        }
+        default:
+            throw new Error(`Unknown provider: ${provider}`);
+    }
+}
+export async function chat(role, systemPrompt, userPrompt) {
+    const client = await buildClient(role);
+    switch (client.type) {
+        case 'openai':
+        case 'opencode':
+            return chatOpenai(client.client, role.model, systemPrompt, userPrompt);
+        case 'anthropic':
+            return chatAnthropic(client.client, role.model, systemPrompt, userPrompt);
+        case 'google':
+            return chatGoogle(client.client, role.model, systemPrompt, userPrompt);
+    }
+}
+async function chatOpenai(client, model, system, user) {
+    const res = await client.chat.completions.create({
+        model,
+        messages: [
+            { role: 'system', content: system },
+            { role: 'user', content: user },
+        ],
+    });
+    const content = res.choices[0]?.message?.content || '';
+    const usage = res.usage;
+    return {
+        content,
+        usage: {
+            input_tokens: usage?.prompt_tokens || 0,
+            output_tokens: usage?.completion_tokens || 0,
+            cache_read_input_tokens: 0,
+        },
+    };
+}
+async function chatAnthropic(client, model, system, user) {
+    const res = await client.messages.create({
+        model,
+        system,
+        max_tokens: 8192,
+        messages: [{ role: 'user', content: user }],
+    });
+    const content = res.content
+        .filter((b) => b.type === 'text')
+        .map((b) => b.text)
+        .join('\n');
+    return {
+        content,
+        usage: {
+            input_tokens: res.usage?.input_tokens || 0,
+            output_tokens: res.usage?.output_tokens || 0,
+            cache_read_input_tokens: res.usage?.cache_read_input_tokens || 0,
+        },
+    };
+}
+async function chatGoogle(client, model, system, user) {
+    const genModel = client.getGenerativeModel({ model });
+    const result = await genModel.generateContent({
+        contents: [{ role: 'user', parts: [{ text: `${system}\n\n---\n\n${user}` }] }],
+    });
+    const text = result.response.text();
+    const usageMetadata = result.response.usageMetadata;
+    return {
+        content: text,
+        usage: {
+            input_tokens: usageMetadata?.promptTokenCount || 0,
+            output_tokens: usageMetadata?.candidatesTokenCount || 0,
+            cache_read_input_tokens: 0,
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,73 @@
+export interface CliRole {
+    cli: string;
+    model: string;
+    cmd: string;
+    fallback?: CliRole;
+}
+export interface AgentConfig {
+    project: string;
+    description: string;
+    stack: string;
+    roles: {
+        orchestrator: CliRole;
+        implementor: CliRole;
+        reviewer: CliRole;
+        explorer?: CliRole;
+    };
+    deliberation?: {
+        proposer: CliRole;
+        critic: CliRole;
+        max_rounds: number;
+        stop_on: string;
+        output_dir: string;
+    };
+    fallback_global?: CliRole;
+    structure: {
+        approved_dirs: string[];
+        forbidden_dirs: string[];
+    };
+}
+export interface TaskPlan {
+    task_id: string;
+    description: string;
+    steps: TaskStep[];
+    acceptance_criteria: string[];
+    deliberation: {
+        needed: boolean;
+        question: string;
+        resolved?: boolean;
+        rounds?: number;
+    };
+}
+export interface TaskStep {
+    num: number;
+    description: string;
+    files: string[];
+    status: 'pending' | 'completed' | 'failed';
+    completed_at?: string;
+}
+export interface TaskProgress {
+    task_id: string;
+    created_at: string;
+    steps: TaskStep[];
+    status: string;
+    validation?: {
+        status: 'PASS' | 'FAIL';
+        reviewed_at: string;
+        reviewer: string;
+    };
+}
+export interface TokenUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_input_tokens: number;
+}
+export interface CliInfo {
+    name: string;
+    command: string;
+    modelFlag: string;
+    extraFlags: string;
+    promptFlag: string;
+    promptPosition: 'flag' | 'arg';
+}
+export declare const CLI_REGISTRY: Record<string, CliInfo>;

package/dist/types.js

@@ -0,0 +1,58 @@
+export const CLI_REGISTRY = {
+    claude: {
+        name: 'Claude',
+        command: 'claude',
+        modelFlag: '--model',
+        extraFlags: '--dangerously-skip-permissions --output-format json',
+        promptFlag: '-p',
+        promptPosition: 'flag',
+    },
+    qwen: {
+        name: 'Qwen',
+        command: 'qwen',
+        modelFlag: '-m',
+        extraFlags: '-y -o json',
+        promptFlag: '-p',
+        promptPosition: 'flag',
+    },
+    gemini: {
+        name: 'Gemini',
+        command: 'gemini',
+        modelFlag: '-m',
+        extraFlags: '-y -o json',
+        promptFlag: '-p',
+        promptPosition: 'flag',
+    },
+    codex: {
+        name: 'Codex',
+        command: 'codex',
+        modelFlag: '-m',
+        extraFlags: 'exec',
+        promptFlag: '',
+        promptPosition: 'arg',
+    },
+    cn: {
+        name: 'CN',
+        command: 'cn',
+        modelFlag: '--model',
+        extraFlags: '--auto',
+        promptFlag: '-p',
+        promptPosition: 'flag',
+    },
+    opencode: {
+        name: 'Opencode',
+        command: 'opencode',
+        modelFlag: '-m',
+        extraFlags: '',
+        promptFlag: '',
+        promptPosition: 'arg',
+    },
+    aider: {
+        name: 'Aider',
+        command: 'aider',
+        modelFlag: '--model',
+        extraFlags: '--yes',
+        promptFlag: '-p',
+        promptPosition: 'flag',
+    },
+};

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;
+}