index.js

#!/usr/bin/env node

const fs = require('fs');
const https = require('https');
const http = require('http');

const args = process.argv.slice(2);

if (args.includes('-h') || args.includes('--help') || args.length === 0) {
  console.log(`
🔥 roast-my-code - AI brutally roasts your code

Usage:
  roast <file>              Roast a file
  roast <file> --harsh      Extra brutal mode
  roast <file> --kind       Gentle roasting (for sensitive devs)
  cat file.js | roast -     Roast from stdin

Environment:
  OPENAI_API_KEY      Use OpenAI (gpt-4o-mini)
  ANTHROPIC_API_KEY   Use Anthropic (claude-3-haiku)
  OLLAMA_HOST         Use Ollama (default: http://localhost:11434)

Examples:
  roast src/index.js
  roast app.py --harsh
  OPENAI_API_KEY=sk-... roast main.go
`);
  process.exit(0);
}

const harsh = args.includes('--harsh');
const kind = args.includes('--kind');
const file = args.find(a => !a.startsWith('--'));

let code = '';

async function main() {
  // Read code
  if (file === '-') {
    code = fs.readFileSync(0, 'utf8');
  } else if (file && fs.existsSync(file)) {
    code = fs.readFileSync(file, 'utf8');
  } else {
    console.error('Error: File not found');
    process.exit(1);
  }

  if (code.length > 10000) {
    code = code.slice(0, 10000) + '\n... [truncated]';
  }

  const tone = harsh ? 'extremely brutal, savage, no mercy' : 
               kind ? 'gentle but still funny' : 
               'brutally honest but hilarious';

  const prompt = `You are a code roaster. Your job is to roast the following code in a ${tone} way.

Rules:
- Be funny and creative with your insults
- Point out actual code smells, anti-patterns, and issues
- Use programming humor and references
- Keep it under 300 words
- End with a brutal rating out of 10

CODE TO ROAST:
\`\`\`
${code}
\`\`\`

Now roast this code like it owes you money:`;

  console.log('\n🔥 Roasting your code...\n');

  try {
    const roast = await callAI(prompt);
    console.log(roast);
    console.log();
  } catch (err) {
    console.error('Error:', err.message);
    console.error('\nMake sure you have set one of: OPENAI_API_KEY, ANTHROPIC_API_KEY, or have Ollama running');
    process.exit(1);
  }
}

async function callAI(prompt) {
  // Try OpenAI
  if (process.env.OPENAI_API_KEY) {
    return callOpenAI(prompt);
  }
  
  // Try Anthropic
  if (process.env.ANTHROPIC_API_KEY) {
    return callAnthropic(prompt);
  }
  
  // Try Ollama
  return callOllama(prompt);
}

function callOpenAI(prompt) {
  return new Promise((resolve, reject) => {
    const data = JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [{ role: 'user', content: prompt }],
      max_tokens: 1000
    });

    const req = https.request({
      hostname: 'api.openai.com',
      path: '/v1/chat/completions',
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`
      }
    }, res => {
      let body = '';
      res.on('data', chunk => body += chunk);
      res.on('end', () => {
        try {
          const json = JSON.parse(body);
          if (json.error) reject(new Error(json.error.message));
          else resolve(json.choices[0].message.content);
        } catch (e) {
          reject(new Error('Failed to parse OpenAI response'));
        }
      });
    });
    req.on('error', reject);
    req.write(data);
    req.end();
  });
}

function callAnthropic(prompt) {
  return new Promise((resolve, reject) => {
    const data = JSON.stringify({
      model: 'claude-3-haiku-20240307',
      max_tokens: 1000,
      messages: [{ role: 'user', content: prompt }]
    });

    const req = https.request({
      hostname: 'api.anthropic.com',
      path: '/v1/messages',
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': process.env.ANTHROPIC_API_KEY,
        'anthropic-version': '2023-06-01'
      }
    }, res => {
      let body = '';
      res.on('data', chunk => body += chunk);
      res.on('end', () => {
        try {
          const json = JSON.parse(body);
          if (json.error) reject(new Error(json.error.message));
          else resolve(json.content[0].text);
        } catch (e) {
          reject(new Error('Failed to parse Anthropic response'));
        }
      });
    });
    req.on('error', reject);
    req.write(data);
    req.end();
  });
}

function callOllama(prompt) {
  return new Promise((resolve, reject) => {
    const host = process.env.OLLAMA_HOST || 'http://localhost:11434';
    const url = new URL('/api/generate', host);
    
    const data = JSON.stringify({
      model: 'llama3.2',
      prompt: prompt,
      stream: false
    });

    const proto = url.protocol === 'https:' ? https : http;
    const req = proto.request({
      hostname: url.hostname,
      port: url.port,
      path: url.pathname,
      method: 'POST',
      headers: { 'Content-Type': 'application/json' }
    }, res => {
      let body = '';
      res.on('data', chunk => body += chunk);
      res.on('end', () => {
        try {
          const json = JSON.parse(body);
          resolve(json.response);
        } catch (e) {
          reject(new Error('Failed to parse Ollama response. Is Ollama running?'));
        }
      });
    });
    req.on('error', () => reject(new Error('Could not connect to Ollama. Is it running?')));
    req.write(data);
    req.end();
  });
}

main();