@hublo/sentinel 1.1.2 → 1.1.4

package/dist/bin/sentinel.js

@@ -16,7 +16,7 @@ import {
   registerAdapters,
   resolve,
   resolveBin
-} from "../chunk-B337JGTW.js";
+} from "../chunk-HNE774F7.js";
 
 // bin/sentinel.ts
 import { program } from "commander";
@@ -348,7 +348,12 @@ var RULE_BLOCKS = [
   // The format role's equivalent. A rule parked and an option overridden are the same kind of
   // fact: this module deliberately does not do what the standard says, and someone should be
   // able to see every such decision in one place, with the reason beside it.
-  { key: "overrides", label: "formatted differently from the repo standard:" }
+  { key: "overrides", label: "formatted differently from the repo standard:" },
+  // And the one a default can create rather than a module. `sortImports` ships off, so an
+  // adopted module can be missing a check nobody in it ever chose to drop. Reduced coverage
+  // has to be readable, or the difference between an accepted cost and a regression is only
+  // that nobody looked.
+  { key: "unenforced", label: "not checked at all:" }
 ];
 var MAX_INLINE_WIDTH = 60;
 function renderValue(key, value, p) {

package/dist/{chunk-B337JGTW.js → chunk-HNE774F7.js}

@@ -627,25 +627,39 @@ var base_default = {
   singleQuote: true,
   trailingComma: "all",
   sortPackageJson: false,
-  sortImports: {
-    groups: ["builtin", "external", "internal", ["parent", "index"], "sibling"],
-    newlinesBetween: true,
-    order: "asc",
-    ignoreCase: false
-  }
+  sortImports: false
+};
+
+// src/roles/format/presets/nest-imports.json
+var nest_imports_default = {
+  customGroups: [
+    {
+      groupName: "workspace",
+      elementNamePattern: ["@hublo/**", "@shared/**", "@front/**", "@network/**"]
+    }
+  ],
+  groups: ["builtin", "external", "workspace", ["parent", "index"], "sibling"],
+  newlinesBetween: true,
+  order: "asc",
+  ignoreCase: false
 };
 
 // src/roles/format/preset-data.ts
-var FORMAT_PRESETS = ["base", "svelte"];
+var FORMAT_PRESETS = ["base", "svelte", "nest"];
 function hasFormatPreset(name) {
   return FORMAT_PRESETS.includes(name);
 }
 function formatPresetName(declared) {
-  return declared === "svelte" ? "svelte" : "base";
+  if (declared === "svelte") return "svelte";
+  if (declared === "nest") return "nest";
+  return "base";
 }
 function formatPresetFor(preset) {
   const base = base_default;
-  return formatPresetName(preset) === "svelte" ? { ...base, svelte: true } : base;
+  const name = formatPresetName(preset);
+  if (name === "svelte") return { ...base, svelte: true };
+  if (name === "nest") return { ...base, sortImports: nest_imports_default };
+  return base;
 }
 
 // src/roles/format/prettier-config.ts
@@ -775,6 +789,7 @@ var NOT_ADOPTED = (configFile, unreadable = null) => ({
   drift: [],
   local: {},
   presetVersion: null,
+  effective: {},
   unreadable
 });
 function sameValue(a, b) {
@@ -823,11 +838,26 @@ function readFormatAdoption(cwd) {
     drift,
     local,
     presetVersion: typeof provenance.version === "string" ? provenance.version : null,
+    effective: parsed,
     unreadable: null
   };
 }
 
+// src/roles/format/unenforced.ts
+function unenforcedFormatOptions(options) {
+  const gaps = [];
+  const sortImports = options["sortImports"];
+  if (sortImports === void 0 || sortImports === false) {
+    gaps.push({
+      rule: "sortImports",
+      reason: 'import order is not checked here. Enable it with `"sortImports": true` in .oxfmtrc.json, and run `pnpm run format:fix` as its own commit: reordering was 89-96% of the adoption diff on the modules measured'
+    });
+  }
+  return gaps;
+}
+
 // src/roles/format/adapters/oxfmt/oxfmt.adapter.ts
+var FORMATTER_DIFFERENCES = "note: oxfmt is a reimplementation of Prettier, so a few files change even though the settings are identical (it de-indents some multi-line conditions, and drops quotes around enum members). Prettier considered those files correctly formatted; both are valid, the two tools simply disagree. Expect a small tail of such files in the reformat commit.";
 var DEFAULT_PRESET = "base";
 var OXFMT_VALUE_FLAGS = ["-c", "--config", "--ignore-path", "--threads", "--stdin-filepath"];
 var OxfmtAdapter = class extends BaseAdapter {
@@ -937,6 +967,8 @@ var OxfmtAdapter = class extends BaseAdapter {
     const oxfmt = resolveOxfmt(ctx.cwd);
     if (!oxfmt) return;
     const pass = spawnSync(oxfmt, ["--write", "."], { cwd: ctx.cwd, encoding: "utf8" });
+    process.stderr.write(`  ${palette(process.stderr).dim(FORMATTER_DIFFERENCES)}
+`);
     if (pass.status === 0) return;
     const output = `${pass.stdout ?? ""}${pass.stderr ?? ""}`;
     const unparseable = unparseableFiles(output);
@@ -1040,7 +1072,15 @@ var OxfmtAdapter = class extends BaseAdapter {
       })),
       // Which files this module does not format at all. A long list here is worth a look:
       // it is the quiet way a module stops being covered.
-      ignored: Array.isArray(adoption.local.ignorePatterns) ? adoption.local.ignorePatterns.length : 0
+      ignored: Array.isArray(adoption.local.ignorePatterns) ? adoption.local.ignorePatterns.length : 0,
+      // And which CHECKS it does not perform. `overrides` above answers "what is different
+      // here"; this answers "what is not being checked at all", which is the question a gap
+      // has to be readable as. Reported for adopted modules only: an unadopted module is not
+      // missing a check, it has not started.
+      // From `adoption.effective`, NOT the merged `options` above. This answers "what will
+      // oxfmt actually do", and oxfmt reads the file. An undeclared override is still drift
+      // — that is `drift`'s job — but it is not also a missing check.
+      ...adoption.adopted ? { unenforced: unenforcedFormatOptions(adoption.effective) } : {}
     };
   }
   /**
@@ -3870,20 +3910,52 @@ var OxlintAdapter = class extends BaseAdapter {
     };
   }
   /** How many rules the extended preset enforces, read from the preset on disk. */
