SKILL: Autonomous Code Maintenance with LLM Mechanic

name: llm-code-mechanic version: 1.0.0 author: aiindigo-simulation description: Continuously monitor a multi-job simulation engine for runtime errors, generate fixes using a local coding LLM, validate fixes with syntax checks, and auto-revert on failure dependencies:

• node.js >= 18
• ollama (local inference server)
• pm2 (process manager) inputs:
• jobs/ directory of .js worker files
• PM2 error logs (~/.pm2/logs/)
• output-ledger.json (job health records) outputs:
• mechanic-state.json (current health of all jobs)
• mechanic-log.json (history of fixes applied/reverted)

Prerequisites

# Ollama running with a coding model
ollama pull qwen2.5-coder:7b  # or any code-capable model
ollama serve &

# PM2 managing the simulation process
npm install -g pm2
pm2 start simulation.js --name simulation

Steps

Step 1 — Scan All Job Files for Syntax Errors

Use Node.js built-in --check flag to catch syntax errors without executing code.

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

const JOBS_DIR = path.join(__dirname, 'jobs');
const PROTECTED_FILES = new Set([
    'core.js', 'simulation.js', 'work-queue.js', 'periodic-scheduler.js'
]);

function syntaxCheck(filePath) {
    try {
        execSync(`node --check "${filePath}"`, { stdio: 'pipe' });
        return { ok: true, error: null };
    } catch (err) {
        return {
            ok: false,
            error: err.stderr?.toString() || err.message
        };
    }
}

function scanAllFiles(dir) {
    const results = [];
    const files = fs.readdirSync(dir).filter(f => f.endsWith('.js'));

    for (const file of files) {
        if (PROTECTED_FILES.has(file)) continue;
        const fullPath = path.join(dir, file);
        const check = syntaxCheck(fullPath);
        if (!check.ok) {
            results.push({ file, path: fullPath, error: check.error });
            console.log(`❌ Syntax error in <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mrow><mi>f</mi><mi>i</mi><mi>l</mi><mi>e</mi></mrow><mo>:</mo></mrow><annotation encoding="application/x-tex">{file}:</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1076em;">f</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">e</span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">:</span></span></span></span>{check.error.split('\n')[0]}`);
        }
    }

    console.log(`Syntax scan: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mrow><mi>f</mi><mi>i</mi><mi>l</mi><mi>e</mi><mi>s</mi><mi mathvariant="normal">.</mi><mi>l</mi><mi>e</mi><mi>n</mi><mi>g</mi><mi>t</mi><mi>h</mi></mrow><mi>f</mi><mi>i</mi><mi>l</mi><mi>e</mi><mi>s</mi><mo separator="true">,</mo></mrow><annotation encoding="application/x-tex">{files.length} files,</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1076em;">f</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">es</span><span class="mord">.</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">e</span><span class="mord mathnormal">n</span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mord mathnormal">t</span><span class="mord mathnormal">h</span></span><span class="mord mathnormal" style="margin-right:0.1076em;">f</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">es</span><span class="mpunct">,</span></span></span></span>{results.length} errors`);
    return results;
}

Step 2 — Read PM2 Error Logs

Parse recent PM2 error logs to find runtime exceptions.

const os = require('os');

