@hublo/sentinel 1.1.0-alpha.6 → 1.1.0

package/dist/bin/sentinel.js

@@ -16,7 +16,7 @@ import {
   registerAdapters,
   resolve,
   resolveBin
-} from "../chunk-U2NAKQXR.js";
+} from "../chunk-FA6N4XCP.js";
 
 // bin/sentinel.ts
 import { program } from "commander";
@@ -223,6 +223,14 @@ async function analyse(params) {
         toolArgs: params.toolArgs
       };
       try {
+        let adoption;
+        if (params.verb === "run" || params.verb === "report") {
+          try {
+            adoption = await adapter.status(ctx);
+          } catch {
+          }
+        }
+        const adoptionFields = adoption ? { adopted: adoption.adopted, preset: adoption.preset, conformant: adoption.conformant } : {};
         if (params.verb === "run") {
           if (params.modules.length > 1) {
             const err = palette(process.stderr);
@@ -239,7 +247,7 @@ async function analyse(params) {
             flavour: effectiveFlavour,
             ok: result.ok,
             status: result.ok ? "ok" : "failed",
-            data: {}
+            data: { ...adoptionFields }
           });
           worstCode = Math.max(worstCode, result.code);
         } else if (params.verb === "report") {
@@ -250,12 +258,15 @@ async function analyse(params) {
             flavour: effectiveFlavour,
             ok: result.ok,
             status: result.ok ? "ok" : "failed",
-            data: result.metrics ?? {}
+            // Engine fields LAST, so they WIN. Spreading them first let a role's own metrics
+            // override them, which is the disagreement this was written to remove: the point
+            // is that adoption has exactly one source, not that it has a default.
+            data: { ...result.metrics ?? {}, ...adoptionFields }
           });
           worstCode = Math.max(worstCode, result.code);
         } else if (params.verb === "inspect") {
-          const [config, adoption] = await Promise.all([adapter.inspect(ctx), adapter.status(ctx)]);
-          const ok = !adoption.unreadable && (!adoption.adopted || adoption.conformant);
+          const [config, adoption2] = await Promise.all([adapter.inspect(ctx), adapter.status(ctx)]);
+          const ok = !adoption2.unreadable && (!adoption2.adopted || adoption2.conformant);
           results.push({
             project: module.name,
             target,
@@ -265,7 +276,7 @@ async function analyse(params) {
             // `inspect` is typed as `unknown` (each role shapes its own detail), so the
             // merge is guarded rather than assumed: a role returning a non-object still
             // gets its adoption fields instead of throwing here.
-            data: config && typeof config === "object" ? { ...config, ...adoption } : { ...adoption }
+            data: config && typeof config === "object" ? { ...config, ...adoption2 } : { ...adoption2 }
           });
           if (!ok) worstCode = Math.max(worstCode, 1);
         } else {

package/dist/{chunk-U2NAKQXR.js → chunk-FA6N4XCP.js}

@@ -1057,7 +1057,7 @@ var OxfmtAdapter = class extends BaseAdapter {
    */
   async report(ctx) {
     const adoption = readFormatAdoption(ctx.cwd);
-    const base = { adopted: adoption.adopted, preset: adoption.preset };
+    const base = {};
     if (!adoption.adopted) return { ok: true, code: 0, metrics: { ...base, unformatted: 0 } };
     const oxfmt = resolveOxfmt(ctx.cwd);
     if (!oxfmt) {
@@ -3023,9 +3023,15 @@ import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 import { join as join13 } from "path";
 
 // src/core/config/owned-keys.ts
-function presetOwnedKeys(config, permitted) {
+function presetOwnedKeys(config, permitted, presetSets) {
   if (!config) return [];
-  return Object.keys(config).filter((key) => !permitted.includes(key));
+  return Object.keys(config).filter(
+    (key) => !permitted.includes(key) && (presetSets === void 0 || presetSets.includes(key))
+  );
+}
+function localOnlyKeys(config, permitted, presetSets) {
+  if (!config) return [];
+  return Object.keys(config).filter((key) => !permitted.includes(key) && !presetSets.includes(key));
 }
 
 // src/core/config/resolve-config-target.ts
@@ -3095,7 +3101,7 @@ function readAdoption(cwd, options) {
   const preset = normaliseExtends(parsed.extends).find((entry) => options.presetPattern.test(entry)) ?? null;
   if (preset === null) return NOT_ADOPTED2(target.path);
   const settings = options.settingsKey === null ? parsed : parsed[options.settingsKey];
-  const drift = presetOwnedKeys(settings, options.permitted);
+  const drift = presetOwnedKeys(settings, options.permitted, options.presetOwns?.(preset));
   return {
     configFile: target.path,
     preset,
@@ -3740,10 +3746,9 @@ var OxlintAdapter = class extends BaseAdapter {
   /** Lint health for `--report`. Deepened in a later step; today it is the run outcome. */
   async report(ctx) {
     const adoption = readLintAdoption(ctx.cwd);
-    if (!adoption.adopted) return { ok: true, code: 0, metrics: { adopted: false } };
+    if (!adoption.adopted) return { ok: true, code: 0, metrics: {} };
     const oxlint = resolveOxlint(ctx.cwd);
-    if (!oxlint)
-      return { ok: false, code: 1, metrics: { adopted: true, error: "oxlint not found" } };
+    if (!oxlint) return { ok: false, code: 1, metrics: { error: "oxlint not found" } };
     const typeAware = canRunTypeAware(ctx.cwd) ? ["--type-aware"] : [];
     const result = spawnSync2(oxlint, ["-c", LINT_CONFIG_FILE, ...typeAware, "-f", "json", "."], {
       cwd: ctx.cwd,
@@ -3751,7 +3756,7 @@ var OxlintAdapter = class extends BaseAdapter {
       env: { ...process.env, PATH: oxlintPath(ctx.cwd, process.env) }
     });
     if (result.error) {
-      return { ok: false, code: 1, metrics: { adopted: true, error: result.error.message } };
+      return { ok: false, code: 1, metrics: { error: result.error.message } };
     }
     const diagnostics = parseOxlintDiagnostics(result.stdout ?? "");
     const errors = diagnostics.filter((entry) => entry.severity === "error").length;
@@ -3769,7 +3774,6 @@ var OxlintAdapter = class extends BaseAdapter {
       ok: errors === 0,
       code: errors === 0 ? 0 : 1,
       metrics: {
-        adopted: true,
         errors,
         warnings,
         rules,
@@ -3952,6 +3956,14 @@ validate2();
 function hasShippedPreset(preset) {
   return preset in LAYERS;
 }
+function tsPresetFor(preset) {
+  const layer = LAYERS[preset];
+  if (!layer) throw new Error(`no TypeScript preset ships for preset "${preset}"`);
+  return {
+    ...BASE.$schema === void 0 ? {} : { $schema: BASE.$schema },
+    compilerOptions: { ...BASE.compilerOptions, ...layer.compilerOptions }
+  };
+}
 
 // src/roles/typescript/phased-rules.ts
 function deferredRuleNames2() {
@@ -3966,8 +3978,17 @@ var PERMITTED_COMPILER_OPTIONS = [
   "outDir",
   "tsBuildInfoFile"
 ];
-function presetOwnedKeys2(compilerOptions) {
-  return presetOwnedKeys(compilerOptions, PERMITTED_COMPILER_OPTIONS);
+function presetCompilerOptionKeys(preset) {
+  if (preset === void 0 || !hasShippedPreset(preset)) return void 0;
+  return Object.keys(tsPresetFor(preset).compilerOptions);
+}
+function presetOwnedKeys2(compilerOptions, preset) {
+  return presetOwnedKeys(compilerOptions, PERMITTED_COMPILER_OPTIONS, presetCompilerOptionKeys(preset));
+}
+function localOnlyCompilerOptions(compilerOptions, preset) {
+  const sets = presetCompilerOptionKeys(preset);
+  if (sets === void 0) return [];
+  return localOnlyKeys(compilerOptions, PERMITTED_COMPILER_OPTIONS, sets);
 }
 
 // src/roles/typescript/resolve-tsconfig-target.ts
@@ -3991,7 +4012,11 @@ function readTsconfigAdoption(cwd) {
     fallback: TSCONFIG_FALLBACK,
     presetPattern: SENTINEL_PRESET,
     settingsKey: "compilerOptions",
-    permitted: PERMITTED_COMPILER_OPTIONS
+    permitted: PERMITTED_COMPILER_OPTIONS,
+    // Drift is measured against what the preset SETS, not against the allowlist alone: see
+    // `presetOwnedKeys`. Without this a module overriding the workspace base reads as
+    // non-conformant forever, since re-running `--init` would not (and should not) fix it.
+    presetOwns: (path) => presetCompilerOptionKeys(path.slice(path.lastIndexOf("/") + 1)) ?? []
   });
 }
 
@@ -4086,7 +4111,8 @@ function planAdoption(context) {
     target.path
   );
   const extendsChain = composeExtends(existing.extends, preset);
-  const drift = presetOwnedKeys2(existing.compilerOptions);
+  const drift = presetOwnedKeys2(existing.compilerOptions, context.preset);
+  const keptLocal = localOnlyCompilerOptions(existing.compilerOptions, context.preset);
   const operations = [
     { kind: "merge-json", path: target.path, value: { extends: extendsChain } }
   ];
@@ -4101,6 +4127,11 @@ function planAdoption(context) {
     });
     notes.push(`stripped preset-owned compilerOptions: ${drift.join(", ")}`);
   }
+  if (keptLocal.length > 0) {
+    notes.push(
+      `KEPT this module's own compilerOptions (${keptLocal.join(", ")}): the preset does not set them, so they are yours rather than drift. Removing them would not hand the decision to the preset, it would hand it to the workspace tsconfig this module extends`
+    );
+  }
   operations.push(addScript, ...nxTargets);
   const existingCheck = moduleScripts(context.cwd)[TYPECHECK_SCRIPT_NAME];
   if (keepsForeignChecker(existingCheck)) {
@@ -4133,7 +4164,7 @@ function parseDiagnostics(output) {
   return diagnostics;
 }
 var PHASED_STRICTNESS_WARNING = `sentinel typescript: phase 1 (non-breaking) \u2014 deferred: ${deferredRuleNames2().join(", ")}. Enabled centrally in a later wave; run \`sentinel --inspect --typescript\` for the list, or \`sentinel --run --typescript -- --noImplicitAny\` to measure what one would cost today.`;
-var TscAdapter = class extends BaseAdapter {
+var TscAdapter = class _TscAdapter extends BaseAdapter {
   target = "typescript";
   runner = "tsc";
   /**
@@ -4241,6 +4272,13 @@ var TscAdapter = class extends BaseAdapter {
       );
       return { ok: true, code: 0 };
     }
+    if (!readTsconfigAdoption(ctx.cwd).adopted) {
+      process.stderr.write(
+        `sentinel typescript(tsc): no sentinel preset in this module's tsconfig; run \`sentinel --init --typescript\` to adopt.
+`
+      );
+      return { ok: true, code: 0 };
+    }
     const missing = this.missingPresetPackage(ctx.cwd);
     if (missing) {
       process.stderr.write(
@@ -4366,10 +4404,23 @@ var TscAdapter = class extends BaseAdapter {
    * 7006/7031/7053/… ), the signal that drives the noImplicitAny migration. No
    * tsconfig is a clean, empty report.
    */
+  /**
+   * The metrics for a module this role has nothing to say about. Every KEY the full path
+   * emits, so a consumer never sees a row whose shape depends on whether the module adopted.
+   */
+  static NOTHING_TO_REPORT = {
+    errors: 0,
+    implicitAny: "deferred",
+    diagnostics: [],
+    diagnosticsTruncated: false
+  };
   async report(ctx) {
     const config = this.typecheckTarget(ctx.cwd);
     if (!config) {
-      return { ok: true, code: 0, metrics: { errors: 0, implicitAny: "deferred", diagnostics: [] } };
+      return { ok: true, code: 0, metrics: _TscAdapter.NOTHING_TO_REPORT };
+    }
+    if (!readTsconfigAdoption(ctx.cwd).adopted) {
+      return { ok: true, code: 0, metrics: _TscAdapter.NOTHING_TO_REPORT };
     }
     const tsc = resolveBin(ctx.cwd, "tsc") ?? "tsc";
     const result = spawnSync3(tsc, ["-b", config], { cwd: ctx.cwd, encoding: "utf8" });
@@ -4861,4 +4912,4 @@ export {
   detectFramework,
   dispatch
 };
-//# sourceMappingURL=chunk-U2NAKQXR.js.map
+//# sourceMappingURL=chunk-FA6N4XCP.js.map

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hublo/sentinel",
-  "version": "1.1.0-alpha.6",
+  "version": "1.1.0",
   "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",