+  /**
+   * How many rules this module actually enforces.
+   *
+   * Counted from the PRESET it extends, not from its own file: the stub is one line by
+   * design, so counting there would always answer zero and read as "this module lints
+   * nothing".
+   *
+   * Two things this got wrong, both worth stating because both produced the same dangerous
+   * output — a module reporting `rules=0` while `conformant=true`, which the migration page
+   * counts as adopted and checking an empty set:
+   *
+   *  - it used `JSON.parse`. The chain is JSONC: the per-module baseline carries a comment
+   *    per held rule explaining why. One comment anywhere in the chain threw, the catch
+   *    returned 0, and host-admin reported 188 rules as 0 the moment it gained a baseline.
+   *  - one unreadable entry zeroed the WHOLE count. An entry that cannot be read is a gap in
+   *    the count, not proof the module enforces nothing, and the difference matters most
+   *    exactly when something is broken.
+   *
+   * Counted as a SET of rule names, so the baseline re-stating a preset rule at `warn` is
+   * the same rule, not a second one.
+   */
   presetRuleCount(cwd) {
     const target = this.unresolvedPreset(cwd);
     if (target) return 0;
-    let total = 0;
+    let stub;
     try {
-      const stub = JSON.parse(readFileSync14(join18(cwd, LINT_CONFIG_FILE), "utf8"));
-      for (const entry of stub.extends ?? []) {
-        const preset = JSON.parse(readFileSync14(join18(cwd, entry), "utf8"));
-        total += Object.keys(preset.rules ?? {}).length;
-      }
+      stub = parseJsonc(
+        readFileSync14(join18(cwd, LINT_CONFIG_FILE), "utf8"),
+        LINT_CONFIG_FILE
+      );
     } catch {
       return 0;
     }
-    return total;
+    const names = /* @__PURE__ */ new Set();
+    for (const entry of stub.extends ?? []) {
+      try {
+        const preset = parseJsonc(
+          readFileSync14(join18(cwd, entry), "utf8"),
+          entry
+        );
+        for (const rule of Object.keys(preset.rules ?? {})) names.add(rule);
+      } catch {
+        continue;
+      }
+    }
+    return names.size;
   }
   /** Lint health for `--report`. Deepened in a later step; today it is the run outcome. */
   async report(ctx) {
@@ -3944,7 +4016,10 @@ var OxlintAdapter = class extends BaseAdapter {
   unresolvedPreset(cwd) {
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync14(join18(cwd, LINT_CONFIG_FILE), "utf8"));
+      parsed = parseJsonc(
+        readFileSync14(join18(cwd, LINT_CONFIG_FILE), "utf8"),
+        LINT_CONFIG_FILE
+      );
     } catch {
       return void 0;
     }
@@ -5055,4 +5130,4 @@ export {
   detectFramework,
   dispatch
 };
-//# sourceMappingURL=chunk-B337JGTW.js.map
+//# sourceMappingURL=chunk-HNE774F7.js.map

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   registerAdapters,
   resolve,
   setDefaultRunner
-} from "./chunk-B337JGTW.js";
+} from "./chunk-HNE774F7.js";
 export {
   BaseAdapter,
   all,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hublo/sentinel",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "One CLI that guards code health across Hublo repos: shared lint/typescript/build/test presets, static & dynamic analysis, and architecture checks.",
   "type": "module",
   "license": "MIT",