@comity-dev/validate 0.1.2 → 0.2.0

package/dist/run.js

@@ -0,0 +1,144 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { discoverRepository } from "./discover.js";
+import { runAdapterPeers } from "./engines/adapter-peers.js";
+import { runDepcruise } from "./engines/depcruise.js";
+import { runEslint } from "./engines/eslint.js";
+import { runSchema } from "./engines/schema.js";
+import { runSemgrep } from "./engines/semgrep.js";
+function categoryOf(result) {
+    return {
+        status: result.status,
+        executed: result.executed,
+        exitCode: result.exitCode,
+        passed: result.passed,
+        findings: result.findings.length,
+        tool: result.tool,
+        reason: result.reason,
+    };
+}
+function emptyCategory(reason) {
+    return {
+        status: "NOT-RUN",
+        executed: false,
+        exitCode: null,
+        passed: false,
+        findings: 0,
+        reason,
+    };
+}
+function findBinDir() {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    // `__dirname` is the directory of the running module. Both the source
+    // `src/` and the built `dist/` are direct children of the package root,
+    // so the package's own `node_modules/.bin` is always exactly one level
+    // up from the running module.
+    return resolve(__dirname, "..", "node_modules", ".bin");
+}
+/**
+ * Run validation against a repository. Returns a normalized result.
+ *
+ * Every category reports either an executed engine with its real exit
+ * code, or an explicit NOT-RUN / TOOL-UNAVAILABLE / CONFIGURATION-ERROR
+ * state. PASS without execution is impossible.
+ */
+export async function runValidation(options) {
+    const only = options.only ?? null;
+    const repo = await discoverRepository({ root: options.root });
+    const binDir = findBinDir();
+    let schemaResult;
+    let metaResult;
+    let configResult;
+    if (!only || only === "metadata" || only === "config" || only === "schema") {
+        schemaResult = runSchema(repo);
+        const metaFindings = schemaResult.findings.filter((f) => f.rule === "package-metadata");
+        const configFindings = schemaResult.findings.filter((f) => f.rule === "comity-config");
+        metaResult = {
+            ...schemaResult,
+            findings: metaFindings,
+            passed: metaFindings.length === 0,
+            status: metaFindings.length === 0 ? "PASS" : "FAIL",
+        };
+        configResult = {
+            ...schemaResult,
+            findings: configFindings,
+            passed: configFindings.length === 0,
+            status: configFindings.length === 0 ? "PASS" : "FAIL",
+        };
+    }
+    else {
+        schemaResult = emptyEngineResult("schema engine skipped");
+        metaResult = emptyEngineResult("schema engine skipped");
+        configResult = emptyEngineResult("schema engine skipped");
+    }
+    let depResult;
+    if (!only || only === "dependencies" || only === "depcruise") {
+        depResult = runDepcruise(repo, binDir);
+    }
+    else {
+        depResult = emptyEngineResult("dependencies engine skipped");
+    }
+    let eslintResult;
+    if (!only || only === "eslint") {
+        eslintResult = runEslint(repo, binDir);
+    }
+    else {
+        eslintResult = emptyEngineResult("eslint engine skipped");
+    }
+    let semgrepResult;
+    if (!only || only === "semgrep") {
+        semgrepResult = await runSemgrep(repo);
+    }
+    else {
+        semgrepResult = emptyEngineResult("semgrep engine skipped");
+    }
+    let adapterResult;
+    if (!only || only === "adapter-peers") {
+        adapterResult = runAdapterPeers(repo);
+    }
+    else {
+        adapterResult = emptyEngineResult("adapter-peers engine skipped");
+    }
+    const violations = [];
+    for (const r of [
+        schemaResult,
+        depResult,
+        eslintResult,
+        semgrepResult,
+        adapterResult,
+    ]) {
+        if (Array.isArray(r.findings)) {
+            violations.push(...r.findings);
+        }
+    }
+    const allExecuted = [depResult, eslintResult, semgrepResult, adapterResult];
+    const allPassed = allExecuted.every((r) => (r.executed ? r.passed : r.status !== "FAIL")) &&
+        (metaResult.executed ? metaResult.passed : metaResult.status !== "FAIL") &&
+        (configResult.executed
+            ? configResult.passed
+            : configResult.status !== "FAIL");
+    return {
+        passed: allPassed,
+        violations,
+        categories: {
+            schema: categoryOf(schemaResult),
+            metadata: categoryOf(metaResult),
+            config: categoryOf(configResult),
+            dependencies: categoryOf(depResult),
+            eslint: categoryOf(eslintResult),
+            semgrep: categoryOf(semgrepResult),
+            adapterPeers: categoryOf(adapterResult),
+        },
+    };
+}
+function emptyEngineResult(reason) {
+    return {
+        executed: false,
+        exitCode: null,
+        passed: false,
+        findings: [],
+        duration: 0,
+        status: "NOT-RUN",
+        reason,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comity-dev/validate",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Thin orchestrator over Comity shared validation tooling. Development tooling.",
   "type": "module",
   "private": false,
@@ -34,10 +34,10 @@
     "@typescript-eslint/parser": "^8.69.0",
     "dependency-cruiser": "^16.10.4",
     "eslint": "^9.39.5",
-    "@comity-dev/schemas": "0.1.1",
-    "@comity-dev/dependency-rules": "0.1.1",
-    "@comity-dev/eslint-plugin": "0.1.2",
-    "@comity-dev/semgrep-rules": "0.1.2"
+    "@comity-dev/schemas": "0.2.0",
+    "@comity-dev/dependency-rules": "0.2.0",
+    "@comity-dev/eslint-plugin": "0.2.0",
+    "@comity-dev/semgrep-rules": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",