connections-arkitect 0.3.4

package/src/checks/code/oversized-files.mjs

@@ -0,0 +1,74 @@
+// CORE check — generic. Advisory by default (surfaces debt without blocking a fork whose files are
+// already large). A user can flip it to gating in arkitect.config.json.
+import { readFileSync } from "node:fs";
+import { relative, extname } from "node:path";
+import { createFinding } from "../../core/finding.mjs";
+import { walkFiles } from "../../core/fs-walk.mjs";
+
+const CODE_EXT = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rs",
+  ".go",
+  ".rb",
+  ".java",
+  ".php",
+  ".vue",
+  ".css",
+  ".scss",
+]);
+
+export const audit = {
+  id: "oversized-files",
+  title: "Oversized source files",
+  category: "maintainability",
+  domain: "code",
+  requires: {},
+  gating: false,
+  defaultConfig: { warnLines: 800, errorLines: 2500 },
+  async run(ctx) {
+    const { root, checkConfig } = ctx;
+    const findings = [];
+    for (const file of walkFiles(root)) {
+      if (!CODE_EXT.has(extname(file))) continue;
+      let lines;
+      try {
+        lines = readFileSync(file, "utf8").split("\n").length;
+      } catch {
+        continue;
+      }
+      if (lines >= checkConfig.errorLines)
+        findings.push(
+          createFinding({
+            id: "oversized",
+            title: "File far too large",
+            severity: "error",
+            file: relative(root, file),
+            line: lines,
+            message: `${lines} lines (≥ ${checkConfig.errorLines})`,
+          }),
+        );
+      else if (lines >= checkConfig.warnLines)
+        findings.push(
+          createFinding({
+            id: "oversized",
+            title: "Large file",
+            severity: "warning",
+            file: relative(root, file),
+            line: lines,
+            message: `${lines} lines (≥ ${checkConfig.warnLines})`,
+          }),
+        );
+    }
+    const errors = findings.filter((f) => f.severity === "error").length;
+    const report = findings.length
+      ? `# Oversized files\n\n${findings.map((f) => `- ${f.severity.toUpperCase()} ${f.file} — ${f.message}`).join("\n")}\n\nErrors: ${errors}\nWarnings: ${findings.length - errors}\n`
+      : "";
+    return { failed: errors > 0, findings, report };
+  },
+};

package/src/checks/code/sibling-consensus.mjs

@@ -0,0 +1,69 @@
+// CORE check — the CONFORMANCE ORACLE (consensus mode), distilled to a generic, project-agnostic shape.
+// A denylist enumerates known-bad and is forever one bug behind. An oracle declares what AGREEMENT looks
+// like across a FAMILY of sibling artifacts and flags the odd-one-out — catching divergence nobody named.
+// Default family: every package.json; default fingerprint: the `license` field. Both are configurable.
+// Refactored to delegate consensus logic to runFamilyConformance (keeps identical behavior + output).
+import { readFileSync } from "node:fs";
+import { relative, basename } from "node:path";
+import { createFinding } from "../../core/finding.mjs";
+import { walkFiles } from "../../core/fs-walk.mjs";
+import { runFamilyConformance } from "../../core/oracle/family-conformance.mjs";
+
+function getPath(obj, path) {
+  return path.split(".").reduce((o, k) => (o == null ? undefined : o[k]), obj);
+}
+
+export const audit = {
+  id: "sibling-consensus",
+  title: "Sibling files agree (consensus oracle)",
+  category: "consistency",
+  domain: "code",
+  requires: { ecosystems: ["npm"] },
+  gating: false,
+  defaultConfig: { family: "package.json", field: "license", minFamily: 3 },
+  async run(ctx) {
+    const { root, checkConfig } = ctx;
+
+    // Collect family members.
+    const members = [];
+    for (const file of walkFiles(root)) {
+      if (basename(file) === checkConfig.family) members.push({ path: file });
+    }
+    if (members.length < checkConfig.minFamily) return { failed: false, findings: [], report: "" };
+
+    // project() extracts the fingerprint for a member (the configured field from the JSON file).
+    const project = (member) => {
+      try {
+        return getPath(JSON.parse(readFileSync(member.path, "utf8")), checkConfig.field) ?? null;
+      } catch {
+        return null;
+      }
+    };
+
+    const { findings: divergences, consensusOrReference } = await runFamilyConformance({ family: members, project, mode: "consensus" });
+
+    if (divergences === null || consensusOrReference === null) {
+      // No clear majority — nothing to flag.
+      return { failed: false, findings: [], report: "" };
+    }
+
+    const majorityKey = JSON.stringify(consensusOrReference);
+    const majorityCount = members.length - divergences.length;
+
+    const findings = divergences.map((d) =>
+      createFinding({
+        id: "consensus-divergence",
+        title: `Diverges from sibling consensus on '${checkConfig.field}'`,
+        severity: "warning",
+        file: relative(root, d.member.path),
+        message: `'${checkConfig.field}' = ${JSON.stringify(d.actual)}; ${majorityCount}/${members.length} siblings agree on ${majorityKey}`,
+        fix: `Set '${checkConfig.field}' to ${majorityKey} to match its siblings (or justify the difference).`,
+      }),
+    );
+
+    const report = findings.length
+      ? `# Sibling consensus — ${checkConfig.family} · ${checkConfig.field}\n\nMajority (${majorityCount}/${members.length}): ${majorityKey}\n\n${findings.map((f) => `- WARN ${f.file} — ${f.message}`).join("\n")}\n\nErrors: 0\nWarnings: ${findings.length}\n`
+      : "";
+    return { failed: false, findings, report };
+  },
+};

