fchek 1.0.0

package/lib/lint.js

@@ -0,0 +1,624 @@
+'use strict';
+
+/**
+ * lint.js — linter + auto-fix + show diff of what changed
+ *
+ * Python (.py)     → ruff check --fix  (fast, modern)
+ * Rust             → cargo clippy --fix
+ * JS/TS            → eslint --fix
+ * C/C++            → clang-tidy --fix-errors (or clang-format)
+ * Go               → gofmt -w + go vet
+ *
+ * Always:
+ *   1. Read file before fix
+ *   2. Apply fixes
+ *   3. Read file after fix
+ *   4. Build unified diff
+ *   5. Return issues + diff in JSON
+ */
+
+const { spawnSync, execSync } = require('child_process');
+const path   = require('path');
+const fs     = require('fs');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek lint <file_or_dir> [--no-fix] [--strict]
+
+Run linter, apply safe auto-fixes, and show a diff of what changed.
+
+Supported:
+  .py          → ruff  (pip install ruff)
+  .rs / Cargo  → cargo clippy --fix
+  .js / .ts    → eslint --fix  (npm install -g eslint)
+  .c / .cpp    → clang-tidy + clang-format
+  .go          → gofmt -w + go vet
+
+Options:
+  --no-fix    Report issues only, do not modify files
+  --strict    Include warnings (not just errors)
+
+Examples:
+  fchek lint main.py
+  fchek lint src/
+  fchek lint app.ts --no-fix
+  fchek lint . --strict       (Rust: cargo clippy in cwd)
+`.trim();
+
+const DEFAULT_TIMEOUT = 60_000;
+
+function commandExists(cmd) {
+  try {
+    execSync(process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch { return false; }
+}
+
+function readFile(p) {
+  try { return fs.readFileSync(p, 'utf8'); } catch { return null; }
+}
+
+/** Build a simple unified-diff-like structure between two strings */
+function buildLineDiff(before, after, filePath) {
+  if (before === after) return [];
+  const bLines = before.split('\n');
+  const aLines = after.split('\n');
+  const hunks  = [];
+  const maxLen = Math.max(bLines.length, aLines.length);
+
+  let i = 0;
+  while (i < maxLen) {
+    if (bLines[i] !== aLines[i]) {
+      const hunkStart = i;
+      const hunk = { file: filePath, from_line: i + 1, changes: [] };
+      while (i < maxLen && (bLines[i] !== aLines[i] || (i - hunkStart < 3))) {
+        if (i >= maxLen) break;
+        if (bLines[i] !== aLines[i]) {
+          if (bLines[i] !== undefined) hunk.changes.push({ op: '-', line: i + 1, text: bLines[i] });
+          if (aLines[i] !== undefined) hunk.changes.push({ op: '+', line: i + 1, text: aLines[i] });
+        } else {
+          hunk.changes.push({ op: ' ', line: i + 1, text: bLines[i] });
+        }
+        i++;
+        if (hunk.changes.length > 20) break;
+      }
+      hunks.push(hunk);
+    } else {
+      i++;
+    }
+  }
+  return hunks.slice(0, 15); // cap hunks
+}
+
+// ─── Python: ruff ─────────────────────────────────────────────────────────────
+
+function lintPython(target, fix, strict, timeoutMs) {
+  if (!commandExists('ruff')) {
+    return output(fail('ruff not found. Install: pip install ruff'));
+  }
+
+  // 1. Capture issues BEFORE fixing
+  const checkArgs = ['check', '--output-format=json', target];
+  const checkRes  = spawnSync('ruff', checkArgs, { encoding: 'utf8', timeout: timeoutMs });
+
+  let issuesBefore = [];
+  try { issuesBefore = JSON.parse(checkRes.stdout || '[]'); } catch {}
+
+  let diff = [];
+  let issuesAfter = issuesBefore;
+
+  if (fix) {
+    // Snapshot files before fix
+    const snapshotBefore = snapshotFiles(target, ['.py']);
+
+    const fixArgs = ['check', '--fix', target];
+    spawnSync('ruff', fixArgs, { encoding: 'utf8', timeout: timeoutMs });
+    spawnSync('ruff', ['format', target], { encoding: 'utf8', timeout: timeoutMs });
+
+    // Snapshot after fix
+    const snapshotAfter = snapshotFiles(target, ['.py']);
+
+    // Build diff for changed files
+    for (const [file, before] of Object.entries(snapshotBefore)) {
+      const after = snapshotAfter[file];
+      if (after && before !== after) {
+        diff.push(...buildLineDiff(before, after, file));
+      }
+    }
+
+    // Re-check to see remaining issues
+    const recheckRes = spawnSync('ruff', ['check', '--output-format=json', target], { encoding: 'utf8', timeout: timeoutMs });
+    try { issuesAfter = JSON.parse(recheckRes.stdout || '[]'); } catch {}
+  }
+
+  const fixedCount = issuesBefore.length - issuesAfter.length;
+
+  output(ok({
+    target,
+    lang:  'python',
+    tool:  'ruff',
+    fix_applied: fix,
+    issues_before: issuesBefore.length,
+    issues_after:  issuesAfter.length,
+    fixed_count:   fixedCount,
+    remaining_issues: issuesAfter.slice(0, 30).map(i => ({
+      file:    i.filename,
+      line:    i.location?.row,
+      col:     i.location?.column,
+      code:    i.code,
+      message: i.message,
+    })),
+    diff: diff.slice(0, 20),
+  }));
+}
+
+// ─── Rust: cargo clippy ───────────────────────────────────────────────────────
+
+function lintRust(target, fix, strict, timeoutMs) {
+  if (!commandExists('cargo')) {
+    return output(fail('cargo not found. Install Rust: https://rustup.rs'));
+  }
+
+  const cwd = path.resolve(target === '.' ? process.cwd() : target);
+  const strictFlag = strict ? ['--', '-W', 'clippy::all'] : [];
+
+  // Run clippy check first to get issues
+  const checkArgs = ['clippy', '--message-format=json', ...strictFlag];
+  const checkRes  = spawnSync('cargo', checkArgs, { encoding: 'utf8', cwd, timeout: timeoutMs });
+
+  const issuesBefore = parseCargoMessages(checkRes.stdout || '');
+
+  let diff = [];
+  let issuesAfter = issuesBefore;
+  let fixNote = null;
+
+  if (fix) {
+    // cargo clippy --fix requires either a clean git repo OR --allow-dirty/--allow-staged.
+    // If not a git repo at all, those flags still cause an error on some versions.
+    // Detect whether we are inside a git repo.
+    const isGitRepo = (() => {
+      try {
+        const r = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
+          encoding: 'utf8', cwd, timeout: 3000,
+        });
+        return r.status === 0;
+      } catch { return false; }
+    })();
+
+    const fixArgs = isGitRepo
+      ? ['clippy', '--fix', '--allow-dirty', '--allow-staged', ...strictFlag]
+      : ['clippy', '--fix', ...strictFlag];  // no git flags if no repo
+
+    const snapshotBefore = snapshotDir(cwd, ['.rs']);
+    const fixRes = spawnSync('cargo', fixArgs, { encoding: 'utf8', cwd, timeout: timeoutMs });
+
+    // If clippy --fix failed because of git check even without the flags, report clearly
+    if (fixRes.status !== 0) {
+      const errOut = (fixRes.stderr || '');
+      if (errOut.includes('no VCS found') || errOut.includes('uncommitted changes')) {
+        fixNote = 'cargo clippy --fix requires a git repository or clean working tree. ' +
+          'Run: git init && git add . && git commit -m init — then re-run fchek lint.';
+        // Still report issues found, just without fixes applied
+      }
+    }
+
+    const snapshotAfter = snapshotDir(cwd, ['.rs']);
+    for (const [file, before] of Object.entries(snapshotBefore)) {
+      const after = snapshotAfter[file];
+      if (after && before !== after) {
+        diff.push(...buildLineDiff(before, after, file));
+      }
+    }
+
+    const recheckRes = spawnSync('cargo', checkArgs, { encoding: 'utf8', cwd, timeout: timeoutMs });
+    issuesAfter = parseCargoMessages(recheckRes.stdout || '');
+  }
+
+  output(ok({
+    target: cwd,
+    lang:   'rust',
+    tool:   'cargo-clippy',
+    fix_applied:    fix && !fixNote,
+    fix_note:       fixNote,
+    issues_before:  issuesBefore.length,
+    issues_after:   issuesAfter.length,
+    fixed_count:    issuesBefore.length - issuesAfter.length,
+    remaining_issues: issuesAfter.slice(0, 20),
+    diff: diff.slice(0, 20),
+  }));
+}
+
+function parseCargoMessages(raw) {
+  const issues = [];
+  for (const line of raw.split('\n')) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.reason === 'compiler-message' && msg.message?.level === 'warning') {
+        issues.push({
+          message: msg.message.message,
+          code:    msg.message.code?.code ?? null,
+          spans:   (msg.message.spans || []).slice(0, 2).map(s => ({
+            file: s.file_name, line: s.line_start,
+          })),
+        });
+      }
+    } catch {}
+  }
+  return issues;
+}
+
+// ─── JS/TS: eslint ────────────────────────────────────────────────────────────
+
+function lintJs(target, fix, strict, timeoutMs) {
+  const eslint = commandExists('eslint') ? 'eslint' : null;
+  if (!eslint) {
+    return output(fail('eslint not found. Install: npm install -g eslint'));
+  }
+
+  const snapshotBefore = snapshotFiles(target, ['.js', '.ts', '.jsx', '.tsx', '.mjs']);
+  const checkArgs = [target, '--format=json', fix ? '--fix' : ''];
+  const res = spawnSync(eslint, checkArgs.filter(Boolean), { encoding: 'utf8', timeout: timeoutMs });
+
+  let issues = [];
+  try {
+    const parsed = JSON.parse(res.stdout || '[]');
+    for (const file of parsed) {
+      for (const msg of file.messages || []) {
+        if (!strict && msg.severity < 2) continue;
+        issues.push({
+          file:    file.filePath,
+          line:    msg.line,
+          col:     msg.column,
+          rule:    msg.ruleId,
+          message: msg.message,
+          severity: msg.severity === 2 ? 'error' : 'warning',
+        });
+      }
+    }
+  } catch {}
+
+  let diff = [];
+  if (fix) {
+    const snapshotAfter = snapshotFiles(target, ['.js', '.ts', '.jsx', '.tsx', '.mjs']);
+    for (const [file, before] of Object.entries(snapshotBefore)) {
+      const after = snapshotAfter[file];
+      if (after && before !== after) diff.push(...buildLineDiff(before, after, file));
+    }
+  }
+
+  output(ok({
+    target,
+    lang: 'javascript',
+    tool: 'eslint',
+    fix_applied: fix,
+    remaining_issues: issues.slice(0, 30),
+    issue_count: issues.length,
+    diff: diff.slice(0, 20),
+  }));
+}
+
+// ─── C#: dotnet format + dotnet build ────────────────────────────────────────
+
+function lintCSharp(target, fix, timeoutMs) {
+  if (!commandExists('dotnet')) {
+    return output(fail('dotnet not found. Install .NET SDK: https://dotnet.microsoft.com/download'));
+  }
+
+  // Find project root (where .csproj or .sln lives)
+  let projDir = path.resolve(fs.statSync(target).isDirectory() ? target : path.dirname(target));
+  for (let i = 0; i < 6; i++) {
+    const found = fs.readdirSync(projDir).find(f => f.endsWith('.csproj') || f.endsWith('.sln'));
+    if (found) break;
+    const parent = path.dirname(projDir);
+    if (parent === projDir) { projDir = null; break; }
+    projDir = parent;
+  }
+
+  if (!projDir) {
+    return output(fail('No .csproj or .sln found. Run: dotnet new console -o MyApp'));
+  }
+
+  // Snapshot .cs files before fix
+  const snapshotBefore = fix ? snapshotFiles(projDir, ['.cs']) : {};
+
+  // Run dotnet format
+  const formatArgs = fix
+    ? ['format', projDir]
+    : ['format', projDir, '--verify-no-changes'];
+
+  const formatRes = spawnSync('dotnet', formatArgs, {
+    encoding: 'utf8', cwd: projDir, timeout: timeoutMs,
+  });
+
+  // Build diff if fix was applied
+  const diff = [];
+  if (fix) {
+    const snapshotAfter = snapshotFiles(projDir, ['.cs']);
+    for (const [file, before] of Object.entries(snapshotBefore)) {
+      const after = snapshotAfter[file];
+      if (after && before !== after) diff.push(...buildLineDiff(before, after, file));
+    }
+  }
+
+  // Run dotnet build to catch compiler errors/warnings
+  const buildRes = spawnSync('dotnet', ['build', projDir, '--no-restore', '-v', 'quiet'],
+    { encoding: 'utf8', cwd: projDir, timeout: timeoutMs });
+
+  const buildOutput = (buildRes.stdout || '') + (buildRes.stderr || '');
+  const issues = [];
+  for (const line of buildOutput.split('\n')) {
+    // Format: file.cs(line,col): warning/error CS1234: message
+    const m = line.match(/^(.+\.cs)\((\d+),(\d+)\):\s+(warning|error)\s+(CS\d+):\s+(.+)$/);
+    if (m) {
+      issues.push({
+        file: m[1], line: parseInt(m[2]), col: parseInt(m[3]),
+        severity: m[4], code: m[5], message: m[6].trim(),
+      });
+    }
+  }
+
+  const formatFailed = !fix && formatRes.status !== 0;
+
+  output(ok({
+    target: projDir,
+    lang: 'csharp',
+    tools: ['dotnet format', 'dotnet build'],
+    fix_applied: fix,
+    format_needs_changes: formatFailed,
+    issues_count: issues.length,
+    remaining_issues: issues.slice(0, 30),
+    diff: diff.slice(0, 20),
+    build_clean: buildRes.status === 0,
+  }));
+}
+
+// ─── C/C++: clang-format + clang-tidy ────────────────────────────────────────
+
+function lintC(file, fix, timeoutMs) {
+  const results = { issues: [], diff: [] };
+
+  // clang-format
+  if (commandExists('clang-format')) {
+    const before = readFile(file);
+    const fmtRes = spawnSync('clang-format', [file], { encoding: 'utf8', timeout: timeoutMs });
+    const after  = fmtRes.stdout || '';
+    if (fix && before && before !== after) {
+      fs.writeFileSync(file, after, 'utf8');
+      results.diff.push(...buildLineDiff(before, after, file));
+    }
+  }
+
+  // clang-tidy issues (no auto-fix to avoid breaking changes)
+  if (commandExists('clang-tidy')) {
+    const tidyRes = spawnSync('clang-tidy', [file, '--'], { encoding: 'utf8', timeout: timeoutMs });
+    const lines = (tidyRes.stdout || tidyRes.stderr || '').split('\n');
+    for (const line of lines) {
+      const m = line.match(/^(.+):(\d+):(\d+):\s+(warning|error):\s+(.+)\[(.+)\]$/);
+      if (m) {
+        results.issues.push({
+          file: m[1], line: parseInt(m[2]), col: parseInt(m[3]),
+          severity: m[4], message: m[5], code: m[6],
+        });
+      }
+    }
+  }
+
+  output(ok({
+    target: path.resolve(file),
+    lang: 'c',
+    tools: ['clang-format', 'clang-tidy'],
+    fix_applied: fix,
+    remaining_issues: results.issues.slice(0, 30),
+    issue_count: results.issues.length,
+    diff: results.diff.slice(0, 20),
+  }));
+}
+
+// ─── Go: gofmt + go vet ──────────────────────────────────────────────────────
+
+function lintGo(target, fix, timeoutMs) {
+  if (!commandExists('gofmt')) {
+    return output(fail('gofmt not found. Install Go: https://go.dev'));
+  }
+
+  const files = fs.statSync(target).isDirectory()
+    ? findFiles(target, ['.go'])
+    : [target];
+
+  const allDiff  = [];
+  const vetIssues = [];
+
+  for (const file of files) {
+    const before  = readFile(file);
+    const fmtRes  = spawnSync('gofmt', ['-l', file], { encoding: 'utf8', timeout: 10_000 });
+    const needsFmt = (fmtRes.stdout || '').trim() !== '';
+
+    if (fix && needsFmt) {
+      spawnSync('gofmt', ['-w', file], { encoding: 'utf8' });
+      const after = readFile(file);
+      if (before && after && before !== after) {
+        allDiff.push(...buildLineDiff(before, after, file));
+      }
+    }
+  }
+
+  // go vet
+  const vetRes = spawnSync('go', ['vet', './...'], { encoding: 'utf8', cwd: path.resolve(target), timeout: timeoutMs });
+  for (const line of (vetRes.stderr || '').split('\n')) {
+    if (line.trim()) vetIssues.push(line.trim());
+  }
+
+  output(ok({
+    target,
+    lang: 'go',
+    tools: ['gofmt', 'go vet'],
+    fix_applied: fix,
+    vet_issues: vetIssues.slice(0, 20),
+    issue_count: vetIssues.length,
+    diff: allDiff.slice(0, 20),
+  }));
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function findFiles(dir, exts) {
+  const results = [];
+  const ignored = new Set(['node_modules', '.git', 'dist', 'target', 'build']);
+  function walk(d) {
+    let entries;
+    try { entries = fs.readdirSync(d); } catch { return; }
+    for (const name of entries) {
+      if (ignored.has(name)) continue;
+      const full = path.join(d, name);
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) walk(full);
+      else if (exts.includes(path.extname(name).toLowerCase())) results.push(full);
+    }
+  }
+  walk(dir);
+  return results;
+}
+
+function snapshotFiles(target, exts) {
+  const snap = {};
+  const stat = fs.existsSync(target) && fs.statSync(target);
+  if (!stat) return snap;
+  const files = stat.isDirectory() ? findFiles(target, exts) : [target];
+  for (const f of files) {
+    const content = readFile(f);
+    if (content !== null) snap[f] = content;
+  }
+  return snap;
+}
+
+function snapshotDir(dir, exts) {
+  return snapshotFiles(dir, exts);
+}
+
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') {
+    console.log(HELP);
+    return;
+  }
+
+  const target  = args[0];
+  const noFix   = args.includes('--no-fix');
+  const strict  = args.includes('--strict');
+  const fix     = !noFix;
+
+  if (!fs.existsSync(target)) {
+    return output(fail(`Not found: ${target}`));
+  }
+
+  const ext    = path.extname(target).toLowerCase();
+  const isDir  = fs.statSync(target).isDirectory();
+
+  // Single file — route directly by extension
+  if (!isDir) {
+    if (ext === '.cs')                              return lintCSharp(target, fix, DEFAULT_TIMEOUT);
+    if (ext === '.py')                              return lintPython(target, fix, strict, DEFAULT_TIMEOUT);
+    if (ext === '.rs')                              return lintRust(target, fix, strict, DEFAULT_TIMEOUT);
+    if (['.js','.ts','.jsx','.tsx','.mjs'].includes(ext)) return lintJs(target, fix, strict, DEFAULT_TIMEOUT);
+    if (['.c','.cpp','.cc'].includes(ext))          return lintC(target, fix, DEFAULT_TIMEOUT);
+    if (ext === '.go')                              return lintGo(target, fix, DEFAULT_TIMEOUT);
+    return output(fail(`Cannot detect linter for: ${target}. Supported: .py .rs .js .ts .c .cpp .go .cs`));
+  }
+
+  // Directory — detect ALL languages present and run each linter
+  const hasCsproj  = fs.readdirSync(target).some(f => f.endsWith('.csproj') || f.endsWith('.sln'));
+  const hasCargo   = fs.existsSync(path.join(target, 'Cargo.toml'));
+  const hasPkgJson = fs.existsSync(path.join(target, 'package.json'));
+  const hasGoMod   = fs.existsSync(path.join(target, 'go.mod'));
+
+  const hasPy  = findFiles(target, ['.py']).length > 0;
+  const hasJs  = findFiles(target, ['.js', '.ts', '.jsx', '.tsx', '.mjs']).length > 0;
+  const hasC   = findFiles(target, ['.c', '.cpp', '.cc']).length > 0;
+  const hasCs  = findFiles(target, ['.cs']).length > 0;
+  const hasGo  = findFiles(target, ['.go']).length > 0;
+
+  const langs = [];
+  if (hasCsproj || hasCs)         langs.push('csharp');
+  if (hasCargo)                   langs.push('rust');
+  if (hasPkgJson || hasJs)        langs.push('javascript');
+  if (hasGoMod || hasGo)          langs.push('go');
+  if (hasPy)                      langs.push('python');
+  if (hasC && !hasCargo)          langs.push('c');
+
+  if (langs.length === 0) {
+    return output(fail(`No supported source files found in: ${target}. Supported: .py .rs .js .ts .c .cpp .go .cs`));
+  }
+
+  // Single language — run directly (returns output itself)
+  if (langs.length === 1) {
+    const lang = langs[0];
+    if (lang === 'csharp')     return lintCSharp(target, fix, DEFAULT_TIMEOUT);
+    if (lang === 'rust')       return lintRust(target, fix, strict, DEFAULT_TIMEOUT);
+    if (lang === 'javascript') return lintJs(target, fix, strict, DEFAULT_TIMEOUT);
+    if (lang === 'go')         return lintGo(target, fix, DEFAULT_TIMEOUT);
+    if (lang === 'python')     return lintPython(target, fix, strict, DEFAULT_TIMEOUT);
+    if (lang === 'c')          return lintC(target, fix, DEFAULT_TIMEOUT);
+  }
+
+  // Multiple languages — capture output from each linter and combine
+  const results = [];
+  let totalIssues = 0;
+
+  for (const lang of langs) {
+    // Temporarily capture console.log to get the JSON result
+    const lines = [];
+    const origLog = console.log;
+    console.log = (s) => lines.push(s);
+
+    try {
+      if (lang === 'csharp')     await lintCSharp(target, fix, DEFAULT_TIMEOUT);
+      else if (lang === 'rust')       await lintRust(target, fix, strict, DEFAULT_TIMEOUT);
+      else if (lang === 'javascript') await lintJs(target, fix, strict, DEFAULT_TIMEOUT);
+      else if (lang === 'go')         await lintGo(target, fix, DEFAULT_TIMEOUT);
+      else if (lang === 'python')     await lintPython(target, fix, strict, DEFAULT_TIMEOUT);
+      else if (lang === 'c') {
+        // C linter works per-file — collect all .c/.cpp files
+        const cFiles = findFiles(target, ['.c', '.cpp', '.cc']);
+        for (const cFile of cFiles.slice(0, 20)) {
+          await lintC(cFile, fix, DEFAULT_TIMEOUT);
+        }
+      }
+    } catch {}
+
+    console.log = origLog;
+
+    // Parse last JSON line from captured output
+    let result = null;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try { result = JSON.parse(lines[i]); break; } catch {}
+    }
+
+    if (result?.data) {
+      const d = result.data;
+      const issues = d.issues_count ?? d.issue_count ?? d.remaining_issues?.length ?? d.vet_issues?.length ?? 0;
+      totalIssues += issues;
+      results.push({
+        lang,
+        tool:         d.tool ?? d.tools ?? null,
+        issues_count: issues,
+        fixed_count:  d.fixed_count ?? null,
+        build_clean:  d.build_clean ?? null,
+        diff_count:   d.diff?.length ?? 0,
+      });
+    } else {
+      results.push({ lang, error: result?.error ?? 'no output' });
+    }
+  }
+
+  output(ok({
+    target,
+    langs_detected: langs,
+    total_issues:   totalIssues,
+    fix_applied:    fix,
+    results,
+    verdict: totalIssues === 0 ? 'clean' : 'issues_found',
+  }));
+}
+
+module.exports = { run };