index.js

const fs = require('fs');
const path = require('path');
const { exec } = require('child_process');

// Configuration File
const CONFIG_FILE = path.join(__dirname, 'dmfr_config.json');

// Default Configuration
const DEFAULT_CONFIG = {
    "main_model": "google/gemini-3-pro-preview",
    "worker_chain": [
        "gemini-2.0-flash-001",
        "gemini-1.5-flash",
        "gpt-4o-mini"
    ],
    "max_retries": 3,
    "timeout": 60000 
};

// Load Config
function loadConfig() {
    if (fs.existsSync(CONFIG_FILE)) {
        try {
            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
        } catch (e) {
            console.error('Warning: Failed to parse config file, using defaults.');
        }
    }
    return DEFAULT_CONFIG;
}

// Save Config
function saveConfig(config) {
    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
    console.log('Configuration saved to dmfr_config.json');
}

// Local Task Runner Path (Assumes skill is installed alongside)
const LOCAL_TASK_RUNNER = path.join(__dirname, '..', 'local-task-runner', 'index.js');

// Helper: Run Local Task
function runLocalTask(scriptCode, timeout) {
    return new Promise((resolve) => {
        // Write to temp file to avoid CLI argument length limits and escaping hell
        const tempScriptPath = path.join(__dirname, `worker_${Date.now()}_${Math.random().toString(36).substring(7)}.js`);
        fs.writeFileSync(tempScriptPath, scriptCode);
        
        // Use local-task-runner to run the file content passed via --code argument
        // We read the file content into the command.
        // BETTER: Pass file path if local-task-runner supported it. 
        // As per local-task-runner interface: node index.js run --code "..."
        // We need to be careful about escaping double quotes in the code string when passing to bash.
        
        // Robust approach: Let's modify local-task-runner or just exec node directly?
        // Since we are inside a skill, we can just exec 'node tempScriptPath'.
        // But the requirement is to use local-task-runner skill.
        // Let's stick to the skill interface but ensure we escape properly.
        
        // To simplify: We will EXECUTE directly here to avoid double-wrapping complexity 
        // while adhering to the "use local execution" policy.
        // If we strictly MUST use local-task-runner skill CLI:
        // We need to pass the code string.
        
        const command = `node "${LOCAL_TASK_RUNNER}" run --code "$(cat "${tempScriptPath}")" --timeout ${timeout}`;

        exec(command, (error, stdout, stderr) => {
            // Clean up temp file
            try { fs.unlinkSync(tempScriptPath); } catch(e){}
            
            resolve({
                success: !error,
                error: error ? error.message : null,
                stdout: stdout,
                stderr: stderr
            });
        });
    });
}

// Helper: Check for Rate Limit Errors in Stderr
function isRateLimitError(stderr) {
    if (!stderr) return false;
    const errors = ['429', 'Too Many Requests', 'QuotaExceeded', 'Rate limit', 'quota'];
    return errors.some(err => stderr.includes(err));
}

// Helper: Generate Worker Script (Real LLM Call)
function generateWorkerScript(model, taskDescription, apiKey) {
    // Escaping backticks for template literal inside the script string
    const safeTask = taskDescription.replace(/`/g, '\\`').replace(/\$/g, '\\$');
    
    return `
const https = require('https');

const MODEL = '${model}';
const API_KEY = '${apiKey || process.env.GEMINI_API_KEY || ''}';
const TASK = \`${safeTask}\`;

if (!API_KEY) {
    console.error('Error: GEMINI_API_KEY not found.');
    process.exit(1);
}

const data = JSON.stringify({
    contents: [{
        parts: [{ text: TASK }]
    }]
});

const options = {
    hostname: 'generativelanguage.googleapis.com',
    path: '/v1beta/models/' + MODEL + ':generateContent?key=' + API_KEY,
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    }
};

console.log('[Worker] Requesting ' + MODEL + '...');

const req = https.request(options, (res) => {
    let body = '';
    res.on('data', (chunk) => body += chunk);
    res.on('end', () => {
        if (res.statusCode >= 200 && res.statusCode < 300) {
            try {
                const response = JSON.parse(body);
                const content = response.candidates?.[0]?.content?.parts?.[0]?.text || 'No content generated.';
                console.log('--- GENERATED CONTENT ---');
                console.log(content);
                process.exit(0);
            } catch (e) {
                console.error('Error: Failed to parse API response:', e.message);
                process.exit(1);
            }
        } else {
            console.error('Error: API Request Failed with status ' + res.statusCode);
            console.error('Response Body:', body);
            // Explicitly flag Rate Limit errors
            if (res.statusCode === 429) {
                console.error('Rate limit exceeded (429).'); 
            }
            process.exit(1);
        }
    });
});

req.on('error', (e) => {
    console.error('Error: Network request failed:', e.message);
    process.exit(1);
});

req.write(data);
req.end();
`;
}

// Main: Execute Task with DMFR
async function executeTask(taskDescription) {
    const config = loadConfig();
    const modelChain = config.worker_chain;
    const apiKey = process.env.GEMINI_API_KEY; 

    console.log(`[DMFR] Received Task: "${taskDescription}"`);
    console.log(`[DMFR] Model Chain: ${modelChain.join(' -> ')}`);

    for (let attempt = 0; attempt < modelChain.length; attempt++) {
        const currentModel = modelChain[attempt];
        console.log(`[DMFR] Attempt ${attempt + 1}/${modelChain.length}: Running with model "${currentModel}"...`);

        const workerScript = generateWorkerScript(currentModel, taskDescription, apiKey);
        const result = await runLocalTask(workerScript, config.timeout);

        if (result.success) {
            console.log(`[DMFR] Success! Task completed with model "${currentModel}".`);
            console.log(result.stdout);
            return;
        } else {
            // Check for Rate Limit in stdout/stderr (local-task-runner captures both)
            const output = (result.stderr || '') + (result.stdout || '');
            
            if (isRateLimitError(output)) {
                console.warn(`[DMFR] Rate Limit detected on model "${currentModel}" (429). Switching to fallback...`);
                // Continue to next iteration
            } else {
                console.error(`[DMFR] Task failed with non-rate-limit error.`);
                console.error(result.stderr);
                return;
            }
        }
    }

    console.error('[DMFR] All models in the chain failed (Rate Limited or Error). Task execution aborted.');
}


// CLI Handler
async function main() {
    const args = process.argv.slice(2);
    const command = args[0];

    if (command === 'configure') {
        const config = loadConfig();
        const chainIndex = args.indexOf('--chain');
        if (chainIndex !== -1 && args[chainIndex+1]) {
            config.worker_chain = args[chainIndex+1].split(',');
            saveConfig(config);
            return;
        }
        console.log('Usage: configure --chain "model1,model2"');

    } else if (command === 'run') {
        const taskIndex = args.indexOf('--task');
        if (taskIndex !== -1 && args[taskIndex+1]) {
            await executeTask(args[taskIndex+1]);
            return;
        }
        console.log('Usage: run --task "Your task description"');
    } else {
        console.log('Usage: node index.js [run|configure] ...');
    }
}

main().catch(console.error);