@hublo/sentinel 1.0.1 → 1.0.3

package/dist/bin/sentinel.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 import {
+  FLAVOURS,
+  TARGETS,
+  VERBS,
   availableTargets,
   describeFramework,
   dispatch,
@@ -11,7 +14,7 @@ import {
   registerAdapters,
   resolve,
   resolveBin
-} from "../chunk-HKGCWPRT.js";
+} from "../chunk-BN3TB6TF.js";
 
 // bin/sentinel.ts
 import { program } from "commander";
@@ -106,20 +109,6 @@ function resolveContext(cwd2, opts2) {
   );
 }
 
-// src/core/domain.ts
-var VERBS = ["run", "inspect", "init", "migrate", "report", "status"];
-var TARGETS = [
-  "lint",
-  "format",
-  "typescript",
-  "build",
-  "test",
-  "static-analysis",
-  "runtime-analysis",
-  "arch"
-];
-var FLAVOURS = ["react", "nest", "svelte", "node"];
-
 // src/core/orchestrate.ts
 async function analyse(params) {
   const results = [];
@@ -141,14 +130,6 @@ async function analyse(params) {
         );
       }
     }
-    const ctx = {
-      module: module.name,
-      cwd: module.root,
-      flavour: flavour2,
-      ci: params.ci,
-      fix: params.fix,
-      maxDiagnostics: params.maxDiagnostics
-    };
     for (const target of params.targets) {
       let adapter;
       try {
@@ -167,13 +148,22 @@ async function analyse(params) {
         }
         continue;
       }
+      const effectiveFlavour = params.flavour ?? adapter.declaredFlavour?.(module.root) ?? flavour2;
+      const ctx = {
+        module: module.name,
+        cwd: module.root,
+        flavour: effectiveFlavour,
+        ci: params.ci,
+        fix: params.fix,
+        maxDiagnostics: params.maxDiagnostics
+      };
       try {
         if (params.verb === "run") {
           if (params.modules.length > 1) {
             const err = palette(process.stderr);
             process.stderr.write(
               `
-  ${err.accent("\u25B6")} ${err.strong(module.name)} ${err.dim(`(${flavour2})`)} ${target}
+  ${err.accent("\u25B6")} ${err.strong(module.name)} ${err.dim(`(${effectiveFlavour})`)} ${target}
 `
             );
           }
@@ -181,7 +171,7 @@ async function analyse(params) {
           results.push({
             project: module.name,
             target,
-            flavour: flavour2,
+            flavour: effectiveFlavour,
             ok: result.ok,
             status: result.ok ? "ok" : "failed",
             data: {}
@@ -192,7 +182,7 @@ async function analyse(params) {
           results.push({
             project: module.name,
             target,
-            flavour: flavour2,
+            flavour: effectiveFlavour,
             ok: result.ok,
             status: result.ok ? "ok" : "failed",
             data: result.metrics ?? {}
@@ -203,7 +193,7 @@ async function analyse(params) {
           results.push({
             project: module.name,
             target,
-            flavour: flavour2,
+            flavour: effectiveFlavour,
             ok: true,
             status: "ok",
             data: config
@@ -214,7 +204,7 @@ async function analyse(params) {
           results.push({
             project: module.name,
             target,
-            flavour: flavour2,
+            flavour: effectiveFlavour,
             ok,
             status: ok ? "ok" : "failed",
             data: status
@@ -226,7 +216,7 @@ async function analyse(params) {
         results.push({
           project: module.name,
           target,
-          flavour: flavour2,
+          flavour: effectiveFlavour,
           ok: false,
           status: "failed",
           data: { error: message }
@@ -529,8 +519,13 @@ async function runVerb() {
     maxDiagnostics,
     ci: Boolean(opts.ci),
     fix: Boolean(opts.fix),
-    onProgress: (done, total, name) => process.stderr.write(err.dim(`  [${done}/${total}] ${name}
-`))
+    // Per-module progress is a HUMAN affordance: it tells someone staring at a slow sweep
+    // that it is alive. On this monorepo's 441 projects it is 441 lines that bury the four
+    // that matter, and it is pure noise in a captured log. So emit it only for an
+    // interactive terminal; a pipe, CI, or a generated trace gets the results and the
+    // one-line summary, which is all any of them can use.
+    onProgress: process.stderr.isTTY ? (done, total, name) => process.stderr.write(err.dim(`  [${done}/${total}] ${name}
+`)) : void 0
   });
   const summary = generateSummaries(results, targets);
   if (opts.json && verb !== "run") {
@@ -613,18 +608,24 @@ sentinel (${type}): ${asMessage(err)}
   }
   return worst;
 }
+async function exitWithoutTruncating(code) {
+  process.exitCode = code;
+  const stream = process.stdout;
+  if (stream.write("")) return;
+  await new Promise((resolve2) => stream.once("drain", () => resolve2()));
+}
 async function main() {
   if (verb === "migrate") {
     program.error("--migrate is planned and not available yet; use --init to set a module up.");
   }
   const runSelectedVerb = verb === "init" ? runInit : runVerb;
   const exitCode = await runSelectedVerb();
-  process.exit(exitCode);
+  await exitWithoutTruncating(exitCode);
 }
 main().catch((error) => {
   process.stderr.write(`
 sentinel: ${asMessage(error)}
 `);
-  process.exit(1);
+  void exitWithoutTruncating(1);
 });
 //# sourceMappingURL=sentinel.js.map

package/dist/{chunk-HKGCWPRT.js → chunk-BN3TB6TF.js}

@@ -62,6 +62,20 @@ var BaseAdapter = class {
   }
 };
 
+// src/core/domain.ts
+var VERBS = ["run", "inspect", "init", "migrate", "report", "status"];
+var TARGETS = [
+  "lint",
+  "format",
+  "typescript",
+  "build",
+  "test",
+  "static-analysis",
+  "runtime-analysis",
+  "arch"
+];
+var FLAVOURS = ["react", "nest", "svelte", "node"];
+
 // src/shared/color.ts
 import { styleText } from "util";
 function palette(stream) {
@@ -125,8 +139,12 @@ function readNxProjectName(dir) {
 
 // src/roles/typescript/adapters/tsc/tsc.adapter.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { basename, join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { basename, join as join6 } from "path";
+
+// src/core/config/flavour-evidence.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 
 // src/shared/jsonc.ts
 import { parse, printParseErrorCode } from "jsonc-parser";
@@ -140,14 +158,92 @@ function parseJsonc(text, source = "config") {
   return value;
 }
 
+// src/core/config/flavour-evidence.ts
+var PATH_SIGNALS = [
+  {
+    flavour: "nest",
+    pattern: /(^|\/)apps\/nest\//,
+    evidence: "it lives under apps/nest"
+  }
+];
+var DEPENDENCY_SIGNALS = [
+  { flavour: "react", pattern: /^(react|react-dom|@types\/react)$|^eslint-plugin-react/ },
+  { flavour: "svelte", pattern: /^svelte$|^@sveltejs\// },
+  { flavour: "nest", pattern: /^@nestjs\// }
+];
+function dependencyNames(cwd) {
+  const path = join2(cwd, "package.json");
+  if (!existsSync2(path)) return [];
+  try {
+    const manifest = parseJsonc(
+      readFileSync2(path, "utf8"),
+      path
+    );
+    return [
+      ...Object.keys(manifest.dependencies ?? {}),
+      ...Object.keys(manifest.devDependencies ?? {})
+    ];
+  } catch {
+    return [];
+  }
+}
+function declaresJsx(cwd) {
+  let entries;
+  try {
+    entries = readdirSync(cwd).filter(
+      (name) => name.startsWith("tsconfig") && name.endsWith(".json")
+    );
+  } catch {
+    return false;
+  }
+  for (const name of entries) {
+    try {
+      const config = parseJsonc(
+        readFileSync2(join2(cwd, name), "utf8"),
+        name
+      );
+      if (config.compilerOptions?.jsx !== void 0) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function flavourSignals(cwd) {
+  const signals = [];
+  const dependencies = dependencyNames(cwd);
+  for (const { flavour, pattern } of DEPENDENCY_SIGNALS) {
+    const hit = dependencies.find((name) => pattern.test(name));
+    if (hit) signals.push({ flavour, evidence: `it depends on "${hit}"` });
+  }
+  if (declaresJsx(cwd) && !signals.some((signal) => signal.flavour === "react")) {
+    signals.push({ flavour: "react", evidence: 'its tsconfig sets "jsx"' });
+  }
+  const location = cwd.replaceAll("\\", "/");
+  for (const { flavour, pattern, evidence } of PATH_SIGNALS) {
+    if (pattern.test(location) && !signals.some((signal) => signal.flavour === flavour)) {
+      signals.push({ flavour, evidence });
+    }
+  }
+  return signals;
+}
+function flavourContradiction(declared, cwd) {
+  const signals = flavourSignals(cwd);
+  if (signals.length === 0) return void 0;
+  if (signals.some((signal) => signal.flavour === declared)) return void 0;
+  const [first] = signals;
+  if (!first) return void 0;
+  const evidence = signals.map((signal) => signal.evidence).join(", and ");
+  return `--flavour ${declared} does not match this module: ${evidence}, which makes it "${first.flavour}". Nothing was written. Re-run with --flavour ${first.flavour}, or adopt from the module you actually meant.`;
+}
+
 // src/shared/resolve-bin.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
 function resolveBin(fromDir, name) {
   let dir = fromDir;
   for (; ; ) {
-    const candidate = join2(dir, "node_modules", ".bin", name);
-    if (existsSync2(candidate)) return candidate;
+    const candidate = join3(dir, "node_modules", ".bin", name);
+    if (existsSync3(candidate)) return candidate;
     const parent = dirname2(dir);
     if (parent === dir) return void 0;
     dir = parent;
@@ -184,18 +280,18 @@ function hasShippedPreset(flavour) {
 }
 
 // src/roles/typescript/read-adoption.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
 
 // src/roles/typescript/resolve-tsconfig-target.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
 var TARGET_EXTENDS_MARKERS = ["tsconfig.base.json", "@hublo/sentinel/tsconfig/"];
 var CANDIDATES = ["tsconfig.app.json", "tsconfig.json"];
 function readExtends(absolutePath) {
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync2(absolutePath, "utf8"), absolutePath);
+    parsed = parseJsonc(readFileSync3(absolutePath, "utf8"), absolutePath);
   } catch {
     return [];
   }
@@ -207,11 +303,15 @@ function readExtends(absolutePath) {
 }
 function resolveTsconfigTarget(moduleDir) {
   let existing;
+  let existingExtendsSomething = false;
   for (const candidate of CANDIDATES) {
-    const absolutePath = join3(moduleDir, candidate);
-    if (!existsSync3(absolutePath)) continue;
-    existing ??= candidate;
+    const absolutePath = join4(moduleDir, candidate);
+    if (!existsSync4(absolutePath)) continue;
     const extendsValues = readExtends(absolutePath);
+    if (existing === void 0) {
+      existing = candidate;
+      existingExtendsSomething = extendsValues.length > 0;
+    }
     const extendsBase = extendsValues.some(
       (value) => TARGET_EXTENDS_MARKERS.some((marker) => value.includes(marker))
     );
@@ -219,7 +319,9 @@ function resolveTsconfigTarget(moduleDir) {
       return { path: candidate, reason: "extends-base" };
     }
   }
-  if (existing) return { path: existing, reason: "other-chain" };
+  if (existing) {
+    return { path: existing, reason: existingExtendsSomething ? "other-chain" : "no-extends" };
+  }
   return { path: "tsconfig.json", reason: "none" };
 }
 
@@ -240,12 +342,12 @@ var NOT_ADOPTED = (configFile) => ({
 });
 function readTsconfigAdoption(cwd) {
   const target = resolveTsconfigTarget(cwd);
-  if (target.reason === "none" || !existsSync4(join4(cwd, target.path))) {
+  if (target.reason === "none" || !existsSync5(join5(cwd, target.path))) {
     return NOT_ADOPTED(target.reason === "none" ? null : target.path);
   }
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync3(join4(cwd, target.path), "utf8"), target.path);
+    parsed = parseJsonc(readFileSync4(join5(cwd, target.path), "utf8"), target.path);
   } catch {
     return NOT_ADOPTED(target.path);
   }
@@ -294,6 +396,20 @@ var TscAdapter = class extends BaseAdapter {
   appliesTo(_flavour) {
     return true;
   }
+  /**
+   * The flavour read from the committed `extends` chain
+   * (`@hublo/sentinel/tsconfig/nest` -> `nest`), or undefined when the module has not
+   * adopted a preset, so the engine falls back to dependency detection.
+   *
+   * This is the same detection-free read `--status` uses, and it is why an adopted React app
+   * reports `react` even in a monorepo that hoists `react` to the root.
+   */
+  declaredFlavour(cwd) {
+    const { preset } = readTsconfigAdoption(cwd);
+    if (!preset) return void 0;
+    const name = preset.slice(preset.lastIndexOf("/") + 1);
+    return FLAVOURS.includes(name) ? name : void 0;
+  }
   /**
    * Plan `--init`: make the module extend the sentinel preset with a THIN,
    * conformant stub, route type-checking through the CLI, and pin the
@@ -314,6 +430,17 @@ var TscAdapter = class extends BaseAdapter {
         blocked: `no TypeScript preset for flavour "${context.flavour}" yet (shipped: ${SHIPPED_FLAVOURS.join(", ")}). Nothing was written; this module cannot adopt the TypeScript preset until that flavour ships.`
       };
     }
+    const current = this.declaredFlavour(context.cwd);
+    if (current !== void 0 && current !== context.flavour) {
+      return {
+        operations: [],
+        blocked: `this module is already adopted as "${current}", and --flavour says "${context.flavour}". Nothing was written. If the change is deliberate, remove the sentinel preset from the tsconfig \`extends\` chain and re-run; otherwise re-run with --flavour ${current}.`
+      };
+    }
+    const contradiction = flavourContradiction(context.flavour, context.cwd);
+    if (contradiction !== void 0) {
+      return { operations: [], blocked: contradiction };
+    }
     const target = resolveTsconfigTarget(context.cwd);
     const preset = `@hublo/sentinel/tsconfig/${context.flavour}`;
     const addScript = this.packageJsonOperation(context.cwd);
@@ -322,6 +449,12 @@ var TscAdapter = class extends BaseAdapter {
         operations: [],
         blocked: `${target.path} extends a config chain sentinel does not handle, so nothing was written. Point it at the workspace base (or a plain config) and re-run.`
       };
+      if (target.reason === "no-extends") {
+        return {
+          operations: [],
+          blocked: `${target.path} extends nothing, so it defines its own complete set of compilerOptions and sentinel will not silently take ownership of them. Nothing was written. Make it extend the workspace base and re-run, and --init will then move the shared options into the preset.`
+        };
+      }
     }
     if (target.reason === "none") {
       const contents = JSON.stringify({ extends: preset, include: ["src"] }, null, 2) + "\n";
@@ -331,7 +464,7 @@ var TscAdapter = class extends BaseAdapter {
       };
     }
     const existing = parseJsonc(
-      readFileSync4(join5(context.cwd, target.path), "utf8"),
+      readFileSync5(join6(context.cwd, target.path), "utf8"),
       target.path
     );
     const extendsChain = composeExtends(existing.extends, preset);
@@ -366,7 +499,7 @@ var TscAdapter = class extends BaseAdapter {
   packageJsonOperation(cwd) {
     const own = readOwnPackage();
     const devDependencies = { [own.name]: own.version };
-    if (existsSync5(join5(cwd, "package.json"))) {
+    if (existsSync6(join6(cwd, "package.json"))) {
       return {
         kind: "merge-json",
         path: "package.json",
@@ -414,7 +547,7 @@ var TscAdapter = class extends BaseAdapter {
    * check.
    */
   typecheckTarget(cwd) {
-    if (existsSync5(join5(cwd, "tsconfig.json"))) return "tsconfig.json";
+    if (existsSync6(join6(cwd, "tsconfig.json"))) return "tsconfig.json";
     const target = resolveTsconfigTarget(cwd);
     return target.reason === "none" ? null : target.path;
   }
@@ -598,7 +731,7 @@ function diffLines(before, after) {
 }
 
 // src/core/apply-plan.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, renameSync, writeFileSync } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, renameSync, writeFileSync } from "fs";
 import { resolve as resolve2, sep } from "path";
 import { applyEdits, modify } from "jsonc-parser";
 
@@ -617,7 +750,7 @@ function resolveWithinRoot(cwd, relativePath) {
   return absolutePath;
 }
 function readIfExists(absolutePath) {
-  return existsSync6(absolutePath) ? readFileSync5(absolutePath, "utf8") : void 0;
+  return existsSync7(absolutePath) ? readFileSync6(absolutePath, "utf8") : void 0;
 }
 function* leaves(value, prefix = []) {
   for (const [key, keyValue] of Object.entries(value)) {
@@ -745,8 +878,9 @@ async function dispatch(opts) {
   if (opts.verb !== "init") {
     throw new Error(`dispatch handles --init only; --${opts.verb} routes through analyse()`);
   }
-  const flavour = resolveFlavour(opts);
-  const adapter = resolve(opts.target, flavour, opts.runner);
+  const detected = resolveFlavour(opts);
+  const adapter = resolve(opts.target, detected, opts.runner);
+  const flavour = opts.flavour ?? adapter.declaredFlavour?.(opts.cwd) ?? detected;
   const context = { cwd: opts.cwd, flavour };
   const plan = await adapter.plan(context);
   if (plan.blocked) {
@@ -772,6 +906,9 @@ export {
   availableTargets,
   resolve,
   BaseAdapter,
+  VERBS,
+  TARGETS,
+  FLAVOURS,
   palette,
   readOwnPackage,
   readOwnVersion,
@@ -783,4 +920,4 @@ export {
   detectFramework,
   dispatch
 };
-//# sourceMappingURL=chunk-HKGCWPRT.js.map
+//# sourceMappingURL=chunk-BN3TB6TF.js.map

package/dist/index.d.ts

@@ -169,6 +169,17 @@ interface Adapter {
      * adapters can share a (target, runner) if they specialise different flavours.
      */
     appliesTo(flavour: Flavour): boolean;
+    /**
+     * The flavour this module has COMMITTED to, read from its own config, or undefined when
+     * it has not adopted a preset yet. Optional: an adapter implements it only when its tool's
+     * config states the flavour unambiguously.
+     *
+     * The engine prefers this over dependency detection, because in a monorepo dependencies are
+     * hoisted to the root: `host-admin` declares no `react`, so detection honestly answers
+     * `node` while the committed `extends` says `.../tsconfig/react`. Reporting the detected
+     * value there would show every adopted module as `node`, which is simply untrue.
+     */
+    declaredFlavour?(cwd: string): Flavour | undefined;
     /**
      * Plan what `--init` should write, as declarative operations (see
      * `FileOperation`). Given a normalized `UpdateContext`, the adapter may READ the

package/dist/index.js

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

package/package.json

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