@vhite/vhite 0.0.0-stage → 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 };
+}