function readPM2Logs(processName = 'simulation', maxLines = 200) {
    const logPath = path.join(os.homedir(), '.pm2', 'logs', `${processName}-error.log`);

    if (!fs.existsSync(logPath)) {
        console.warn(`PM2 log not found at ${logPath}`);
        return [];
    }

    const content = fs.readFileSync(logPath, 'utf8');
    const lines = content.split('\n').slice(-maxLines);

    // Extract error patterns with context
    const errors = [];
    const ERROR_PATTERNS = [
        /ReferenceError: (\w+) is not defined/,
        /TypeError: Cannot read propert(?:y|ies) of (undefined|null)/,
        /TypeError: (\w+(?:\.\w+)*) is not a function/,
        /SyntaxError: (.+)/,
        /Error: (.+) at (.+\.js):(\d+)/
    ];

    for (let i = 0; i < lines.length; i++) {
        for (const pattern of ERROR_PATTERNS) {
            if (pattern.test(lines[i])) {
                // Extract filename from stack trace if available
                const fileMatch = lines.slice(i, i+5)
                    .join('\n')
                    .match(/at .+ \((.+\.js):(\d+):\d+\)/);

                errors.push({
                    message: lines[i].trim(),
                    file: fileMatch ? fileMatch[1] : null,
                    line: fileMatch ? parseInt(fileMatch[2]) : null,
                    context: lines.slice(Math.max(0, i-1), i+4).join('\n')
                });
                break;
            }
        }
    }

    console.log(`PM2 logs: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mrow><mi>e</mi><mi>r</mi><mi>r</mi><mi>o</mi><mi>r</mi><mi>s</mi><mi mathvariant="normal">.</mi><mi>l</mi><mi>e</mi><mi>n</mi><mi>g</mi><mi>t</mi><mi>h</mi></mrow><mi>e</mi><mi>r</mi><mi>r</mi><mi>o</mi><mi>r</mi><mi>s</mi><mi>f</mi><mi>o</mi><mi>u</mi><mi>n</mi><mi>d</mi><mi>i</mi><mi>n</mi><mi>l</mi><mi>a</mi><mi>s</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">{errors.length} errors found in last</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">er</span><span class="mord mathnormal" style="margin-right:0.0278em;">r</span><span class="mord mathnormal" style="margin-right:0.0278em;">or</span><span class="mord mathnormal">s</span><span class="mord">.</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">e</span><span class="mord mathnormal">n</span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mord mathnormal">t</span><span class="mord mathnormal">h</span></span><span class="mord mathnormal" style="margin-right:0.0278em;">er</span><span class="mord mathnormal" style="margin-right:0.0278em;">r</span><span class="mord mathnormal" style="margin-right:0.0278em;">or</span><span class="mord mathnormal">s</span><span class="mord mathnormal" style="margin-right:0.1076em;">f</span><span class="mord mathnormal">o</span><span class="mord mathnormal">u</span><span class="mord mathnormal">n</span><span class="mord mathnormal">d</span><span class="mord mathnormal">in</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">a</span><span class="mord mathnormal">s</span><span class="mord mathnormal">t</span></span></span></span>{maxLines} lines`);
    return errors;
}

Step 3 — Read Output Ledger for Failing Jobs

The output ledger tracks success/failure rates per job over time.

function getFailingJobs(ledgerPath = 'data/state/output-ledger.json') {
    if (!fs.existsSync(ledgerPath)) return [];

    const ledger = JSON.parse(fs.readFileSync(ledgerPath, 'utf8'));
    const failing = [];

    for (const [jobName, records] of Object.entries(ledger)) {
        if (!Array.isArray(records) || records.length < 3) continue;

        const recent = records.slice(-3);
        const failCount = recent.filter(r => r.status === 'failed').length;

        if (failCount >= 2) {  // 2+ of last 3 runs failed
            failing.push({
                job: jobName,
                recentFails: failCount,
                lastError: recent.reverse().find(r => r.error)?.error,
                lastRun: recent[0].timestamp
            });
        }
    }

    console.log(`Failing jobs: ${failing.length}`);
    return failing;
}

Step 4 — Generate Fixes with Coding LLM

For each bug, read the file and send it to Ollama with structured error context.

async function generateFix(filePath, errorMessage, fileContent) {
    const prompt = `You are a JavaScript debugging assistant. Fix the following error in the code.

ERROR:
${errorMessage}

FILE: ${path.basename(filePath)}
CONTENT:
\`\`\`javascript
${fileContent}
\`\`\`

INSTRUCTIONS:
1. Fix ONLY the specific error described above
2. Do NOT add new features or refactor unrelated code
3. Keep the same structure and style
4. Return ONLY the complete fixed JavaScript file, no explanation
5. Start your response with the first line of code (no markdown, no \`\`\`js)`;

    const response = await fetch('http://localhost:11434/api/generate', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
            model: 'qwen2.5-coder:7b',
            prompt,
            stream: false,
            think: false,
            options: { temperature: 0.1, num_predict: 4096 }
        }),
        signal: AbortSignal.timeout(120000)  // 2 min timeout
    });

    const data = await response.json();
    return data.response?.trim();
}

Step 5 — Apply Fix with Backup and Validation

Write the fix, verify syntax, and revert immediately if syntax check fails.

const BACKUP_DIR = path.join(__dirname, 'data', 'state', 'mechanic-backups');
fs.mkdirSync(BACKUP_DIR, { recursive: true });

