@vhite/vhite 0.1.0 → 0.6.0

package/src/output/sarif.js

@@ -0,0 +1,60 @@
+import { relative, sep } from "node:path";
+import { rules } from "../../rules/index.js";
+
+const LEVELS = { error: "error", warning: "warning", info: "note" };
+
+function toPosix(path) {
+  return path.split(sep).join("/");
+}
+
+export function formatSarif({ root, issues, version }) {
+  const descriptions = new Map(rules.map((rule) => [rule.name, rule.description]));
+  const ruleIds = [...new Set(issues.map((issue) => issue.rule))].sort();
+
+  const results = issues.map((issue) => {
+    const column = issue.column ?? 1;
+    return {
+      ruleId: issue.rule,
+      level: LEVELS[issue.severity] ?? "warning",
+      message: { text: issue.message },
+      locations: [
+        {
+          physicalLocation: {
+            artifactLocation: { uri: toPosix(relative(root, issue.file)) },
+            region: {
+              startLine: issue.line,
+              startColumn: column,
+              endLine: issue.endLine ?? issue.line,
+              endColumn: issue.endColumn ?? column,
+            },
+          },
+        },
+      ],
+    };
+  });
+
+  return JSON.stringify(
+    {
+      $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+      version: "2.1.0",
+      runs: [
+        {
+          tool: {
+            driver: {
+              name: "vhite",
+              version,
+              informationUri: "https://github.com/Wilson-Edem/vhite",
+              rules: ruleIds.map((id) => ({
+                id,
+                shortDescription: { text: descriptions.get(id) ?? id },
+              })),
+            },
+          },
+          results,
+        },
+      ],
+    },
+    null,
+    2
+  );
+}

package/src/scan/baseline.js