package/src/checks/code/tsconfig-conformance.mjs

@@ -0,0 +1,98 @@
+// CORE check — conformance oracle in REFERENCE mode applied to tsconfig.json compilerOptions.
+// Walks all tsconfig.json files; the reference (default: root tsconfig.json) defines the expected values
+// for any compilerOption key it declares. Any tsconfig whose values for those shared keys differ from the
+// reference is flagged. Uses runFamilyConformance in reference mode — catches drift nobody has named.
+import { readFileSync } from "node:fs";
+import { relative, join, basename } from "node:path";
+import { createFinding } from "../../core/finding.mjs";
+import { walkFiles } from "../../core/fs-walk.mjs";
+import { runFamilyConformance } from "../../core/oracle/family-conformance.mjs";
+
+/**
+ * Parse a tsconfig.json — returns { compilerOptions: {...} } or null on failure.
+ */
+function parseTsconfig(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export const audit = {
+  id: "tsconfig-conformance",
+  title: "tsconfig.json files conform to reference compilerOptions",
+  category: "conformance",
+  domain: "code",
+  requires: { ecosystems: ["npm"] },
+  gating: false,
+  defaultConfig: { referenceFile: "tsconfig.json" }, // relative to root
+  async run(ctx) {
+    const { root, checkConfig } = ctx;
+    const refPath = join(root, checkConfig.referenceFile);
+
+    // Parse the reference to extract its compilerOptions keys — these are the axes we judge.
+    const refParsed = parseTsconfig(refPath);
+    const refCompilerOptions = refParsed?.compilerOptions || {};
+    const refKeys = Object.keys(refCompilerOptions);
+    if (refKeys.length === 0) {
+      // No compilerOptions in reference — nothing to judge.
+      return { failed: false, findings: [], report: "" };
+    }
+
+    // Collect all tsconfig.json files (including the reference — the oracle skips it).
+    const members = [];
+    for (const file of walkFiles(root)) {
+      if (basename(file) === "tsconfig.json") members.push({ path: file });
+    }
+    if (members.length === 0) return { failed: false, findings: [], report: "" };
+
+    // Fingerprint = the subset of compilerOptions present in the REFERENCE — so we only compare apples to apples.
+    const project = (member) => {
+      const parsed = parseTsconfig(member.path);
+      const co = parsed?.compilerOptions || {};
+      // Build a sub-object with ONLY the keys from the reference's compilerOptions.
+      const subset = {};
+      for (const k of refKeys) {
+        if (Object.prototype.hasOwnProperty.call(co, k)) {
+          subset[k] = co[k];
+        }
+      }
+      return subset;
+    };
+
+    // Reference fingerprint is the subset of its OWN compilerOptions keys.
+    const { findings: divergences } = await runFamilyConformance({ family: members, project, mode: "reference", referenceId: refPath });
+
+    if (!divergences || divergences.length === 0) {
+      return { failed: false, findings: [], report: "" };
+    }
+
+    const findings = [];
+    for (const d of divergences) {
+      const relPath = relative(root, d.member.path);
+      // Enumerate only the keys that actually differ.
+      const expected = d.expected || {};
+      const actual = d.actual || {};
+      const allKeys = new Set([...Object.keys(expected), ...Object.keys(actual)]);
+      const diffKeys = [...allKeys].filter((k) => JSON.stringify(expected[k]) !== JSON.stringify(actual[k]));
+      for (const k of diffKeys) {
+        findings.push(
+          createFinding({
+            id: "tsconfig-drift",
+            title: `tsconfig compilerOption '${k}' diverges from reference`,
+            severity: "warning",
+            file: relPath,
+            message: `compilerOptions.${k}: expected ${JSON.stringify(expected[k])}, got ${JSON.stringify(actual[k])} (reference: ${checkConfig.referenceFile})`,
+            fix: `Set compilerOptions.${k} to ${JSON.stringify(expected[k])} to match ${checkConfig.referenceFile}, or remove it from the reference if it should not be enforced globally.`,
+          }),
+        );
+      }
+    }
+
+    const report = findings.length
+      ? `# tsconfig conformance\n\nReference: ${checkConfig.referenceFile}\n\n${findings.map((f) => `- WARN ${f.file} — ${f.message}`).join("\n")}\n\nErrors: 0\nWarnings: ${findings.length}\n`
+      : "";
+    return { failed: false, findings, report };
+  },
+};