agent-mp 0.4.14 → 0.5.0

package/dist/commands/repl.js

@@ -233,7 +233,7 @@ function detectModels(cliName) {
                     }
                     catch { }
                 }
-                return [`run: ${cliName} --login`];
+                return ['coder-model'];
             }
             default: return ['default'];
         }
@@ -1136,11 +1136,11 @@ export async function runRepl(resumeSession) {
  * Prompt estricto: cada rol solo hace lo que debe, sin extras.
  */
 export async function runRole(role, arg, model) {
-    const init = await initCoordinator();
-    if (!init)
-        process.exit(1);
-    const { coordinatorCmd } = init;
-    const rl = init.rl;
+    const { PKG_NAME, getConfigDir } = await import('../utils/config.js');
+    // Detect if running a native role binary directly (agent-orch, agent-impl, etc.)
+    // In that case, skip REPL and run headless — no coordinator needed
+    const ROLE_BINS = new Set(['agent-orch', 'agent-impl', 'agent-rev', 'agent-explorer']);
+    const isNativeBin = ROLE_BINS.has(PKG_NAME);
     const dir = process.cwd();
     let config;
     try {
@@ -1148,13 +1148,11 @@ export async function runRole(role, arg, model) {
     }
     catch {
         console.log(chalk.red('  No project config found. Run /setup first.'));
-        rl.close();
         process.exit(1);
     }
     // Validate roles are configured
     if (!config.roles?.orchestrator?.cli || !config.roles?.implementor?.cli || !config.roles?.reviewer?.cli) {
         console.log(chalk.red('  Roles not configured. Run setup first.'));
-        rl.close();
         process.exit(1);
     }
     // Override model if passed via --model flag
@@ -1170,7 +1168,60 @@ export async function runRole(role, arg, model) {
             r.cmd = r.cmd.replace(/(-m|--model)\s+\S+/, `$1 ${model}`);
         }
     }
-    console.log(chalk.bold.cyan(`\n  Agent-mp — Rol: ${role.toUpperCase()}${model ? ` (${model})` : ''}\n`));
+    console.log(chalk.bold.cyan(`\n  ${PKG_NAME} — Rol: ${role.toUpperCase()}${model ? ` (${model})` : ''}\n`));
+    if (isNativeBin) {
+        // Headless mode: create a dummy RL (no stdin), run engine directly
+        const { Readable } = await import('stream');
+        const emptyStream = new Readable({ read() { this.push(null); } });
+        const dummyRl = readline.createInterface({ input: emptyStream, output: process.stdout });
+        const engine = new AgentEngine(config, dir, '', dummyRl);
+        try {
+            switch (role.toLowerCase()) {
+                case 'orchestrator':
+                case 'orch': {
+                    const result = await engine.runOrchestrator(arg);
+                    log.ok(`Task ID: ${result.taskId}`);
+                    break;
+                }
+                case 'implementor':
+                case 'impl': {
+                    const taskDir = path.join(dir, '.agent', 'tasks', arg);
+                    const plan = await readJson(path.join(taskDir, 'plan.json'));
+                    await engine.runImplementor(arg, plan);
+                    break;
+                }
+                case 'reviewer':
+                case 'rev': {
+                    const taskDir = path.join(dir, '.agent', 'tasks', arg);
+                    const plan = await readJson(path.join(taskDir, 'plan.json'));
+                    const progress = await readJson(path.join(taskDir, 'progress.json'));
+                    await engine.runReviewer(arg, plan, progress);
+                    break;
+                }
+                case 'explorer':
+                case 'exp': {
+                    const result = await engine.runExplorer(arg);
+                    log.ok(`Explorer: ${result.substring(0, 100)}...`);
+                    break;
+                }
+                default:
+                    console.log(chalk.red(`  Unknown role: ${role}. Use: orchestrator, implementor, reviewer, explorer`));
+                    process.exit(1);
+            }
+        }
+        catch (err) {
+            console.log(chalk.red(`  Error: ${err.message}`));
+            process.exit(1);
+        }
+        dummyRl.close();
+        return;
+    }
+    // REPL mode: needs coordinator
+    const init = await initCoordinator();
+    if (!init)
+        process.exit(1);
+    const { coordinatorCmd } = init;
+    const rl = init.rl;
     const engine = new AgentEngine(config, dir, coordinatorCmd, rl);
     try {
         switch (role.toLowerCase()) {
@@ -1195,6 +1246,12 @@ export async function runRole(role, arg, model) {
                 await engine.runReviewer(arg, plan, progress);
                 break;
             }
+            case 'explorer':
+            case 'exp': {
+                const result = await engine.runExplorer(arg);
+                log.ok(`Explorer: ${result.substring(0, 100)}...`);
+                break;
+            }
             case 'coordinator':
             case 'coord': {
                 console.log(chalk.yellow('  Coordinator mode requires interactive REPL.'));
@@ -1202,7 +1259,7 @@ export async function runRole(role, arg, model) {
                 process.exit(1);
             }
             default:
-                console.log(chalk.red(`  Unknown role: ${role}. Use: orchestrator, implementor, reviewer`));
+                console.log(chalk.red(`  Unknown role: ${role}. Use: orchestrator, implementor, reviewer, explorer`));
                 process.exit(1);
         }
     }

package/dist/commands/setup.js

@@ -73,7 +73,7 @@ function detectModels(cliName) {
                     }
                     catch { }
                 }
-                return [`run: ${cliName} --login`];
+                return ['coder-model'];
             }
             default:
                 return ['default'];

package/dist/index.js

@@ -137,7 +137,7 @@ if (nativeRole) {
     if (modelIdx !== -1 && args[modelIdx + 1]) {
         model = args[modelIdx + 1];
     }
-    const taskArg = args.filter((a, i) => !a.startsWith('-') && i !== modelIdx + 1).join(' ').trim();
+    const taskArg = args.filter((a, i) => !a.startsWith('-') && (modelIdx === -1 || i !== modelIdx + 1)).join(' ').trim();
     if (!taskArg) {
         console.log(chalk.bold.cyan(`\n  ${PKG_NAME} — ${nativeRole} agent\n`));
         console.log(chalk.dim(`  Usage:   ${PKG_NAME} [--model <model>] "<task>"`));

package/dist/utils/qwen-auth.js

@@ -42,9 +42,10 @@ async function loadToken() {
         };
         if (!token.accessToken)
             return null;
-        // Refresh proactivo: si vence en menos de 2 minutos (o ya venció)
-        const TWO_MIN = 2 * 60 * 1000;
-        if (token.expiresAt - Date.now() < TWO_MIN && token.refreshToken) {
+        // Refresh proactivo: si vence en menos de 5 minutos (o ya venció)
+        // Mismo threshold que el CLI original de qwen
+        const FIVE_MIN = 5 * 60 * 1000;
+        if (token.expiresAt - Date.now() < FIVE_MIN && token.refreshToken) {
             const refreshed = await doRefreshToken(token.refreshToken);
             if (refreshed) {
                 await saveToken(refreshed);
@@ -253,45 +254,41 @@ export async function getQwenAccessToken() {
     return token?.accessToken || null;
 }
 async function callQwenAPIWithToken(token, prompt, model, onData) {
-    // Use resource_url from token (e.g. "portal.qwen.ai"), fallback to DashScope
+    // Build base URL from token's resource_url (same logic as qwen CLI original)
     const rawHost = token.resourceUrl || 'dashscope.aliyuncs.com/compatible-mode';
-    const host = rawHost.startsWith('http') ? rawHost : `https://${rawHost}`;
-    const baseUrl = host.endsWith('/v1') ? host : `${host}/v1`;
+    const baseUrl = rawHost.startsWith('http')
+        ? (rawHost.endsWith('/v1') ? rawHost : rawHost.replace(/\/$/, '') + '/v1')
+        : `https://${rawHost}/v1`;
     const useStream = !!onData;
-    const userAgent = `QwenCode/0.14.2 (${process.platform}; ${process.arch})`;
-    // portal.qwen.ai requires: content parts format + system message (plain strings → 400, no system → 400)
-    const toContentParts = (text) => [{ type: 'text', text }];
+    // portal.qwen.ai requires: content as array of {type, text} objects + system message
+    // DashScope accepts: plain string content
+    const isPortalQwen = rawHost.includes('portal.qwen.ai') || rawHost.includes('chat.qwen.ai');
+    const toContent = (text) => isPortalQwen ? [{ type: 'text', text }] : text;
     const response = await fetch(`${baseUrl}/chat/completions`, {
         method: 'POST',
         headers: {
             'Authorization': `Bearer ${token.accessToken}`,
             'Content-Type': 'application/json',
             'Accept': 'application/json',
-            'User-Agent': userAgent,
-            'x-dashscope-authtype': 'qwen-oauth',
-            'x-dashscope-cachecontrol': 'enable',
-            'x-dashscope-useragent': userAgent,
-            'x-stainless-lang': 'js',
-            'x-stainless-package-version': '5.11.0',
-            'x-stainless-os': process.platform,
-            'x-stainless-arch': process.arch,
-            'x-stainless-runtime': 'node',
-            'x-stainless-runtime-version': process.version,
-            'x-stainless-retry-count': '0',
+            'User-Agent': `QwenCode/0.14.2 (${process.platform}; ${process.arch})`,
+            'X-DashScope-AuthType': 'qwen-oauth',
+            'X-DashScope-CacheControl': 'enable',
+            'X-DashScope-UserAgent': `QwenCode/0.14.2 (${process.platform}; ${process.arch})`,
         },
         body: JSON.stringify({
             model: model || 'coder-model',
             messages: [
-                { role: 'system', content: toContentParts('You are a helpful coding assistant.') },
-                { role: 'user', content: toContentParts(prompt) },
+                { role: 'system', content: toContent('You are a helpful coding assistant.') },
+                { role: 'user', content: toContent(prompt) },
             ],
             stream: useStream,
         }),
     });
     if (!response.ok) {
         const errorText = await response.text();
-        if (response.status === 401)
+        if (response.status === 401 || (response.status === 429 && errorText.includes('insufficient_quota'))) {
             throw new Error(`QWEN_AUTH_EXPIRED: ${errorText}`);
+        }
         throw new Error(`Qwen API error: ${response.status} - ${errorText}`);
     }
     if (!useStream) {
@@ -380,8 +377,9 @@ export async function callQwenAPIFromCreds(prompt, model, credsPath, onData) {
     if (!token.accessToken) {
         throw new Error(`Invalid credentials at ${credsPath}. Run: ${cliName} --login`);
     }
-    const TWO_MIN = 2 * 60 * 1000;
-    if (token.expiresAt - Date.now() < TWO_MIN && token.refreshToken) {
+    // Refresh proactivo: mismo threshold de 5 minutos que el CLI original
+    const FIVE_MIN = 5 * 60 * 1000;
+    if (token.expiresAt - Date.now() < FIVE_MIN && token.refreshToken) {
         const refreshed = await doRefreshToken(token.refreshToken);
         if (refreshed) {
             token = refreshed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-mp",
-  "version": "0.4.14",
+  "version": "0.5.0",
   "description": "Deterministic multi-agent CLI orchestrator — plan, code, review",
   "type": "module",
   "main": "./dist/index.js",

package/dist/api/qwen.d.ts

@@ -1,12 +0,0 @@
-interface QwenMessage {
-    role: 'system' | 'user' | 'assistant';
-    content: string;
-}
-export declare function qwenLogin(): Promise<boolean>;
-export declare function qwenAuthStatus(): Promise<{
-    authenticated: boolean;
-    email?: string;
-}>;
-export declare function qwenChat(messages: QwenMessage[], model?: string): Promise<string>;
-export declare function qwenAsk(prompt: string, model?: string): Promise<string>;
-export {};

package/dist/api/qwen.js

@@ -1,150 +0,0 @@
-import axios from 'axios';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import open from 'open';
-const QWEN_API_BASE = 'https://dashscope-intl.aliyuncs.com/api/v1';
-const QWEN_AUTH_URL = 'https://oauth.aliyun.com/v1/oauth/authorize';
-const CLIENT_ID = 'your_client_id'; // Reemplazar con el client ID real de Qwen
-const REDIRECT_URI = 'http://localhost:3000/callback';
-let tokenCache = null;
-async function getTokenPath() {
-    const homeDir = os.homedir();
-    const dir = path.join(homeDir, '.agent');
-    await fs.mkdir(dir, { recursive: true });
-    return path.join(dir, 'qwen-token.json');
-}
-async function loadToken() {
-    try {
-        const tokenPath = await getTokenPath();
-        const content = await fs.readFile(tokenPath, 'utf-8');
-        const token = JSON.parse(content);
-        if (token.expiresAt > Date.now()) {
-            return token;
-        }
-        // Token expirado, intentar refresh
-        if (token.refreshToken) {
-            return refreshAccessToken(token.refreshToken);
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-async function saveToken(token) {
-    const tokenPath = await getTokenPath();
-    await fs.writeFile(tokenPath, JSON.stringify(token, null, 2), 'utf-8');
-}
-async function refreshAccessToken(refreshToken) {
-    try {
-        const response = await axios.post('https://oauth.aliyun.com/v1/oauth/token', new URLSearchParams({
-            grant_type: 'refresh_token',
-            refresh_token: refreshToken,
-            client_id: CLIENT_ID,
-        }), {
-            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-        });
-        const token = {
-            accessToken: response.data.access_token,
-            refreshToken: response.data.refresh_token || refreshToken,
-            expiresAt: Date.now() + (response.data.expires_in || 3600) * 1000,
-        };
-        await saveToken(token);
-        return token;
-    }
-    catch (error) {
-        console.error('Error refreshing token:', error);
-        return null;
-    }
-}
-export async function qwenLogin() {
-    const authUrl = `${QWEN_AUTH_URL}?client_id=${CLIENT_ID}&redirect_uri=${encodeURIComponent(REDIRECT_URI)}&response_type=code&scope=api`;
-    console.log('Abriendo navegador para autenticación con Qwen...');
-    console.log('URL:', authUrl);
-    await open(authUrl);
-    console.log('');
-    console.log('Por favor completá la autenticación en el navegador.');
-    console.log('Cuando obtengas el código de autorización, ingresalo abajo:');
-    return new Promise((resolve) => {
-        const readline = await import('readline');
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.question('Código de autorización: ', async (code) => {
-            try {
-                const response = await axios.post('https://oauth.aliyun.com/v1/oauth/token', new URLSearchParams({
-                    grant_type: 'authorization_code',
-                    code,
-                    redirect_uri: REDIRECT_URI,
-                    client_id: CLIENT_ID,
-                }), {
-                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-                });
-                const token = {
-                    accessToken: response.data.access_token,
-                    refreshToken: response.data.refresh_token,
-                    expiresAt: Date.now() + (response.data.expires_in || 3600) * 1000,
-                };
-                await saveToken(token);
-                console.log('¡Autenticación exitosa!');
-                rl.close();
-                resolve(true);
-            }
-            catch (error) {
-                console.error('Error en autenticación:', error);
-                rl.close();
-                resolve(false);
-            }
-        });
-    });
-}
-export async function qwenAuthStatus() {
-    const token = await loadToken();
-    if (token) {
-        return { authenticated: true };
-    }
-    return { authenticated: false };
-}
-export async function qwenChat(messages, model = 'qwen-coder') {
-    const token = await loadToken();
-    if (!token) {
-        throw new Error('No hay token de Qwen. Ejecutá /qwen-login primero.');
-    }
-    try {
-        const response = await axios.post(`${QWEN_API_BASE}/services/aigc/text-generation/generation`, {
-            model,
-            input: {
-                messages,
-            },
-            parameters: {
-                result_format: 'text',
-            },
-        }, {
-            headers: {
-                'Authorization': `Bearer ${token.accessToken}`,
-                'Content-Type': 'application/json',
-            },
-        });
-        return response.data.output.text;
-    }
-    catch (error) {
-        if (error.response?.status === 401) {
-            // Token inválido, intentar refresh
-            const newToken = token.refreshToken ? await refreshAccessToken(token.refreshToken) : null;
-            if (newToken) {
-                // Reintentar con el nuevo token
-                return qwenChat(messages, model);
-            }
-        }
-        throw error;
-    }
-}
-export async function qwenAsk(prompt, model = 'qwen-coder') {
-    const messages = [
-        { role: 'system', content: 'Sos un asistente útil de programación.' },
-        { role: 'user', content: prompt },
-    ];
-    return qwenChat(messages, model);
-}

package/dist/commands/auth.d.ts

@@ -1,31 +0,0 @@
-import { Command } from 'commander';
-declare const CONFIG_DIR: string;
-declare const CONFIG_FILE: string;
-interface AuthEntry {
-    provider: string;
-    method: 'oauth' | 'apikey';
-    accessToken?: string;
-    refreshToken?: string;
-    expiresAt?: number;
-    apiKey?: string;
-    email?: string;
-}
-interface AuthStore {
-    entries: AuthEntry[];
-    activeProvider?: string;
-}
-interface CliConfig {
-    roles: Record<string, {
-        provider: string;
-        model: string;
-    }>;
-    deliberation: {
-        enabled: boolean;
-        max_rounds: number;
-    };
-}
-declare function loadAuth(): Promise<AuthStore>;
-declare function loadCliConfig(): Promise<CliConfig>;
-declare function saveCliConfig(cfg: CliConfig): Promise<void>;
-export declare function authCommand(program: Command): void;
-export { loadAuth, loadCliConfig, saveCliConfig, CONFIG_DIR, CONFIG_FILE };

package/dist/commands/auth.js

@@ -1,255 +0,0 @@
-import * as readline from 'readline';
-import * as path from 'path';
-import * as fs from 'fs/promises';
-import { createServer } from 'http';
-import { createHash, randomBytes } from 'crypto';
-import open from 'open';
-import chalk from 'chalk';
-import { writeJson, ensureDir } from '../utils/fs.js';
-const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.agent-cli');
-const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-// ── OAuth providers ────────────────────────────────────────────────────────
-const OAUTH_PROVIDERS = {
-    opencode: {
-        authorizeUrl: 'https://accounts.opencode.ai/oauth2/auth',
-        tokenUrl: 'https://accounts.opencode.ai/oauth2/token',
-        clientId: 'claw_code',
-        scopes: 'openid email profile offline_access',
-        name: 'Opencode',
-    },
-    google: {
-        authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
-        tokenUrl: 'https://oauth2.googleapis.com/token',
-        clientId: '',
-        scopes: 'openid email profile',
-        name: 'Google',
-    },
-};
-async function loadAuth() {
-    try {
-        const content = await fs.readFile(AUTH_FILE, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return { entries: [] };
-    }
-}
-async function saveAuth(auth) {
-    await ensureDir(CONFIG_DIR);
-    await writeJson(AUTH_FILE, auth);
-}
-async function loadCliConfig() {
-    try {
-        const content = await fs.readFile(CONFIG_FILE, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return { roles: {}, deliberation: { enabled: false, max_rounds: 4 } };
-    }
-}
-async function saveCliConfig(cfg) {
-    await ensureDir(CONFIG_DIR);
-    await writeJson(CONFIG_FILE, cfg);
-}
-function base64url(buf) {
-    return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
-}
-async function oauthFlow(providerId) {
-    const provider = OAUTH_PROVIDERS[providerId];
-    if (!provider)
-        throw new Error(`Unknown OAuth provider: ${providerId}`);
-    const port = 9800 + Math.floor(Math.random() * 1000);
-    const state = base64url(randomBytes(32));
-    const codeVerifier = base64url(randomBytes(32));
-    const codeChallenge = base64url(createHash('sha256').update(codeVerifier).digest());
-    const redirectUri = `http://127.0.0.1:${port}/callback`;
-    const authUrl = new URL(provider.authorizeUrl);
-    authUrl.searchParams.set('response_type', 'code');
-    authUrl.searchParams.set('client_id', provider.clientId);
-    authUrl.searchParams.set('redirect_uri', redirectUri);
-    authUrl.searchParams.set('scope', provider.scopes);
-    authUrl.searchParams.set('state', state);
-    authUrl.searchParams.set('code_challenge', codeChallenge);
-    authUrl.searchParams.set('code_challenge_method', 'S256');
-    console.log(chalk.dim(`  Opening browser for ${provider.name} login...`));
-    await open(authUrl.toString());
-    return new Promise((resolve, reject) => {
-        const server = createServer((req, res) => {
-            const url = new URL(req.url, `http://127.0.0.1:${port}`);
-            if (url.pathname !== '/callback') {
-                res.writeHead(404);
-                res.end();
-                return;
-            }
-            const returnedState = url.searchParams.get('state');
-            const code = url.searchParams.get('code');
-            const error = url.searchParams.get('error');
-            if (error) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end(`<h1>Login failed</h1><p>${error}</p>`);
-                server.close();
-                reject(new Error(`OAuth error: ${error}`));
-                return;
-            }
-            if (returnedState !== state) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end('<h1>Invalid state</h1>');
-                server.close();
-                reject(new Error('State mismatch'));
-                return;
-            }
-            if (!code) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end('<h1>No code</h1>');
-                server.close();
-                reject(new Error('No authorization code'));
-                return;
-            }
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end(`
-        <html><body style="font-family:system-ui;text-align:center;padding:60px">
-          <h1 style="color:#06b6d4">✓ Login successful</h1>
-          <p>You can close this tab and return to the terminal.</p>
-        </body></html>
-      `);
-            server.close();
-            // Exchange code for tokens
-            exchangeToken(provider, code, redirectUri, codeVerifier).then(resolve).catch(reject);
-        });
-        server.listen(port, '127.0.0.1', () => {
-            console.log(chalk.blue(`  → Waiting for callback on port ${port}...`));
-        });
-        server.on('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                reject(new Error(`Port ${port} is in use. Try again.`));
-            }
-            else {
-                reject(err);
-            }
-        });
-    });
-}
-async function exchangeToken(provider, code, redirectUri, codeVerifier) {
-    const params = new URLSearchParams({
-        grant_type: 'authorization_code',
-        client_id: provider.clientId,
-        code,
-        redirect_uri: redirectUri,
-        code_verifier: codeVerifier,
-    });
-    const res = await fetch(provider.tokenUrl, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-        body: params.toString(),
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`Token exchange failed (${res.status}): ${text}`);
-    }
-    const data = await res.json();
-    // Decode email from id_token if available
-    let email;
-    if (data.id_token) {
-        try {
-            const payload = JSON.parse(Buffer.from(data.id_token.split('.')[1], 'base64').toString());
-            email = payload.email;
-        }
-        catch { }
-    }
-    return {
-        provider: 'opencode',
-        method: 'oauth',
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token,
-        expiresAt: data.expires_in ? Date.now() + data.expires_in * 1000 : undefined,
-        email,
-    };
-}
-function ask(rl, q) {
-    return new Promise((resolve) => rl.question(q, resolve));
-}
-export function authCommand(program) {
-    const auth = program.command('auth')
-        .description('Manage authentication');
-    auth
-        .command('login')
-        .description('Login to a provider (opens browser)')
-        .option('-p, --provider <name>', 'Provider name (opencode)')
-        .action(async (opts) => {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        console.log(chalk.bold.cyan('\n  Agent CLI — Login\n'));
-        let providerId = opts.provider;
-        if (!providerId) {
-            console.log(chalk.dim('  Available providers:'));
-            for (const [id, p] of Object.entries(OAUTH_PROVIDERS)) {
-                console.log(chalk.dim(`    ${id} — ${p.name}`));
-            }
-            providerId = await ask(rl, '\n  Provider: ');
-        }
-        providerId = providerId.trim();
-        try {
-            const entry = await oauthFlow(providerId);
-            const auth = await loadAuth();
-            // Remove existing entry for same provider
-            auth.entries = auth.entries.filter((e) => e.provider !== entry.provider);
-            auth.entries.push(entry);
-            auth.activeProvider = entry.provider;
-            await saveAuth(auth);
-            console.log(chalk.green(`\n  ✓ Logged in as ${entry.email || 'user'} via ${entry.provider}`));
-            console.log(chalk.dim('  Auth saved to ~/.agent-cli/auth.json'));
-        }
-        catch (err) {
-            console.log(chalk.red(`\n  ✗ Login failed: ${err.message}`));
-        }
-        rl.close();
-    });
-    auth
-        .command('logout')
-        .description('Logout from current provider')
-        .action(async () => {
-        const auth = await loadAuth();
-        if (!auth.activeProvider || auth.entries.length === 0) {
-            console.log(chalk.yellow('  Not logged in'));
-            return;
-        }
-        auth.entries = auth.entries.filter((e) => e.provider !== auth.activeProvider);
-        auth.activeProvider = undefined;
-        await saveAuth(auth);
-        console.log(chalk.green('  ✓ Logged out'));
-    });
-    auth
-        .command('status')
-        .description('Show current auth status')
-        .action(async () => {
-        const auth = await loadAuth();
-        console.log(chalk.bold('\n  Auth Status'));
-        console.log(chalk.dim('  ──────────────────────────'));
-        if (auth.entries.length === 0) {
-            console.log(chalk.yellow('  Not logged in to any provider'));
-        }
-        else {
-            for (const entry of auth.entries) {
-                const active = entry.provider === auth.activeProvider ? chalk.green(' (active)') : '';
-                const email = entry.email ? ` — ${entry.email}` : '';
-                const expired = entry.expiresAt && entry.expiresAt < Date.now() ? chalk.red(' (expired)') : '';
-                console.log(`  ${entry.provider} (${entry.method})${email}${active}${expired}`);
-            }
-        }
-        console.log('');
-    });
-    auth
-        .command('apikey')
-        .description('Set API key for a provider')
-        .argument('<provider>', 'Provider name')
-        .argument('<key>', 'API key')
-        .action(async (provider, key) => {
-        const auth = await loadAuth();
-        auth.entries = auth.entries.filter((e) => e.provider !== provider);
-        auth.entries.push({ provider, method: 'apikey', apiKey: key });
-        auth.activeProvider = provider;
-        await saveAuth(auth);
-        console.log(chalk.green(`  ✓ API key saved for ${provider}`));
-    });
-}
-export { loadAuth, loadCliConfig, saveCliConfig, CONFIG_DIR, CONFIG_FILE };

package/dist/commands/config.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function configCommand(program: Command): void;

package/dist/commands/config.js

@@ -1,42 +0,0 @@
-import chalk from 'chalk';
-import { loadCliConfig, saveCliConfig } from '../utils/config.js';
-export function configCommand(program) {
-    program
-        .command('config')
-        .description('View or edit CLI configuration')
-        .option('--show', 'Show current configuration')
-        .option('--set <key=value>', 'Set a config value')
-        .action(async (opts) => {
-        const config = await loadCliConfig();
-        if (opts.show) {
-            console.log(chalk.bold('\n  Agent CLI Configuration'));
-            console.log(chalk.dim('  ──────────────────────────'));
-            console.log(chalk.yellow('  Providers:'), Object.keys(config.apiKeys).join(', ') || 'none');
-            for (const [role, r] of Object.entries(config.roles)) {
-                if (r)
-                    console.log(chalk.yellow(`  ${role}:`), `${r.provider}/${r.model}`);
-            }
-            if (config.deliberation?.enabled) {
-                console.log(chalk.yellow('  Deliberation:'), `enabled (${config.deliberation.max_rounds} rounds)`);
-            }
-            console.log('');
-            return;
-        }
-        if (opts.set) {
-            const [key, ...valParts] = opts.set.split('=');
-            const value = valParts.join('=');
-            const parts = key.split('.');
-            let obj = config;
-            for (let i = 0; i < parts.length - 1; i++) {
-                if (!obj[parts[i]])
-                    obj[parts[i]] = {};
-                obj = obj[parts[i]];
-            }
-            obj[parts[parts.length - 1]] = value;
-            await saveCliConfig(config);
-            console.log(chalk.green(`  ✓ Set ${key} = ${value}`));
-            return;
-        }
-        console.log('Use --show or --set key=value');
-    });
-}

package/dist/core/prompts.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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/providers/index.d.ts

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

package/dist/providers/index.js

@@ -1,120 +0,0 @@
-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,
-        },
-    };
-}