@@ -0,0 +1,60 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+
+export const BASELINE_NAME = "vhite.baseline.json";
+
+function toPosix(path) {
+  return path.split(sep).join("/");
+}
+
+export function fingerprintOf(issue, root) {
+  const text = (issue.snippet ?? issue.message).trim();
+  return `${issue.rule}|${toPosix(relative(root, issue.file))}|${text}`;
+}
+
+export function buildBaseline(issues, root) {
+  const fingerprints = {};
+  for (const issue of issues) {
+    const key = fingerprintOf(issue, root);
+    fingerprints[key] = (fingerprints[key] ?? 0) + 1;
+  }
+  return { version: 1, fingerprints };
+}
+
+export async function saveBaseline(root, baseline) {
+  const path = join(root, BASELINE_NAME);
+  await writeFile(path, JSON.stringify(baseline, null, 2) + "\n", "utf8");
+  return path;
+}
+
+export async function loadBaseline(root) {
+  try {
+    const text = await readFile(join(root, BASELINE_NAME), "utf8");
+    const data = JSON.parse(text);
+    if (typeof data.fingerprints !== "object" || data.fingerprints === null) {
+      throw new Error(`${BASELINE_NAME} has no fingerprints`);
+    }
+    return data;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+export function applyBaseline(issues, baseline, root) {
+  const remaining = { ...baseline.fingerprints };
+  const fresh = [];
+  let hidden = 0;
+
+  for (const issue of issues) {
+    const key = fingerprintOf(issue, root);
+    if ((remaining[key] ?? 0) > 0) {
+      remaining[key] -= 1;
+      hidden += 1;
+    } else {
+      fresh.push(issue);
+    }
+  }
+
+  return { issues: fresh, hidden };
+}

package/src/scan/git.js

@@ -0,0 +1,28 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { resolve } from "node:path";
+
+const run = promisify(execFile);
+
+async function git(root, args) {
+  try {
+    const { stdout } = await run("git", args, { cwd: root });
+    return stdout.split(/\r?\n/).filter((line) => line.trim() !== "");
+  } catch (error) {
+    throw new Error(
+      "This option needs a Git repository with at least one commit, and Git must be installed"
+    );
+  }
+}
+
+export async function changedFiles(root, mode) {
+  let names;
+  if (mode === "staged") {
+    names = await git(root, ["diff", "--name-only", "--relative", "--cached"]);
+  } else {
+    const tracked = await git(root, ["diff", "--name-only", "--relative", "HEAD"]);
+    const untracked = await git(root, ["ls-files", "--others", "--exclude-standard"]);
+    names = [...tracked, ...untracked];
+  }
+  return new Set(names.map((name) => resolve(root, name)));
+}

package/src/scan/ignore.js

@@ -0,0 +1,68 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { normalizePath } from "../core/args.js";
+
+const DEFAULT_IGNORES = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  "vendor",
+  ".vhite-fix",
+];
+
+function globToRegex(glob) {
+  let source = "";
+  for (let index = 0; index < glob.length; index += 1) {
+    const char = glob[index];
+    if (char === "*" && glob[index + 1] === "*") {
+      source += ".*";
+      index += 1;
+    } else if (char === "*") {
+      source += "[^/]*";
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+function prefixesOf(path) {
+  const parts = path.split("/");
+  return parts.map((_, index) => parts.slice(0, index + 1).join("/"));
+}
+
+function matchesPattern(relativePath, pattern) {
+  const anchored = pattern.includes("/");
+  const clean = pattern.replace(/^\//, "").replace(/\/$/, "");
+  const regex = globToRegex(clean);
+
+  if (anchored) {
+    return prefixesOf(relativePath).some((prefix) => regex.test(prefix));
+  }
+  return relativePath.split("/").some((segment) => regex.test(segment));
+}
+
+export async function loadIgnorePatterns(root) {
+  const patterns = [...DEFAULT_IGNORES];
+  try {
+    const text = await readFile(join(root, ".gitignore"), "utf8");
+    for (const raw of text.split(/\r?\n/)) {
+      const line = raw.trim();
+      if (line === "" || line.startsWith("#") || line.startsWith("!")) continue;
+      patterns.push(line);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return patterns;
+}
+
+export function isIgnored(relativePath, patterns) {
+  const rel = normalizePath(relativePath);
+  return patterns.some((pattern) => matchesPattern(rel, pattern));
+}

package/src/scan/suppress.js

@@ -0,0 +1,53 @@
+import { readFile } from "node:fs/promises";
+
+const DIRECTIVE = /vhite-disable-(next-line|line)(?:\s+([A-Za-z0-9_,\- ]+))?/;
+
+function parseRules(text) {
+  if (!text || text.trim() === "") return null;
+  return new Set(
+    text
+      .split(/[, ]+/)
+      .map((name) => name.trim())
+      .filter((name) => name !== "")
+  );
+}
+
+function directivesFor(source) {
+  const lines = source.split(/\r?\n/);
+  const map = new Map();
+
+  lines.forEach((text, index) => {
+    const match = DIRECTIVE.exec(text);
+    if (!match) return;
+
+    const target = match[1] === "next-line" ? index + 2 : index + 1;
+    map.set(target, parseRules(match[2]));
+  });
+
+  return map;
+}
+
+export async function applySuppressions(issues, root) {
+  const cache = new Map();
+  const kept = [];
+  let suppressed = 0;
+
+  for (const issue of issues) {
+    if (!cache.has(issue.file)) {
+      const source = await readFile(issue.file, "utf8");
+      cache.set(issue.file, directivesFor(source));
+    }
+
+    const directives = cache.get(issue.file);
+    const entry = directives.get(issue.line);
+    const hides = entry !== undefined && (entry === null || entry.has(issue.rule));
+
+    if (hides) {
+      suppressed += 1;
+    } else {
+      kept.push(issue);
+    }
+  }
+
+  return { issues: kept, suppressed };
+}

package/src/config.js

@@ -1,42 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { rules } from "../rules/index.js";
-
-const CONFIG_NAME = "vhite.config.json";
-const knownRules = new Set(rules.map((rule) => rule.name));
-
-export async function loadConfig(root) {
-  let text;
-  try {
-    text = await readFile(join(root, CONFIG_NAME), "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return { disabledRules: new Set(), warnings: [] };
-    throw error;
-  }
-
-  let data;
-  try {
-    data = JSON.parse(text);
-  } catch (error) {
-    throw new Error(`${CONFIG_NAME} is not valid JSON: ${error.message}`);
-  }
-
-  if (typeof data !== "object" || data === null || Array.isArray(data)) {
-    throw new Error(`${CONFIG_NAME} must contain a JSON object`);
-  }
-
-  const requested = Array.isArray(data.disabledRules) ? data.disabledRules : [];
-  const disabledRules = new Set();
-  const warnings = [];
-
-  for (const name of requested) {
-    if (knownRules.has(name)) {
-      disabledRules.add(name);
-    } else {
-      warnings.push(`"${name}" is not a rule name, so it was ignored`);
-    }
-  }
-
-  return { disabledRules, warnings };
-}
-

package/src/engine.js

@@ -1,80 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { extname } from "node:path";
-import { parse } from "espree";
-import { rules } from "../rules/index.js";
-
-function parseSource(source, file) {
-  const extension = extname(file).toLowerCase();
-
-  return parse(source, {
-    ecmaVersion: "latest",
-    sourceType: extension === ".cjs" ? "commonjs" : "module",
-    ecmaFeatures: {
-      jsx: true,
-    },
-    loc: true,
-    range: true,
-    comment: true,
-    tokens: true,
-    allowHashBang: true,
-  });
-}
-
-export async function runRules(files, { disabledRules = new Set() } = {}) {
-  const issues = [];
-  const activeRules = rules.filter((rule) => !disabledRules.has(rule.name));
-
-  for (const file of files) {
-    const source = await readFile(file, "utf8");
-    const extension = extname(file).toLowerCase();
-
-    const applicableRules = activeRules.filter((rule) =>
-      rule.extensions?.includes(extension)
-    );
-
-    if (applicableRules.length === 0) {
-      continue;
-    }
-
-    const needsAst = applicableRules.some(
-      (rule) => rule.requiresAst === true
-    );
-
-    let ast;
-
-    if (needsAst) {
-      try {
-        ast = parseSource(source, file);
-      } catch (error) {
-        issues.push({
-          rule: "parser",
-          file,
-          line: error.lineNumber ?? 1,
-          message: `Unable to parse file: ${error.message}`,
-        });
-      }
-    }
-
-    for (const rule of applicableRules) {
-      if (rule.requiresAst === true && !ast) {
-        continue;
-      }
-
-      const found = rule.check({
-        file,
-        source,
-        ...(rule.requiresAst === true ? { ast } : {}),
-      });
-
-      for (const issue of found) {
-        issues.push({
-          rule: rule.name,
-          file,
-          ...issue,
-        });
-      }
-    }
-  }
-
-  return issues;
-}