---
name: autonomous-code-mechanic
description: Continuously scan a Node.js codebase for bugs, generate fixes with a local coding LLM, validate via syntax check, and auto-revert on failure. Production-proven self-healing system.
allowed-tools: Bash(node *), Bash(curl *)
---

# Autonomous Code Maintenance Worker

## Prerequisites
- Node.js 18+
- Ollama running locally with a coding model (e.g., qwen2.5-coder:7b or larger)

## Step 1: Set up test environment
```bash
mkdir -p /tmp/mechanic-demo/src /tmp/mechanic-demo/backups
cat > /tmp/mechanic-demo/src/worker.js << 'WORKEREOF'
const fs = require('fs');
function processData(input) {
  const data = JSON.pars(input);
  const result = data.items.map(item => item.score * 2));
  return result;
}
module.exports = { processData };
WORKEREOF
echo "Test file created with deliberate bugs"
node --check /tmp/mechanic-demo/src/worker.js 2>&1 || echo "(expected: syntax error)"
```
Expected output: SyntaxError reported

## Step 2: Scan for bugs
```bash
node << 'SCAN'
const fs = require('fs');
const { execSync } = require('child_process');
const SRC_DIR = '/tmp/mechanic-demo/src';
const PROTECTED = new Set(['core.js', 'main.js']);
const bugs = [];
for (const file of fs.readdirSync(SRC_DIR).filter(f => f.endsWith('.js'))) {
  if (PROTECTED.has(file)) continue;
  const filePath = SRC_DIR + '/' + file;
  try {
    execSync('node --check "' + filePath + '"', { encoding: 'utf8', timeout: 10000 });
    console.log('OK: ' + file);
  } catch (e) {
    const error = (e.stderr || e.stdout || e.message).substring(0, 300);
    bugs.push({ file: filePath, fileName: file, error, priority: 100 });
    console.log('BUG: ' + file + ' — ' + error.split('\n')[0]);
  }
}
fs.writeFileSync('/tmp/mechanic-demo/bugs.json', JSON.stringify(bugs, null, 2));
console.log('Found ' + bugs.length + ' bugs');
SCAN
```
Expected output: At least 1 BUG reported, bugs.json created

## Step 3: Generate and apply fixes via local LLM
```bash
node << 'FIX'
const fs = require('fs');
const { execSync } = require('child_process');
const BACKUP_DIR = '/tmp/mechanic-demo/backups';
const OLLAMA_URL = process.env.OLLAMA_URL || 'http://localhost:11434';
const MODEL = process.env.CODER_MODEL || 'qwen2.5-coder:7b';
const bugs = JSON.parse(fs.readFileSync('/tmp/mechanic-demo/bugs.json', 'utf8'));

async function generateFix(filePath, fileContent, errorContext) {
  const prompt = 'Fix this Node.js syntax error.\n\nERROR:\n' + errorContext.substring(0,500) +
    '\n\nCODE:\n' + fileContent.substring(0,4000) +
    '\n\nReturn ONLY the complete fixed file. No explanation. No markdown fences.';
  const resp = await fetch(OLLAMA_URL + '/api/generate', {
    method: 'POST', headers: {'Content-Type':'application/json'},
    body: JSON.stringify({model: MODEL, prompt, stream: false, options: {num_predict:4000, temperature:0.1}}),
    signal: AbortSignal.timeout(120000),
  });
  const data = await resp.json();
  let code = (data.response || '').trim().replace(/^```(?:javascript|js)?\s*\n?/gm,'').replace(/```\s*$/gm,'').trim();
  return code.length > 50 ? code : null;
}

(async () => {
  for (const bug of bugs.slice(0, 3)) {
    console.log('Fixing: ' + bug.fileName);
    const original = fs.readFileSync(bug.file, 'utf8');
    const backupPath = BACKUP_DIR + '/' + bug.fileName + '-' + Date.now() + '.bak';
    fs.writeFileSync(backupPath, original);
    const fixed = await generateFix(bug.file, original, bug.error);
    if (!fixed) { console.log('  LLM returned empty — skipping'); continue; }
    fs.writeFileSync(bug.file, fixed);
    try {
      execSync('node --check "' + bug.file + '"', {encoding:'utf8', timeout:10000});
      console.log('  APPLIED — syntax passes');
    } catch (e) {
      fs.writeFileSync(bug.file, original);
      console.log('  REVERTED — syntax failed after fix');
    }
  }
})();
FIX
```
Expected output: APPLIED or REVERTED per file. Backup files created in /tmp/mechanic-demo/backups/

## Step 4: Verify
```bash
for f in /tmp/mechanic-demo/src/*.js; do node --check "$f" 2>&1 && echo "OK: $(basename $f)" || echo "BROKEN: $(basename $f)"; done
ls -la /tmp/mechanic-demo/backups/
```
Expected output: Fixed files pass syntax check. Backup files exist.