agent-mp 0.4.6 → 0.4.8

package/dist/core/engine.js

@@ -88,7 +88,7 @@ async function ask(prompt, rl, fi) {
     const tempRl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => tempRl.question(prompt, (a) => { tempRl.close(); resolve(a); }));
 }
-function runCli(cmd, prompt, timeoutMs = 600000, envOverride) {
+function runCli(cmd, prompt, timeoutMs = 600000, envOverride, onData) {
     // Si el comando es "qwen-direct", usar la API directa sin CLI
     if (cmd.startsWith('qwen-direct')) {
         const model = cmd.includes('-m') ? cmd.split('-m')[1]?.trim().split(/\s/)[0] : 'coder-model';
@@ -143,7 +143,7 @@ function runCli(cmd, prompt, timeoutMs = 600000, envOverride) {
         });
         let output = '';
         let stderr = '';
-        child.stdout?.on('data', (d) => { output += d.toString(); });
+        child.stdout?.on('data', (d) => { const s = d.toString(); output += s; onData?.(s); });
         child.stderr?.on('data', (d) => { stderr += d.toString(); });
         child.on('close', (code) => { resolve({ output: output + stderr, exitCode: code || 0 }); });
         child.on('error', reject);
@@ -423,7 +423,10 @@ INSTRUCCIONES:
         const tryWithAutoRepair = async (cliName, model, currentCmd) => {
             const sp = this._startSpinner(`${cliName}  ${model}`);
             try {
-                const result = await runCli(currentCmd, rolePrompt);
+                const result = await runCli(currentCmd, rolePrompt, 600000, undefined, (chunk) => {
+                    this._parseChunk(chunk).forEach(l => { if (l.trim())
+                        sp.push(l); });
+                });
                 if (result.exitCode !== 0) {
                     sp.stop();
                     const detail = result.output.trim().slice(0, 500);
@@ -487,7 +490,10 @@ INSTRUCCIONES:
                 // Retry with new command
                 const sp2 = this._startSpinner(`${cliName}  ${model}  (retry)`);
                 try {
-                    const result = await runCli(newCmd, rolePrompt);
+                    const result = await runCli(newCmd, rolePrompt, 600000, undefined, (chunk) => {
+                        this._parseChunk(chunk).forEach(l => { if (l.trim())
+                            sp2.push(l); });
+                    });
                     sp2.stop();
                     if (result.exitCode !== 0) {
                         const detail = result.output.trim().slice(0, 500);
@@ -515,17 +521,28 @@ INSTRUCCIONES:
                 return null;
             }
             const sp = this._startSpinner(`${cliName}  ${model}`);
+            let lineBuf = '';
+            const onChunk = (delta) => {
+                lineBuf += delta;
+                const lines = lineBuf.split('\n');
+                lineBuf = lines.pop() || '';
+                for (const l of lines) {
+                    if (l.trim())
+                        sp.push(l.trim());
+                }
+            };
             try {
                 log.info(`${cliName}: calling Qwen API with own credentials (${model})`);
-                const result = await callQwenAPIFromCreds(rolePrompt, model, credsPath, (c) => this._parseChunk(c).forEach(l => sp.push(l)));
+                const result = await callQwenAPIFromCreds(rolePrompt, model, credsPath, onChunk);
+                if (lineBuf.trim())
+                    sp.push(lineBuf.trim());
                 sp.stop();
                 return result;
             }
             catch (err) {
                 sp.stop();
                 if (err.message?.startsWith('QWEN_AUTH_EXPIRED')) {
-                    console.log(chalk.red(`\n  ✗ Sesión expirada para ${cliName}.`));
-                    console.log(chalk.yellow(`  Ejecutá: ${cliName} --login\n`));
+                    log.warn(`${cliName} session expired — using fallback`);
                     return null;
                 }
                 log.warn(`${cliName} direct API call failed: ${err.message}`);
@@ -566,15 +583,33 @@ INSTRUCCIONES:
                 }
             }
         }
-        // Try global fallback
+        // Try global fallback — use callQwenAPI directly for streaming (no subprocess)
         if (this.config.fallback_global) {
             const fb = this.config.fallback_global;
-            log.warn(`Trying global fallback: ${fb.cli} (${fb.model})`);
-            const globalResult = await tryWithAutoRepair(fb.cli, fb.model, fb.cmd);
-            if (globalResult !== null) {
+            log.warn(`Using global fallback: ${fb.cli} (${fb.model})`);
+            const sp = this._startSpinner(`${fb.cli}  ${fb.model}  (fallback)`);
+            let lineBuf = '';
+            const onChunk = (delta) => {
+                lineBuf += delta;
+                const lines = lineBuf.split('\n');
+                lineBuf = lines.pop() || '';
+                for (const l of lines) {
+                    if (l.trim())
+                        sp.push(l.trim());
+                }
+            };
+            try {
+                const globalResult = await callQwenAPI(rolePrompt, fb.model, onChunk);
+                if (lineBuf.trim())
+                    sp.push(lineBuf.trim());
+                sp.stop();
                 trackTokens(globalResult, fb.cli, fb.model);
                 return globalResult;
             }
+            catch (err) {
+                sp.stop();
+                log.warn(`Global fallback failed: ${err.message}`);
+            }
         }
         // All options exhausted
         throw new Error(`${roleName} failed: primary + individual fallback + global fallback all failed`);
@@ -585,10 +620,10 @@ INSTRUCCIONES:
         const preambles = {
             orchestrator: `ROL: ORCHESTRATOR — solo planifica, nunca implementa.
 REGLA: Tu unica salida debe ser el JSON del plan. Sin explicaciones, sin texto extra.`,
-            implementor: `ROL: IMPLEMENTOR — solo ejecuta los steps del plan usando tus herramientas.
-REGLA: Usa tus herramientas (read_file, write_file, run_shell_command, etc.) para ejecutar cada step.
-REGLA: NO tomes decisiones de arquitectura. NO modifiques el plan.
-REGLA: Al terminar, responde SOLO con el JSON de progreso indicado.`,
+            implementor: `ROL: IMPLEMENTOR — genera el contenido completo de los archivos indicados.
+REGLA: Para cada archivo, usa el bloque === FILE: ruta === ... === END FILE === exactamente.
+REGLA: NO tomes decisiones de arquitectura. Sigue los steps del plan.
+REGLA: Genera el contenido COMPLETO de cada archivo, no fragmentos ni pseudocodigo.`,
             reviewer: `ROL: REVIEWER — solo valida, nunca modifica codigo.
 REGLA: Usa tus herramientas (read_file, grep_search, etc.) para leer los archivos y verificar criterios.
 REGLA: NO modifiques archivos. NO implementes correcciones.
@@ -739,41 +774,77 @@ INSTRUCCIONES:
         if (await fileExists(structurePath)) {
             structureRules = await readFile(structurePath);
         }
-        // Build steps list — implementor gets ONLY steps and structure rules (no acceptance_criteria, no deliberation)
+        // Read architecture context for reference
+        const context = await this.buildOrchestratorContext();
+        let archContext = '';
+        const archPath = path.join(this.projectDir, '.agent', 'context', 'architecture.md');
+        if (await fileExists(archPath)) {
+            archContext = (await readFile(archPath)).slice(0, 3000);
+        }
+        const allTargetFiles = [...new Set(plan.steps.flatMap((s) => s.files || []))];
         const stepsText = plan.steps.map((s) => `Step ${s.num}: ${s.description}${s.files?.length ? `\n  Archivos: ${s.files.join(', ')}` : ''}`).join('\n');
+        // The engine writes files itself — ask the LLM to generate content in parseable blocks.
+        // This avoids depending on CLI tool-use capabilities which are unavailable in API mode.
         const prompt = `TAREA: ${plan.description}
 DIRECTORIO_TRABAJO: ${this.projectDir}
 
-STEPS A EJECUTAR EN ORDEN:
+STEPS A IMPLEMENTAR EN ORDEN:
 ${stepsText}
 
+${allTargetFiles.length ? `ARCHIVOS A CREAR/MODIFICAR:\n${allTargetFiles.map(f => `- ${f}`).join('\n')}` : ''}
+
+${context ? `CONTEXTO DEL PROYECTO:\n${context.slice(0, 2000)}\n` : ''}
+${archContext ? `ARQUITECTURA EXISTENTE:\n${archContext}\n` : ''}
 ${structureRules ? `REGLAS DE ESTRUCTURA:\n${structureRules}\n` : ''}
-INSTRUCCIONES:
-1. Ejecuta cada step EN ORDEN usando tus herramientas (read_file, write_file, run_shell_command, etc.)
-2. Para cada step: lee lo necesario, luego crea/modifica los archivos indicados.
-3. NO tomes decisiones de arquitectura fuera del plan.
-4. Al terminar todos los steps, responde SOLO con este JSON:
 
-{"status":"completed","steps_done":[1,2,3],"notes":"resumen breve de lo que se hizo"}`;
+INSTRUCCIONES CRITICAS:
+1. Para CADA archivo que debes crear/modificar, usa este formato EXACTO:
+
+=== FILE: ruta/relativa/del/archivo ===
+contenido completo del archivo aqui
+=== END FILE ===
+
+2. Las rutas son RELATIVAS al DIRECTORIO_TRABAJO.
+3. Genera TODOS los archivos necesarios — uno por bloque FILE.
+4. Incluye el contenido completo de cada archivo (no fragmentos).
+5. Si un step modifica un archivo existente, incluye el archivo completo con los cambios.
+6. NO incluyas explicaciones fuera de los bloques FILE.`;
         const res = await this.runWithFallback('implementor', prompt, 'Implementacion');
-        // Extract text from streaming CLI output (qwen/claude return event arrays)
         const text = extractCliText(res);
-        let progress;
-        try {
-            const json = extractJson(text);
-            progress = (json.progress || json);
+        // Parse === FILE: path === ... === END FILE === blocks written by the LLM
+        const fileBlocks = [];
+        const fileBlockRegex = /^=== FILE: (.+?) ===\n([\s\S]*?)\n=== END FILE ===/gm;
+        let match;
+        while ((match = fileBlockRegex.exec(text)) !== null) {
+            fileBlocks.push({ relPath: match[1].trim(), content: match[2] });
         }
-        catch {
-            // CLI executed the task but didn't return structured JSON — build synthetic progress
-            log.warn('Implementor did not return JSON progress — building from plan');
-            const now = new Date().toISOString();
-            progress = {
-                task_id: taskId,
-                created_at: now,
-                status: 'completed',
-                steps: plan.steps.map((s) => ({ ...s, status: 'completed', completed_at: now })),
-            };
+        const now = new Date().toISOString();
+        if (fileBlocks.length > 0) {
+            const sp = this._startSpinner(`Escribiendo ${fileBlocks.length} archivo(s)`);
+            for (const { relPath, content } of fileBlocks) {
+                // Strip markdown code fences the LLM may have wrapped around content
+                const clean = content.replace(/^```[\w]*\n/, '').replace(/\n```$/, '');
+                sp.push(relPath);
+                const absPath = path.join(this.projectDir, relPath);
+                await fs.mkdir(path.dirname(absPath), { recursive: true });
+                await writeFile(absPath, clean);
+            }
+            sp.stop();
+            log.ok(`${fileBlocks.length} archivo(s) implementado(s)`);
         }
+        else {
+            log.warn('Implementor did not return FILE blocks — no files written');
+        }
+        const progress = {
+            task_id: taskId,
+            created_at: now,
+            status: fileBlocks.length > 0 ? 'completed' : 'failed',
+            steps: plan.steps.map((s) => ({
+                ...s,
+                status: fileBlocks.length > 0 ? 'completed' : 'failed',
+                completed_at: now,
+            })),
+        };
         await writeJson(path.join(taskDir, 'progress.json'), progress);
         log.ok('progress.json updated');
         return progress;

package/dist/utils/qwen-auth.d.ts

@@ -11,16 +11,12 @@ export declare function qwenAuthStatus(): Promise<{
 export declare function fetchQwenModels(): Promise<string[]>;
 export declare function getQwenAccessToken(): Promise<string | null>;
 /**
- * Call Qwen by spawning the `qwen` CLI with piped stdin.
- * The qwen CLI manages its own token refresh and uses the correct API format.
- * Falls back to direct HTTP call if the qwen CLI is not available.
+ * Call Qwen REST API directly using OAuth credentials stored locally.
+ * No dependency on any qwen CLI binary.
  */
 export declare function callQwenAPI(prompt: string, model?: string, onData?: (chunk: string) => void): Promise<string>;
 /**
- * Call Qwen API using credentials from a specific file path (for role binaries).
- * The role binary CLI (e.g. agent-explorer) manages its own qwen auth via the
- * shared ~/.qwen/oauth_creds.json — we spawn it with piped stdin so it runs
- * in non-interactive mode without TTY issues.
- * Falls back to direct HTTP if the role binary is not found.
+ * Call Qwen API using credentials stored at a specific path (for role binaries).
+ * Calls the Qwen REST API directly — no dependency on any qwen CLI binary.
  */
 export declare function callQwenAPIFromCreds(prompt: string, model: string, credsPath: string, onData?: (chunk: string) => void): Promise<string>;

package/dist/utils/qwen-auth.js

@@ -1,25 +1,6 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as crypto from 'crypto';
-import { spawn } from 'child_process';
-/** Async alternative to spawnSync — keeps the event loop free so UI can update. */
-function spawnAsync(bin, args, input, timeout, onData) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(bin, args, { stdio: ['pipe', 'pipe', 'pipe'] });
-        let stdout = '';
-        child.stdout?.on('data', (d) => {
-            const s = d.toString();
-            stdout += s;
-            onData?.(s);
-        });
-        child.stderr?.on('data', (d) => { stdout += d.toString(); });
-        const timer = setTimeout(() => { child.kill(); reject(new Error('qwen timeout')); }, timeout);
-        child.on('close', (code) => { clearTimeout(timer); resolve({ stdout, status: code ?? 0 }); });
-        child.on('error', (err) => { clearTimeout(timer); reject(err); });
-        child.stdin?.write(input, 'utf-8');
-        child.stdin?.end();
-    });
-}
 import open from 'open';
 import { AGENT_HOME } from './config.js';
 const QWEN_OAUTH_BASE_URL = 'https://chat.qwen.ai';
@@ -267,8 +248,9 @@ export async function getQwenAccessToken() {
     const token = await loadToken();
     return token?.accessToken || null;
 }
-async function callQwenAPIWithToken(token, prompt, model) {
+async function callQwenAPIWithToken(token, prompt, model, onData) {
     const baseUrl = 'https://chat.qwen.ai/api/v1';
+    const useStream = !!onData;
     const response = await fetch(`${baseUrl}/chat/completions`, {
         method: 'POST',
         headers: {
@@ -277,46 +259,65 @@ async function callQwenAPIWithToken(token, prompt, model) {
         },
         body: JSON.stringify({
             model: model || 'coder-model',
-            messages: [
-                { role: 'user', content: prompt },
-            ],
+            messages: [{ role: 'user', content: prompt }],
+            stream: useStream,
         }),
     });
     if (!response.ok) {
         const errorText = await response.text();
-        if (response.status === 401) {
+        if (response.status === 401)
             throw new Error(`QWEN_AUTH_EXPIRED: ${errorText}`);
-        }
         throw new Error(`Qwen API error: ${response.status} - ${errorText}`);
     }
-    const data = await response.json();
-    return data.choices?.[0]?.message?.content || '';
+    if (!useStream) {
+        const data = await response.json();
+        return data.choices?.[0]?.message?.content || '';
+    }
+    // Streaming — parse SSE chunks
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error('No response body for streaming');
+    const decoder = new TextDecoder();
+    let fullText = '';
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data: '))
+                continue;
+            const data = trimmed.slice(6);
+            if (data === '[DONE]')
+                continue;
+            try {
+                const parsed = JSON.parse(data);
+                const delta = parsed.choices?.[0]?.delta?.content || '';
+                if (delta) {
+                    fullText += delta;
+                    onData(delta);
+                }
+            }
+            catch { /* skip malformed chunks */ }
+        }
+    }
+    return fullText;
 }
 /**
- * Call Qwen by spawning the `qwen` CLI with piped stdin.
- * The qwen CLI manages its own token refresh and uses the correct API format.
- * Falls back to direct HTTP call if the qwen CLI is not available.
+ * Call Qwen REST API directly using OAuth credentials stored locally.
+ * No dependency on any qwen CLI binary.
  */
 export async function callQwenAPI(prompt, model = 'coder-model', onData) {
-    // Try using the qwen CLI subprocess first — it handles auth/refresh/format automatically
-    const qwenBin = process.env.QWEN_BIN || 'qwen';
-    try {
-        const result = await spawnAsync(qwenBin, [], prompt, 300000, onData);
-        if (result.status === 0 && result.stdout.trim()) {
-            return result.stdout.trim();
-        }
-        // qwen not available or failed — fall through to direct API
-    }
-    catch {
-        // qwen not installed — fall through
-    }
-    // Fallback: direct API call (requires valid token in AGENT_HOME)
     let token = await loadToken();
     if (!token) {
         throw new Error('QWEN_AUTH_EXPIRED: No hay token de Qwen. Ejecutá --login primero.');
     }
     try {
-        return await callQwenAPIWithToken(token, prompt, model);
+        return await callQwenAPIWithToken(token, prompt, model, onData);
     }
     catch (err) {
         if (!err.message?.startsWith('QWEN_AUTH_EXPIRED'))
@@ -325,34 +326,18 @@ export async function callQwenAPI(prompt, model = 'coder-model', onData) {
             const refreshed = await doRefreshToken(token.refreshToken);
             if (refreshed) {
                 await saveToken(refreshed);
-                return callQwenAPIWithToken(refreshed, prompt, model);
+                return callQwenAPIWithToken(refreshed, prompt, model, onData);
             }
         }
         throw new Error('QWEN_AUTH_EXPIRED: Sesión expirada. Ejecutá: agent-mp --login');
     }
 }
 /**
- * Call Qwen API using credentials from a specific file path (for role binaries).
- * The role binary CLI (e.g. agent-explorer) manages its own qwen auth via the
- * shared ~/.qwen/oauth_creds.json — we spawn it with piped stdin so it runs
- * in non-interactive mode without TTY issues.
- * Falls back to direct HTTP if the role binary is not found.
+ * Call Qwen API using credentials stored at a specific path (for role binaries).
+ * Calls the Qwen REST API directly — no dependency on any qwen CLI binary.
  */
 export async function callQwenAPIFromCreds(prompt, model, credsPath, onData) {
-    // Derive the role binary name from the creds path (e.g. ~/.agent-explorer/ → agent-explorer)
     const cliName = path.basename(path.dirname(credsPath)).replace(/^\./, '');
-    // Try spawning the qwen CLI with piped stdin (async — keeps event loop free)
-    const qwenBin = process.env.QWEN_BIN || 'qwen';
-    try {
-        const result = await spawnAsync(qwenBin, [], prompt, 300000, onData);
-        if (result.status === 0 && result.stdout.trim()) {
-            return result.stdout.trim();
-        }
-    }
-    catch {
-        // qwen not available
-    }
-    // Fallback: direct HTTP with stored creds
     let raw;
     try {
         raw = JSON.parse(await fs.readFile(credsPath, 'utf-8'));
@@ -370,7 +355,6 @@ export async function callQwenAPIFromCreds(prompt, model, credsPath, onData) {
     if (!token.accessToken) {
         throw new Error(`Invalid credentials at ${credsPath}. Run: ${cliName} --login`);
     }
-    // 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) {
         const refreshed = await doRefreshToken(token.refreshToken);
@@ -380,17 +364,16 @@ export async function callQwenAPIFromCreds(prompt, model, credsPath, onData) {
         }
     }
     try {
-        return await callQwenAPIWithToken(token, prompt, model);
+        return await callQwenAPIWithToken(token, prompt, model, onData);
     }
     catch (err) {
         if (!err.message?.startsWith('QWEN_AUTH_EXPIRED'))
             throw err;
-        // 401 server-side — intentar refresh aunque expiresAt no haya vencido
         if (token.refreshToken) {
             const refreshed = await doRefreshToken(token.refreshToken);
             if (refreshed) {
                 await fs.writeFile(credsPath, JSON.stringify(refreshed, null, 2), 'utf-8');
-                return callQwenAPIWithToken(refreshed, prompt, model);
+                return callQwenAPIWithToken(refreshed, prompt, model, onData);
             }
         }
         throw new Error(`QWEN_AUTH_EXPIRED: Sesión expirada. Ejecutá: ${cliName} --login`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-mp",
-  "version": "0.4.6",
-  "description": "Deterministic multi-agent CLI orchestrator \u2014 plan, code, review",
+  "version": "0.4.8",
+  "description": "Deterministic multi-agent CLI orchestrator — plan, code, review",
   "type": "module",
   "main": "./dist/index.js",
   "files": [
@@ -41,4 +41,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}