async function applyFix(filePath, fixedContent) {
    const fileName = path.basename(filePath);
    const backupPath = path.join(BACKUP_DIR, `<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mrow><mi>f</mi><mi>i</mi><mi>l</mi><mi>e</mi><mi>N</mi><mi>a</mi><mi>m</mi><mi>e</mi></mrow><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">{fileName}.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1076em;">f</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">e</span><span class="mord mathnormal" style="margin-right:0.109em;">N</span><span class="mord mathnormal">am</span><span class="mord mathnormal">e</span></span><span class="mord">.</span></span></span></span>{Date.now()}.bak`);

    // 1. Create backup
    fs.copyFileSync(filePath, backupPath);
    console.log(`Backup: ${backupPath}`);

    // 2. Write fix
    fs.writeFileSync(filePath, fixedContent, 'utf8');

    // 3. Syntax check
    const check = syntaxCheck(filePath);

    if (check.ok) {
        console.log(`✅ Fix applied and validated: ${fileName}`);
        return { success: true, backup: backupPath };
    } else {
        // 4. Revert on failure
        fs.copyFileSync(backupPath, filePath);
        console.log(`⚠️ Fix reverted (syntax error): ${fileName}`);
        return { success: false, error: check.error, backup: backupPath };
    }
}

Step 6 — Enforce Rate Limits

Prevent runaway fix attempts with per-cycle and cooldown limits.

const STATE_FILE = 'data/state/mechanic-state.json';
const MAX_FIXES_PER_RUN = 3;
const COOLDOWN_MS = 10 * 60 * 1000;  // 10 minutes

function loadState() {
    if (fs.existsSync(STATE_FILE)) {
        return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
    }
    return { fixesThisRun: 0, lastRunAt: 0, fixHistory: [] };
}

function canAttemptFix(state, filePath) {
    if (state.fixesThisRun >= MAX_FIXES_PER_RUN) {
        console.log(`Rate limit: ${MAX_FIXES_PER_RUN} fixes per run reached`);
        return false;
    }
    
    // Check per-file cooldown
    const lastFix = state.fixHistory
        .filter(f => f.file === filePath)
        .sort((a, b) => b.timestamp - a.timestamp)[0];

    if (lastFix && Date.now() - lastFix.timestamp < COOLDOWN_MS) {
        const waitMins = Math.ceil((COOLDOWN_MS - (Date.now() - lastFix.timestamp)) / 60000);
        console.log(`Cooldown: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mrow><mi>p</mi><mi>a</mi><mi>t</mi><mi>h</mi><mi mathvariant="normal">.</mi><mi>b</mi><mi>a</mi><mi>s</mi><mi>e</mi><mi>n</mi><mi>a</mi><mi>m</mi><mi>e</mi><mo stretchy="false">(</mo><mi>f</mi><mi>i</mi><mi>l</mi><mi>e</mi><mi>P</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo stretchy="false">)</mo></mrow><mtext>—</mtext><mi>w</mi><mi>a</mi><mi>i</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">{path.basename(filePath)} — wait</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="mord mathnormal">a</span><span class="mord mathnormal">t</span><span class="mord mathnormal">h</span><span class="mord">.</span><span class="mord mathnormal">ba</span><span class="mord mathnormal">se</span><span class="mord mathnormal">nam</span><span class="mord mathnormal">e</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.1076em;">f</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">e</span><span class="mord mathnormal" style="margin-right:0.1389em;">P</span><span class="mord mathnormal">a</span><span class="mord mathnormal">t</span><span class="mord mathnormal">h</span><span class="mclose">)</span></span><span class="mord">—</span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="mord mathnormal">ai</span><span class="mord mathnormal">t</span></span></span></span>{waitMins}m`);
        return false;
    }

    return true;
}

Step 7 — Main Mechanic Loop

Orchestrate all steps and log results.

const LOG_FILE = 'data/state/mechanic-log.json';

