agent-rev 0.1.0

package/dist/utils/config.d.ts

@@ -0,0 +1,38 @@
+import { AgentConfig } from '../types.js';
+export declare const AGENT_HOME: string;
+export declare const AUTH_FILE: string;
+export declare const CONFIG_FILE: string;
+export interface CliConfig {
+    coordinatorProvider?: string;
+    coordinatorModel?: string;
+    roles: Record<string, {
+        cli: string;
+        model: string;
+        fallbackCli?: string;
+        fallbackModel?: string;
+    }>;
+    fallback_global?: {
+        cli: string;
+        model: string;
+    };
+    deliberation: {
+        enabled: boolean;
+        max_rounds: number;
+    };
+}
+export interface AuthStore {
+    activeProvider?: string;
+    entries: Array<{
+        provider: string;
+        method: 'oauth' | 'apikey';
+        accessToken?: string;
+        apiKey?: string;
+        email?: string;
+    }>;
+}
+export declare function loadAuth(): Promise<AuthStore>;
+export declare function saveAuth(auth: AuthStore): Promise<void>;
+export declare function loadCliConfig(): Promise<CliConfig>;
+export declare function saveCliConfig(cfg: CliConfig): Promise<void>;
+export declare function loadProjectConfig(projectDir: string): Promise<AgentConfig>;
+export declare function getConfigDir(): string;

package/dist/utils/config.js

