// src/linter.js
import Anthropic from '@anthropic-ai/sdk';
import { readFileSync } from 'fs';

const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

const SYSTEM_PROMPT = `You are a code linter. Analyze code for real bugs, security issues, and bad practices.

Return ONLY valid JSON in this exact format:
{
  "issues": [
    {
      "line": <number>,
      "column": <number>,
      "severity": "error" | "warning" | "info",
      "rule": "<short-rule-name>",
      "message": "<description of the issue>"
    }
  ]
}

Focus on:
- Security vulnerabilities (SQL injection, XSS, hardcoded secrets)
- Logic errors (off-by-one, null dereference, unreachable code)
- Performance issues (N+1 queries, unnecessary re-renders)
- Bad patterns (mutable default args in Python, var in JS, etc.)

Do NOT report style issues like formatting or naming conventions.
Return an empty issues array if no problems found.`;

export async function lintFile(filePath) {
  const code = readFileSync(filePath, 'utf-8');
  const extension = filePath.split('.').pop();

  const response = await client.messages.create({
    model: 'claude-haiku-4-5',
    max_tokens: 1024,
    system: SYSTEM_PROMPT,
    messages: [{
      role: 'user',
      content: `File: ${filePath}\nLanguage: ${extension}\n\n\`\`\`${extension}\n${code}\n\`\`\``
    }]
  });

  const text = response.content[0].text;
  const jsonMatch = text.match(/\{[\s\S]*\}/);
  if (!jsonMatch) throw new Error(`Could not parse linter response for ${filePath}`);

  const result = JSON.parse(jsonMatch[0]);
  return { filePath, issues: result.issues || [] };
}

// src/cli.js
import { program } from 'commander';
import { glob } from 'glob';
import { lintFile } from './linter.js';

program
  .name('ai-lint')
  .argument('[patterns...]', 'File patterns to lint', ['**/*.js', '**/*.ts', '**/*.py'])
  .option('--json', 'Output results as JSON')
  .option('--severity <level>', 'Minimum severity (error|warning|info)', 'warning')
  .action(async (patterns, options) => {
    const files = await glob(patterns, {
      ignore: ['node_modules/**', '.git/**', 'dist/**']
    });

    if (files.length === 0) { console.error('No files matched'); process.exit(0); }

    const severityOrder = { error: 0, warning: 1, info: 2 };
    const minSeverity = severityOrder[options.severity] ?? 1;
    let totalErrors = 0;
    const allResults = [];

    const batchSize = 5;
    for (let i = 0; i < files.length; i += batchSize) {
      const batch = files.slice(i, i + batchSize);
      const results = await Promise.all(batch.map(lintFile));

      for (const result of results) {
        const filtered = result.issues.filter(
          issue => severityOrder[issue.severity] <= minSeverity
        );
        if (filtered.length > 0) {
          allResults.push({ ...result, issues: filtered });
          totalErrors += filtered.filter(i => i.severity === 'error').length;
        }
      }
    }

    if (options.json) {
      console.log(JSON.stringify(allResults, null, 2));
    } else {
      for (const result of allResults) {
        for (const issue of result.issues) {
          const loc = `${result.filePath}:${issue.line}:${issue.column}`;
          const sev = issue.severity.toUpperCase().padEnd(7);
          console.log(`${loc}  ${sev}  ${issue.message}  (${issue.rule})`);
        }
      }
      console.log(`\n${totalErrors} error(s) found across ${allResults.length} file(s)`);
    }

    if (totalErrors > 0) process.exit(1);
  });

program.parse();

import { createHash } from 'crypto';
import { existsSync, readFileSync, writeFileSync } from 'fs';

const CACHE_PATH = '.ai-lint-cache.json';

function getCache() {
  if (!existsSync(CACHE_PATH)) return {};
  return JSON.parse(readFileSync(CACHE_PATH, 'utf-8'));
}

function hashFile(content) {
  return createHash('sha256').update(content).digest('hex').slice(0, 16);
}

export async function lintFileWithCache(filePath) {
  const content = readFileSync(filePath, 'utf-8');
  const hash = hashFile(content);
  const cache = getCache();

  if (cache[filePath]?.hash === hash) {
    return cache[filePath].result;
  }

  const result = await lintFile(filePath);
  cache[filePath] = { hash, result };
  writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2));
  return result;
}