async function runMechanic() {
    const state = loadState();
    state.fixesThisRun = 0;
    const log = [];
    const startTime = Date.now();

    // Collect all bug reports
    const syntaxErrors = scanAllFiles(JOBS_DIR);
    const runtimeErrors = readPM2Logs('simulation');
    const failingJobs = getFailingJobs();

    const bugs = [
        ...syntaxErrors.map(e => ({ type: 'syntax', file: e.path, error: e.error })),
        ...runtimeErrors
            .filter(e => e.file && !PROTECTED_FILES.has(path.basename(e.file || '')))
            .map(e => ({ type: 'runtime', file: e.file, error: e.message })),
    ].filter(b => b.file && fs.existsSync(b.file));

    console.log(`Total bugs to attempt: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mrow><mi>b</mi><mi>u</mi><mi>g</mi><mi>s</mi><mi mathvariant="normal">.</mi><mi>l</mi><mi>e</mi><mi>n</mi><mi>g</mi><mi>t</mi><mi>h</mi></mrow><mo stretchy="false">(</mo><mi>m</mi><mi>a</mi><mi>x</mi></mrow><annotation encoding="application/x-tex">{bugs.length} (max</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="mord mathnormal" style="margin-right:0.0359em;">ug</span><span class="mord mathnormal">s</span><span class="mord">.</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">e</span><span class="mord mathnormal">n</span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mord mathnormal">t</span><span class="mord mathnormal">h</span></span><span class="mopen">(</span><span class="mord mathnormal">ma</span><span class="mord mathnormal">x</span></span></span></span>{MAX_FIXES_PER_RUN})`);

    for (const bug of bugs) {
        if (state.fixesThisRun >= MAX_FIXES_PER_RUN) break;
        if (PROTECTED_FILES.has(path.basename(bug.file))) continue;
        if (!canAttemptFix(state, bug.file)) continue;

        console.log(`\nAttempting fix: ${path.basename(bug.file)}`);
        const content = fs.readFileSync(bug.file, 'utf8');
        const fixedContent = await generateFix(bug.file, bug.error, content);

        if (!fixedContent || fixedContent.length < 50) {
            log.push({ file: bug.file, status: 'llm_empty', error: bug.error, ts: Date.now() });
            continue;
        }

        const result = await applyFix(bug.file, fixedContent);
        state.fixesThisRun++;
        state.fixHistory.push({
            file: bug.file,
            timestamp: Date.now(),
            success: result.success
        });

        log.push({
            file: path.basename(bug.file),
            bugType: bug.type,
            error: bug.error.slice(0, 200),
            status: result.success ? 'fixed' : 'reverted',
            ts: Date.now()
        });
    }

    // Save state and log
    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
    const existingLog = fs.existsSync(LOG_FILE)
        ? JSON.parse(fs.readFileSync(LOG_FILE, 'utf8'))
        : [];
    fs.writeFileSync(LOG_FILE, JSON.stringify([...existingLog, ...log].slice(-200), null, 2));

    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
    console.log(`\n=== Mechanic complete in ${elapsed}s ===`);
    console.log(`Bugs found: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mrow><mi>b</mi><mi>u</mi><mi>g</mi><mi>s</mi><mi mathvariant="normal">.</mi><mi>l</mi><mi>e</mi><mi>n</mi><mi>g</mi><mi>t</mi><mi>h</mi></mrow><mi mathvariant="normal">∣</mi><mi>F</mi><mi>i</mi><mi>x</mi><mi>e</mi><mi>s</mi><mi>a</mi><mi>p</mi><mi>p</mi><mi>l</mi><mi>i</mi><mi>e</mi><mi>d</mi><mo>:</mo></mrow><annotation encoding="application/x-tex">{bugs.length} | Fixes applied:</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="mord mathnormal" style="margin-right:0.0359em;">ug</span><span class="mord mathnormal">s</span><span class="mord">.</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">e</span><span class="mord mathnormal">n</span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mord mathnormal">t</span><span class="mord mathnormal">h</span></span><span class="mord">∣</span><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="mord mathnormal">i</span><span class="mord mathnormal">x</span><span class="mord mathnormal">es</span><span class="mord mathnormal">a</span><span class="mord mathnormal" style="margin-right:0.0197em;">ppl</span><span class="mord mathnormal">i</span><span class="mord mathnormal">e</span><span class="mord mathnormal">d</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">:</span></span></span></span>{log.filter(l => l.status === 'fixed').length} | Reverted: ${log.filter(l => l.status === 'reverted').length}`);
}

runMechanic().catch(console.error);

Safety Properties

Production Results (AI Indigo, March 2026)

• Running 24/7 on Mac Studio M4 Max, 10-minute cycles
• 52 active job files monitored
• Avg bugs detected per cycle: 0-2 (most cycles clean)
• Fix success rate: ~70% (syntax fixes near 100%; runtime error fixes ~50%)
• Zero catastrophic failures in 3 weeks of production