@@ -0,0 +1,40 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+export const AGENT_HOME = path.join(os.homedir(), '.agent-cli');
+export const AUTH_FILE = path.join(AGENT_HOME, 'auth.json');
+export const CONFIG_FILE = path.join(AGENT_HOME, 'config.json');
+export async function loadAuth() {
+    try {
+        const content = await fs.readFile(AUTH_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { entries: [] };
+    }
+}
+export async function saveAuth(auth) {
+    await fs.mkdir(AGENT_HOME, { recursive: true });
+    await fs.writeFile(AUTH_FILE, JSON.stringify(auth, null, 2) + '\n', 'utf-8');
+}
+export 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 } };
+    }
+}
+export async function saveCliConfig(cfg) {
+    await fs.mkdir(AGENT_HOME, { recursive: true });
+    await fs.writeFile(CONFIG_FILE, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+}
+export async function loadProjectConfig(projectDir) {
+    const configPath = path.join(projectDir, '.agent', 'config.json');
+    const content = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(content);
+}
+export function getConfigDir() {
+    return AGENT_HOME;
+}

package/dist/utils/fs.d.ts

@@ -0,0 +1,7 @@
+export declare function ensureDir(dir: string): Promise<void>;
+export declare function writeJson(filePath: string, data: unknown): Promise<void>;
+export declare function readJson<T>(filePath: string): Promise<T>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+export declare function readFile(filePath: string): Promise<string>;
+export declare function listDir(dir: string): Promise<string[]>;

package/dist/utils/fs.js

@@ -0,0 +1,37 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+export async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+export async function writeJson(filePath, data) {
+    await ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+export async function readJson(filePath) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    return JSON.parse(content);
+}
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function writeFile(filePath, content) {
+    await ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content, 'utf-8');
+}
+export async function readFile(filePath) {
+    return fs.readFile(filePath, 'utf-8');
+}
+export async function listDir(dir) {
+    try {
+        return await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,13 @@
+export declare const log: {
+    header: (text: string) => void;
+    section: (text: string) => void;
+    ok: (text: string) => void;
+    error: (text: string) => void;
+    warn: (text: string) => void;
+    info: (text: string) => void;
+    phase: (num: number, name: string, cli: string, model: string) => void;
+    verdict: (verdict: string) => void;
+    tokens: (input: number, output: number, cached: number) => void;
+    divider: () => void;
+    cliList: (name: string, path: string) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+export const log = {
+    header: (text) => {
+        console.log('');
+        console.log(chalk.bold.cyan('\u2550'.repeat(46)));
+        console.log(chalk.bold.cyan(`  ${text}`));
+        console.log(chalk.bold.cyan('\u2550'.repeat(46)));
+    },
+    section: (text) => {
+        console.log('');
+        console.log(chalk.bold.yellow(`  \u2500\u2500 ${text} \u2500\u2500`));
+    },
+    ok: (text) => {
+        console.log(chalk.green(`  \u2713 ${text}`));
+    },
+    error: (text) => {
+        console.log(chalk.red(`  \u2717 ${text}`));
+    },
+    warn: (text) => {
+        console.log(chalk.yellow(`  ! ${text}`));
+    },
+    info: (text) => {
+        console.log(chalk.blue(`  \u2192 ${text}`));
+    },
+    phase: (num, name, cli, model) => {
+        console.log('');
+        console.log(chalk.bold.bgBlue.white(`  FASE ${num}: ${name.toUpperCase()} (${cli}/${model})  `));
+    },
+    verdict: (verdict) => {
+        if (verdict === 'PASS') {
+            console.log(chalk.bold.green(`  \u2605 VERDICTO: ${verdict} \u2605`));
+        }
+        else {
+            console.log(chalk.bold.red(`  \u2605 VERDICTO: ${verdict} \u2605`));
+        }
+    },
+    tokens: (input, output, cached) => {
+        console.log(chalk.dim(`    Input: ${input.toLocaleString()} | Output: ${output.toLocaleString()} | Cached: ${cached.toLocaleString()}`));
+    },
+    divider: () => {
+        console.log(chalk.dim('  ' + '\u2500'.repeat(42)));
+    },
+    cliList: (name, path) => {
+        console.log(chalk.green(`  [OK] ${name}  \u2192 ${path}`));
+    },
+};

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

@@ -0,0 +1,12 @@
+/** Exported as const for backward compat */
+export declare const QWEN_AGENT_HOME: string;
+/** Dynamic getter (recommended for runtime changes) */
+export declare function getQwenHome(): string;
+export declare function getTokenPath(): Promise<string>;
+export declare function qwenLogin(): Promise<boolean>;
+export declare function qwenAuthStatus(): Promise<{
+    authenticated: boolean;
+    email?: string;
+}>;
+export declare function getQwenAccessToken(): Promise<string | null>;
+export declare function callQwenAPI(prompt: string, model?: string): Promise<string>;

package/dist/utils/qwen-auth.js

@@ -0,0 +1,250 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import open from 'open';
+import { AGENT_HOME } from './config.js';
+const QWEN_OAUTH_BASE_URL = 'https://chat.qwen.ai';
+const QWEN_OAUTH_DEVICE_CODE_ENDPOINT = `${QWEN_OAUTH_BASE_URL}/api/v1/oauth2/device/code`;
+const QWEN_OAUTH_TOKEN_ENDPOINT = `${QWEN_OAUTH_BASE_URL}/api/v1/oauth2/token`;
+const QWEN_OAUTH_CLIENT_ID = 'f0304373b74a44d2b584a3fb70ca9e56';
+const QWEN_OAUTH_SCOPE = 'openid profile email model.completion';
+/** Get Qwen credentials dir inside agent's home */
+function getQwenAgentHome() {
+    return AGENT_HOME;
+}
+/** Exported as const for backward compat */
+export const QWEN_AGENT_HOME = AGENT_HOME;
+/** Dynamic getter (recommended for runtime changes) */
+export function getQwenHome() {
+    return AGENT_HOME;
+}
+async function getQwenDir() {
+    const dir = getQwenAgentHome();
+    await fs.mkdir(dir, { recursive: true });
+    return dir;
+}
+export async function getTokenPath() {
+    const qwenDir = await getQwenDir();
+    return path.join(qwenDir, 'oauth_creds.json');
+}
+async function loadToken() {
+    try {
+        const tokenPath = await getTokenPath();
+        const content = await fs.readFile(tokenPath, 'utf-8');
+        const raw = JSON.parse(content);
+        // Normalize: qwen CLI saves snake_case, we save camelCase
+        const token = {
+            accessToken: raw.accessToken || raw.access_token || '',
+            refreshToken: raw.refreshToken || raw.refresh_token || '',
+            expiresAt: raw.expiresAt || raw.expiry_date || 0,
+            idToken: raw.idToken || raw.id_token,
+            resourceUrl: raw.resourceUrl || raw.resource_url,
+        };
+        if (!token.accessToken)
+            return null;
+        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 fetch(QWEN_OAUTH_TOKEN_ENDPOINT, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                grant_type: 'refresh_token',
+                refresh_token: refreshToken,
+                client_id: QWEN_OAUTH_CLIENT_ID,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Token refresh failed: ${response.status}`);
+        }
+        const data = await response.json();
+        const token = {
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token || refreshToken,
+            expiresAt: Date.now() + (data.expires_in || 3600) * 1000,
+            idToken: data.id_token,
+            resourceUrl: data.resource_url,
+        };
+        await saveToken(token);
+        return token;
+    }
+    catch (error) {
+        console.error('Error refreshing token:', error);
+        return null;
+    }
+}
+// Generate PKCE code verifier and challenge
+function generatePKCE() {
+    const codeVerifier = crypto.randomBytes(32).toString('base64url');
+    const codeChallenge = crypto
+        .createHash('sha256')
+        .update(codeVerifier)
+        .digest('base64url');
+    return { codeVerifier, codeChallenge };
+}
+export async function qwenLogin() {
+    try {
+        // Step 1: Generate PKCE
+        const { codeVerifier, codeChallenge } = generatePKCE();
+        // Step 2: Get device code with PKCE challenge
+        const deviceCodeResponse = await fetch(QWEN_OAUTH_DEVICE_CODE_ENDPOINT, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json',
+                'User-Agent': 'Qwen-Agent-CLI/1.0',
+                'x-request-id': crypto.randomUUID(),
+            },
+            body: new URLSearchParams({
+                client_id: QWEN_OAUTH_CLIENT_ID,
+                scope: QWEN_OAUTH_SCOPE,
+                code_challenge: codeChallenge,
+                code_challenge_method: 'S256',
+            }),
+        });
+        if (!deviceCodeResponse.ok) {
+            const errorText = await deviceCodeResponse.text();
+            throw new Error(`Failed to get device code: ${deviceCodeResponse.status} - ${errorText}`);
+        }
+        const deviceCodeData = await deviceCodeResponse.json();
+        const { device_code, user_code, verification_uri, verification_uri_complete, expires_in, interval } = deviceCodeData;
+        // Step 3: Show instructions to user
+        console.log('');
+        console.log('╔═══════════════════════════════════════════════════════════╗');
+        console.log('║       Autenticación con Qwen OAuth                        ║');
+        console.log('╚═══════════════════════════════════════════════════════════╝');
+        console.log('');
+        console.log(`  1. Abrí esta URL en tu navegador:`);
+        console.log(`     ${verification_uri_complete || verification_uri}`);
+        console.log('');
+        console.log(`  2. Ingresá el código:`);
+        console.log(`     ${user_code}`);
+        console.log('');
+        console.log('  El código expira en', Math.floor(expires_in / 60), 'minutos.');
+        console.log('');
+        // Step 4: Open browser automatically with complete URL
+        const urlToOpen = verification_uri_complete || verification_uri;
+        console.log('  ✳️  IMPORTANTE: Si tu navegador ya tiene sesión con otra cuenta,');
+        console.log('      copiá la URL y abrila en modo incógnito/privado.');
+        console.log('');
+        await open(urlToOpen);
+        console.log('  ✓ Navegador abierto');
+        console.log('');
+        console.log('  Esperando autorización...');
+        // Step 5: Poll for token with PKCE verifier
+        const token = await pollForToken(device_code, codeVerifier, interval || 5, expires_in);
+        if (token) {
+            await saveToken(token);
+            console.log('');
+            console.log('  ✓ ¡Autenticación exitosa!');
+            console.log('  Token guardado en:', await getTokenPath());
+            console.log('');
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        console.error('  ✗ Error en autenticación:', error.message);
+        console.log('');
+        console.log('  Alternativa: usá el CLI de Qwen directamente:');
+        console.log('    qwen auth qwen-oauth');
+        console.log('');
+        return false;
+    }
+}
+async function pollForToken(deviceCode, codeVerifier, interval, expiresIn) {
+    const maxAttempts = Math.floor(expiresIn / interval);
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        await new Promise(resolve => setTimeout(resolve, interval * 1000));
+        try {
+            const response = await fetch(QWEN_OAUTH_TOKEN_ENDPOINT, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: new URLSearchParams({
+                    grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                    device_code: deviceCode,
+                    client_id: QWEN_OAUTH_CLIENT_ID,
+                    code_verifier: codeVerifier,
+                }),
+            });
+            const data = await response.json();
+            if (response.ok && data.access_token) {
+                return {
+                    accessToken: data.access_token,
+                    refreshToken: data.refresh_token || '',
+                    expiresAt: Date.now() + (data.expires_in || 3600) * 1000,
+                    idToken: data.id_token,
+                    resourceUrl: data.resource_url,
+                };
+            }
+            // authorization_pending - keep polling
+            if (data.error === 'authorization_pending') {
+                continue;
+            }
+            // Other errors - stop polling
+            if (data.error === 'access_denied' || data.error === 'expired_token') {
+                console.log('  ✗ Autorización denegada o código expirado');
+                return null;
+            }
+        }
+        catch (error) {
+            // Continue polling on network errors
+        }
+    }
+    console.log('  ✗ Tiempo de espera agotado');
+    return null;
+}
+export async function qwenAuthStatus() {
+    const token = await loadToken();
+    if (!token)
+        return { authenticated: false };
+    return { authenticated: true };
+}
+export async function getQwenAccessToken() {
+    const token = await loadToken();
+    return token?.accessToken || null;
+}
+export async function callQwenAPI(prompt, model = 'coder-model') {
+    const token = await loadToken();
+    if (!token) {
+        throw new Error('No hay token de Qwen. Ejecutá /login primero.');
+    }
+    // Qwen OAuth tokens work with chat.qwen.ai API
+    const baseUrl = 'https://chat.qwen.ai/api/v1';
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token.accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            model: model || 'coder-model',
+            messages: [
+                { role: 'system', content: 'Sos el COORDINADOR de un equipo multi-agente de desarrollo. Tu trabajo es ENTENDER lo que el programador necesita haciendo PREGUNTAS si es necesario. Habla de forma NATURAL, como un compañero de equipo. Sé breve y directo.' },
+                { role: 'user', content: prompt },
+            ],
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Qwen API error: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    return data.choices?.[0]?.message?.content || '';
+}

package/dist/utils/sessions.d.ts

@@ -0,0 +1,17 @@
+export interface SessionMessage {
+    role: 'user' | 'agent';
+    content: string;
+    ts: string;
+}
+export interface Session {
+    id: string;
+    dir: string;
+    createdAt: string;
+    updatedAt: string;
+    messages: SessionMessage[];
+}
+export declare function newSession(dir: string): Session;
+export declare function saveSession(session: Session): Promise<void>;
+export declare function loadSession(id: string): Promise<Session | null>;
+export declare function listSessions(): Promise<Session[]>;
+export declare function getLastSessionForDir(dir: string): Promise<Session | null>;

package/dist/utils/sessions.js

@@ -0,0 +1,46 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { AGENT_HOME } from './config.js';
+const SESSIONS_DIR = path.join(AGENT_HOME, 'sessions');
+export function newSession(dir) {
+    const now = new Date().toISOString();
+    const id = now.replace(/[:.]/g, '-').replace('T', '_').slice(0, 19);
+    return { id, dir, createdAt: now, updatedAt: now, messages: [] };
+}
+export async function saveSession(session) {
+    await fs.mkdir(SESSIONS_DIR, { recursive: true });
+    session.updatedAt = new Date().toISOString();
+    await fs.writeFile(path.join(SESSIONS_DIR, `${session.id}.json`), JSON.stringify(session, null, 2) + '\n', 'utf-8');
+}
+export async function loadSession(id) {
+    try {
+        const content = await fs.readFile(path.join(SESSIONS_DIR, `${id}.json`), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export async function listSessions() {
+    try {
+        const files = await fs.readdir(SESSIONS_DIR);
+        const sessions = [];
+        for (const f of files) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                const content = await fs.readFile(path.join(SESSIONS_DIR, f), 'utf-8');
+                sessions.push(JSON.parse(content));
+            }
+            catch { }
+        }
+        return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    catch {
+        return [];
+    }
+}
+export async function getLastSessionForDir(dir) {
+    const all = await listSessions();
+    return all.find((s) => s.dir === dir) ?? null;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "agent-rev",
+  "version": "0.1.0",
+  "description": "Reviewer agent — validates and reviews implementation against the plan",
+  "type": "module",
+  "main": "./dist/index.js",
+  "files": [
+    "dist/"
+  ],
+  "bin": {
+    "agent-rev": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && echo '#!/usr/bin/env node' | cat - dist/index.js > dist/index.tmp && mv dist/index.tmp dist/index.js && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "orchestrator",
+    "multi-agent",
+    "cli",
+    "coding"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@google/generative-ai": "^0.24.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "open": "^11.0.0",
+    "openai": "^4.91.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.0",
+    "@types/open": "^6.1.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}