fchek 1.0.0

package/lib/bench.js

@@ -0,0 +1,248 @@
+'use strict';
+
+/**
+ * bench.js — benchmark diff before/after refactoring
+ *
+ * Runs the same target twice (before and after a change) and compares:
+ *   - wall time
+ *   - memory (RSS)
+ *   - custom metric if the program outputs a number
+ *
+ * Modes:
+ *   --before=<file|cmd>  Run this as "before" version
+ *   --after=<file|cmd>   Run this as "after" version
+ *   --runs=N             How many times to run each (default: 5) for stable average
+ *   --timeout=ms         Per-run timeout (default: 30000)
+ *
+ * Language auto-detection for plain file args:
+ *   .py  → python <file>
+ *   .rs  → cargo run (in project root)
+ *   .js  → node <file>
+ *   .cpp → compile then run
+ */
+
+const { spawnSync } = require('child_process');
+const path   = require('path');
+const fs     = require('fs');
+const os     = require('os');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek bench <file> --before=<ver_a> --after=<ver_b> [--runs=5] [--timeout=30000]
+
+Benchmark two versions of the same code and show the diff.
+Eliminates "I think it got faster" guesswork.
+
+Arguments:
+  <file>           The entry point to benchmark
+  --before=<path>  "Before" version (file path or shell command)
+  --after=<path>   "After" version  (file path or shell command)
+  --runs=N         Number of runs per version for stable average (default: 5)
+  --timeout=ms     Per-run timeout in ms (default: 30000)
+
+Output includes:
+  - avg/min/max wall time per version
+  - memory RSS
+  - speedup ratio (after vs before)
+  - raw diff of stdout between versions
+
+Examples:
+  fchek bench main.py --before=main_old.py --after=main.py
+  fchek bench . --before="cargo run --release -- old" --after="cargo run --release"
+  fchek bench app.js --before=app_v1.js --after=app_v2.js --runs=10
+`.trim();
+
+const DEFAULT_RUNS    = 5;
+const DEFAULT_TIMEOUT = 30_000;
+
+function detectRunner(file) {
+  const ext = path.extname(file).toLowerCase();
+  if (ext === '.py') {
+    const py = require('./python').findPython();
+    if (!py) return null;
+    return [py, [file]];
+  }
+  if (ext === '.js')  return ['node', [file]];
+  if (ext === '.ts')  return ['ts-node', [file]];
+  if (['.cpp', '.cc', '.c'].includes(ext)) return null; // needs compile step
+  return null;
+}
+
+function compileC(file) {
+  const ext      = path.extname(file).toLowerCase();
+  const compiler = ext === '.cpp' || ext === '.cc' ? 'g++' : 'gcc';
+  const outBin   = path.join(os.tmpdir(), `fchek_bench_${path.basename(file, ext)}_${Date.now()}`);
+  const res = spawnSync(compiler, ['-O2', '-o', outBin, file], { encoding: 'utf8' });
+  if (res.status !== 0) return { error: res.stderr };
+  return { bin: outBin };
+}
+
+function runOnce(cmd, args, timeoutMs) {
+  const t0 = process.hrtime.bigint();
+  const res = spawnSync(cmd, args, {
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    maxBuffer: 1024 * 1024,
+  });
+  const t1 = process.hrtime.bigint();
+  const wallMs = Number(t1 - t0) / 1e6;
+
+  if (res.error?.code === 'ETIMEDOUT') {
+    return { error: `timed_out after ${timeoutMs}ms` };
+  }
+  if (res.error) {
+    return { error: res.error.message };
+  }
+
+  return {
+    wall_ms:     Math.round(wallMs),
+    exit_code:   res.status,
+    stdout:      (res.stdout || '').slice(0, 2000),
+    stderr:      (res.stderr || '').slice(0, 500),
+    // RSS from /proc/self/status is not available cross-platform via spawnSync
+    // We record approximate Node host memory instead as a proxy
+  };
+}
+
+function runN(cmd, args, n, timeoutMs) {
+  const results = [];
+  for (let i = 0; i < n; i++) {
+    const r = runOnce(cmd, args, timeoutMs);
+    if (r.error) return { error: r.error };
+    results.push(r);
+  }
+
+  const times = results.map(r => r.wall_ms);
+  const avg   = Math.round(times.reduce((a, b) => a + b, 0) / times.length);
+  const min   = Math.min(...times);
+  const max   = Math.max(...times);
+
+  // Measurement note:
+  // wall_ms includes Node.js process fork overhead (~5-50ms per spawn).
+  // min_ms is the PRIMARY metric — least affected by OS scheduling noise.
+  // For programs < 100ms, overhead may dominate. Use --runs=20+ for stability.
+  const overhead_warning = min < 100
+    ? `min_ms=${min}ms is under 100ms. Fork overhead (~5-50ms) may be significant. Use --runs=${Math.max(n, 20)} for better accuracy.`
+    : null;
+
+  return {
+    runs:       n,
+    min_ms:     min,   // PRIMARY — use this for comparison
+    avg_ms:     avg,
+    max_ms:     max,
+    jitter_ms:  max - min,
+    overhead_warning,
+    stdout_sample: results[0].stdout,
+    exit_codes: results.map(r => r.exit_code),
+  };
+}
+
+function buildDiff(before, after) {
+  if (!before || !after) return null;
+  const bLines = before.split('\n');
+  const aLines = after.split('\n');
+  const diff   = [];
+
+  const maxLen = Math.max(bLines.length, aLines.length);
+  for (let i = 0; i < maxLen; i++) {
+    const b = bLines[i] ?? null;
+    const a = aLines[i] ?? null;
+    if (b !== a) {
+      diff.push({ line: i + 1, before: b, after: a });
+    }
+  }
+  return diff.slice(0, 30); // cap at 30 diff lines
+}
+
+function resolveTarget(spec, defaultExt) {
+  // If it looks like a shell command (spaces), split it
+  if (spec.includes(' ')) {
+    const parts = spec.split(/\s+/);
+    return { cmd: parts[0], args: parts.slice(1), tmpBin: null };
+  }
+
+  if (!fs.existsSync(spec)) {
+    return { error: `File not found: ${spec}` };
+  }
+
+  const ext = path.extname(spec).toLowerCase();
+  if (['.c', '.cpp', '.cc'].includes(ext)) {
+    const compiled = compileC(spec);
+    if (compiled.error) return { error: `Compile failed: ${compiled.error}` };
+    return { cmd: compiled.bin, args: [], tmpBin: compiled.bin };
+  }
+
+  const runner = detectRunner(spec);
+  if (!runner) {
+    return { error: `Cannot auto-detect runner for: ${spec}. Use --before="<cmd> ${spec}"` };
+  }
+
+  return { cmd: runner[0], args: runner[1], tmpBin: null };
+}
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') {
+    console.log(HELP);
+    return;
+  }
+
+  const beforeArg  = args.find(a => a.startsWith('--before='))?.replace('--before=', '');
+  const afterArg   = args.find(a => a.startsWith('--after='))?.replace('--after=', '');
+  const runsArg    = parseInt((args.find(a => a.startsWith('--runs=')) ?? `--runs=${DEFAULT_RUNS}`).replace('--runs=', ''), 10);
+  const timeoutArg = parseInt((args.find(a => a.startsWith('--timeout=')) ?? `--timeout=${DEFAULT_TIMEOUT}`).replace('--timeout=', ''), 10);
+
+  if (!beforeArg || !afterArg) {
+    return output(fail('Both --before=<path> and --after=<path> are required'));
+  }
+
+  const beforeTarget = resolveTarget(beforeArg);
+  const afterTarget  = resolveTarget(afterArg);
+
+  if (beforeTarget.error) return output(fail(beforeTarget.error));
+  if (afterTarget.error)  return output(fail(afterTarget.error));
+
+  const beforeResult = runN(beforeTarget.cmd, beforeTarget.args, runsArg, timeoutArg);
+  const afterResult  = runN(afterTarget.cmd,  afterTarget.args,  runsArg, timeoutArg);
+
+  // Cleanup temp binaries
+  if (beforeTarget.tmpBin) try { fs.unlinkSync(beforeTarget.tmpBin); } catch {}
+  if (afterTarget.tmpBin)  try { fs.unlinkSync(afterTarget.tmpBin);  } catch {}
+
+  if (beforeResult.error) return output(fail(`Before run failed: ${beforeResult.error}`));
+  if (afterResult.error)  return output(fail(`After run failed: ${afterResult.error}`));
+
+  // Use min_ms as primary comparison metric — most stable, least OS noise
+  const speedup     = beforeResult.min_ms / afterResult.min_ms;
+  const timeDeltaMs = afterResult.min_ms - beforeResult.min_ms;
+  const verdict     = speedup >= 1.05
+    ? 'faster'
+    : speedup <= 0.95
+    ? 'slower'
+    : 'no_significant_change';
+
+  const stdoutDiff = buildDiff(beforeResult.stdout_sample, afterResult.stdout_sample);
+
+  output(ok({
+    before: {
+      spec:   beforeArg,
+      ...beforeResult,
+    },
+    after: {
+      spec:  afterArg,
+      ...afterResult,
+    },
+    comparison: {
+      time_delta_ms: timeDeltaMs,
+      speedup_ratio: parseFloat(speedup.toFixed(3)),
+      verdict,             // "faster" | "slower" | "no_significant_change"
+      pct_change: parseFloat(((speedup - 1) * 100).toFixed(1)),
+    },
+    stdout_diff: stdoutDiff,
+    config: {
+      runs:       runsArg,
+      timeout_ms: timeoutArg,
+    },
+  }));
+}
+
+module.exports = { run };

package/lib/config.js

@@ -0,0 +1,191 @@
+'use strict';
+
+/**
+ * config.js — read and validate .fchekrc project config
+ *
+ * .fchekrc is a JSON file in project root that configures fchek behavior.
+ * Agent reads this first to understand project-specific rules and thresholds.
+ */
+
+const path = require('path');
+const fs   = require('fs');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek config [action] [key] [value]
+
+Read and manage .fchekrc project configuration.
+
+Actions:
+  show              Show current config (merged: defaults + .fchekrc)
+  init              Create a .fchekrc with defaults for this project
+  get <key>         Get a specific config value
+  set <key> <val>   Set a config value in .fchekrc
+
+Example .fchekrc:
+{
+  "lang": "python",
+  "test_command": "pytest -x",
+  "lint_threshold": 0,
+  "coverage_threshold": 80,
+  "secrets_scan_on_run": true,
+  "ignore_paths": ["migrations/", "*.generated.py"],
+  "auto_fix_lint": true
+}
+`.trim();
+
+const DEFAULTS = {
+  lang:                 null,   // auto-detect if null
+  test_command:         null,   // auto-detect if null
+  lint_threshold:       0,      // 0 = any issue is a failure
+  coverage_threshold:   70,     // minimum coverage %
+  secrets_scan_on_run:  true,   // run secrets check with every fchek run
+  auto_fix_lint:        false,  // auto-apply lint fixes
+  ignore_paths:         [],     // paths to skip in all scans
+  timeout_ms:           60000,  // default timeout for commands
+  git_auto_stage:       false,  // auto-stage on commit
+};
+
+function findProjectRoot(startDir) {
+  const markers = ['package.json', 'Cargo.toml', '.git', 'pyproject.toml', 'go.mod', '.csproj'];
+  let dir = path.resolve(startDir);
+  for (let i = 0; i < 8; i++) {
+    if (markers.some(m => {
+      if (m === '.csproj') {
+        try { return fs.readdirSync(dir).some(f => f.endsWith('.csproj')); } catch { return false; }
+      }
+      return fs.existsSync(path.join(dir, m));
+    })) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.resolve(startDir);
+}
+
+function loadRc(dir) {
+  const rcPath = path.join(dir, '.fchekrc');
+  if (!fs.existsSync(rcPath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(rcPath, 'utf8'));
+  } catch (e) {
+    throw new Error(`.fchekrc parse error: ${e.message}`);
+  }
+}
+
+function mergedConfig(dir) {
+  const userRc = loadRc(dir);
+  return { ...DEFAULTS, ...userRc, _source: path.join(dir, '.fchekrc') };
+}
+
+function detectLangForInit(dir) {
+  // Check current dir first, then walk up
+  const check = (d) => {
+    if (fs.existsSync(path.join(d, 'Cargo.toml')))       return 'rust';
+    if (fs.existsSync(path.join(d, 'go.mod')))            return 'go';
+    if (fs.existsSync(path.join(d, 'pyproject.toml'))
+     || fs.existsSync(path.join(d, 'requirements.txt'))
+     || fs.existsSync(path.join(d, 'setup.py'))
+     || fs.existsSync(path.join(d, 'conftest.py')))       return 'python';
+    if (fs.existsSync(path.join(d, 'package.json')))      return 'javascript';
+    try {
+      if (fs.readdirSync(d).some(f => f.endsWith('.csproj') || f.endsWith('.sln'))) return 'csharp';
+    } catch {}
+    // Check if majority of source files are .py
+    try {
+      const files = fs.readdirSync(d);
+      const pyFiles = files.filter(f => f.endsWith('.py')).length;
+      const jsFiles = files.filter(f => f.endsWith('.js') || f.endsWith('.ts')).length;
+      if (pyFiles > 0 && pyFiles >= jsFiles) return 'python';
+    } catch {}
+    return null;
+  };
+  return check(dir);
+}
+
+async function run(args) {
+  if (args[0] === '--help') { console.log(HELP); return; }
+
+  const root   = findProjectRoot(process.cwd());
+  const action = args[0] || 'show';
+
+  switch (action) {
+    case 'show': {
+      let config;
+      try { config = mergedConfig(root); }
+      catch (e) { return output(fail(e.message)); }
+      output(ok({ action: 'show', root, config }));
+      break;
+    }
+
+    case 'init': {
+      const rcPath = path.join(root, '.fchekrc');
+      if (fs.existsSync(rcPath)) {
+        return output(fail(`.fchekrc already exists at ${rcPath}. Use "fchek config show" to view it.`));
+      }
+      const lang = detectLangForInit(root);
+      const initConfig = {
+        lang,
+        test_command:         null,
+        lint_threshold:       0,
+        coverage_threshold:   70,
+        secrets_scan_on_run:  true,
+        auto_fix_lint:        false,
+        ignore_paths:         [],
+        timeout_ms:           60000,
+      };
+      fs.writeFileSync(rcPath, JSON.stringify(initConfig, null, 2), 'utf8');
+
+      // Add to .gitignore? No — .fchekrc should be committed (it's project config, not secrets)
+      output(ok({ action: 'init', file: rcPath, config: initConfig }));
+      break;
+    }
+
+    case 'get': {
+      const key = args[1];
+      if (!key) return output(fail('Usage: fchek config get <key>'));
+      let config;
+      try { config = mergedConfig(root); } catch (e) { return output(fail(e.message)); }
+      if (!(key in config)) return output(fail(`Key not found: "${key}"`));
+      output(ok({ action: 'get', key, value: config[key] }));
+      break;
+    }
+
+    case 'set': {
+      const key   = args[1];
+      const value = args.slice(2).join(' ');
+      if (!key) return output(fail('Usage: fchek config set <key> <value>'));
+
+      const rcPath = path.join(root, '.fchekrc');
+      let rc = {};
+      if (fs.existsSync(rcPath)) {
+        try { rc = JSON.parse(fs.readFileSync(rcPath, 'utf8')); }
+        catch (e) { return output(fail(`.fchekrc parse error: ${e.message}`)); }
+      }
+
+      // Auto-convert types
+      let parsed = value;
+      if (value === 'true')  parsed = true;
+      if (value === 'false') parsed = false;
+      if (/^\d+$/.test(value)) parsed = parseInt(value, 10);
+      if (value.startsWith('[')) try { parsed = JSON.parse(value); } catch {}
+
+      rc[key] = parsed;
+      fs.writeFileSync(rcPath, JSON.stringify(rc, null, 2), 'utf8');
+      output(ok({ action: 'set', key, value: parsed, file: rcPath }));
+      break;
+    }
+
+    default:
+      output(fail(`Unknown action: "${action}". Valid: show, init, get, set`));
+  }
+}
+
+// Export for use by other modules
+function getConfig(dir) {
+  const root = findProjectRoot(dir || process.cwd());
+  try { return mergedConfig(root); }
+  catch { return { ...DEFAULTS }; }
+}
+
+module.exports = { run, getConfig, DEFAULTS };