@hublo/sentinel 1.5.1-alpha.0 → 1.5.1-alpha.1

package/README.md

@@ -55,10 +55,13 @@ sentinel --init --preset <react|nest|node|svelte>   # every role sentinel ships
 pnpm install   # fetch what --init declared, then commit
 ```
 
-With no target named, `--init` adopts every role, in the order that makes the result correct:
-the linter's autofix runs, then the formatter runs **last** and formats everything every role
-wrote. Naming a target (`--init --build`) adopts just that role and leaves the rest alone, with
+With no target named, `--init` on a module that has adopted nothing adopts every role, in the
+order that makes the result correct: the linter's autofix runs, then the formatter runs **last**
+and formats everything every role wrote. On a module that has already adopted a role, the same
+bare `--init` re-inits only the roles it has, read the way `--inspect` reports them, and says
+which. Naming a target (`--init --build`) adopts just that role and leaves the rest alone, with
 one pairing: lint and format are always adopted together, so `--init --lint` adopts oxfmt too.
+`--init --all` adopts every role on any module.
 
 `--init` writes the config stubs, the `typecheck`/`lint`/... scripts, and pins the `@hublo/sentinel` devDependency into the module (no manual `pnpm add`); it scaffolds a `package.json` for a `project.json`-only module. It also applies, once, the workspace prep that module needs at the root, only when the root's own config shows it is needed (e.g. an i18next singleton override when the repo runs a second TypeScript, a release-age allow-list when the repo uses that pnpm gate). See the [adoption cheat sheet](docs/typescript-adoption.md) for the full list.
 
@@ -128,7 +131,7 @@ And the app's `package.json` scripts route every check through the one CLI (run
 **Step 3 — evolve the toolchain, in one central place:**
 
 - a **rule change** → bump the `@hublo/sentinel` version; the stubs already point at it, so there is **nothing to regenerate**;
-- a **structural change** (new tool, new preset, runner swap) → run `sentinel --init` once to refresh the stubs (sentinel tells you when this is needed).
+- a **structural change** (new tool, new preset, runner swap) → run `sentinel --init` once to refresh the stubs (sentinel tells you when this is needed). On an adopted module it re-inits the roles the module has, and no others.
 
 **Step 4 — stay converged:** a drift guard in CI flags any module whose config quietly diverged from the shared source.
 

package/dist/bin/sentinel.js

@@ -11,10 +11,10 @@ import {
   presetNotInstalledYet,
   registerAdapters,
   resolve
-} from "../chunk-CL7HOHTU.js";
+} from "../chunk-64H5HBPH.js";
 import {
   resolveContext
-} from "../chunk-I2WDZNPR.js";
+} from "../chunk-J2USE3KV.js";
 import {
   ensureWorkspacePrep,
   findWorkspaceRoot,
@@ -36,6 +36,175 @@ import "../chunk-QXFCZON7.js";
 // bin/sentinel.ts
 import { program } from "commander";
 
+// src/core/orchestrate.ts
+async function analyse(params) {
+  const results = [];
+  let worstCode = 0;
+  let done = 0;
+  for (const module of params.modules) {
+    let preset2;
+    if (params.preset) {
+      preset2 = params.preset;
+    } else {
+      const detection = describeFramework(readProjectPackageJson(module.root));
+      preset2 = detection.preset;
+      if (detection.ambiguous) {
+        const warn = palette(process.stderr);
+        process.stderr.write(
+          warn.warn(
+            `sentinel: ${module.name}: preset is ambiguous, detected "${preset2}" (from ${detection.source}), also found ${detection.conflicts.join(", ")}. Pass --preset to be explicit.`
+          ) + "\n"
+        );
+      }
+      preset2 = correctingSignal(preset2, module.root)?.preset ?? preset2;
+    }
+    for (const target of params.targets) {
+      let adapter;
+      const declared = declaredPresetFor(target, module.root);
+      const corrected = params.preset ?? declared ?? correctingSignal(preset2, module.root)?.preset ?? preset2;
+      const resolutionPreset = corrected;
+      try {
+        adapter = resolve(target, resolutionPreset, params.runner);
+      } catch (error) {
+        if (params.targetsExplicit) {
+          const reason = error instanceof Error ? error.message : String(error);
+          results.push({
+            project: module.name,
+            target,
+            flavour: preset2,
+            ok: false,
+            status: "unsupported",
+            data: { reason }
+          });
+        }
+        continue;
+      }
+      const effectiveFlavour = params.preset ?? adapter.declaredPreset?.(module.root) ?? preset2;
+      const ctx = {
+        module: module.name,
+        cwd: module.root,
+        preset: effectiveFlavour,
+        ci: params.ci,
+        fix: params.fix,
+        maxDiagnostics: params.maxDiagnostics,
+        toolArgs: params.toolArgs,
+        output: params.output
+      };
+      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);
+            process.stderr.write(
+              `
+  ${err.accent("\u25B6")} ${err.strong(module.name)} ${err.dim(`(${effectiveFlavour})`)} ${target}
+`
+            );
+          }
+          const result = await adapter.run(ctx);
+          results.push({
+            project: module.name,
+            target,
+            flavour: effectiveFlavour,
+            ok: result.ok,
+            status: result.ok ? "ok" : "failed",
+            data: { ...adoptionFields }
+          });
+          worstCode = Math.max(worstCode, result.code);
+        } else if (params.verb === "report") {
+          const result = await adapter.report(ctx);
+          results.push({
+            project: module.name,
+            target,
+            flavour: effectiveFlavour,
+            ok: result.ok,
+            status: result.ok ? "ok" : "failed",
+            // 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, adoption2] = await Promise.all([adapter.inspect(ctx), adapter.status(ctx)]);
+          const ok = !adoption2.unreadable && (!adoption2.adopted || adoption2.conformant);
+          results.push({
+            project: module.name,
+            target,
+            flavour: effectiveFlavour,
+            ok,
+            status: ok ? "ok" : "failed",
+            // `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, ...adoption2 } : { ...adoption2 }
+          });
+          if (!ok) worstCode = Math.max(worstCode, 1);
+        } else {
+          const status = await adapter.status(ctx);
+          const ok = !status.unreadable && (!status.adopted || status.conformant);
+          results.push({
+            project: module.name,
+            target,
+            flavour: effectiveFlavour,
+            ok,
+            status: ok ? "ok" : "failed",
+            data: status
+          });
+          if (!ok) worstCode = Math.max(worstCode, 1);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        results.push({
+          project: module.name,
+          target,
+          flavour: effectiveFlavour,
+          ok: false,
+          status: "failed",
+          data: { error: message }
+        });
+        worstCode = Math.max(worstCode, 1);
+      }
+    }
+    params.onProgress?.(done += 1, params.modules.length, module.name);
+  }
+  return { results, worstCode };
+}
+function generateSummary(result) {
+  const { project, target, flavour, ok, status, data } = result;
+  const details = data && typeof data === "object" ? data : { value: data };
+  return { project, target, flavour, ok, status, ...details };
+}
+function generateSummaries(results, requestedTargets) {
+  const available = new Set(availableTargets());
+  return {
+    schemaVersion: 2,
+    executed: requestedTargets.filter((t) => available.has(t)),
+    skipped: requestedTargets.filter((t) => !available.has(t)),
+    results: results.map(generateSummary)
+  };
+}
+async function adoptedTargets(params) {
+  const { results } = await analyse({
+    verb: "status",
+    targets: params.targets,
+    modules: [params.module],
+    preset: params.preset,
+    runner: params.runner,
+    targetsExplicit: false,
+    ci: false,
+    fix: false
+  });
+  return results.filter((row) => row.data?.adopted === true).map((row) => row.target);
+}
+
 // src/core/rehearse.ts
 import { createHash } from "node:crypto";
 import {
@@ -202,6 +371,24 @@ function describeRehearsal(target, rewrites, failure) {
   const rest = rewrites.length - NAMED_REWRITES;
   return `${pass} would rewrite ${rewrites.length} file${rewrites.length === 1 ? "" : "s"} beyond the ones above: ${rest > 0 ? `${named} and ${rest} more` : named}${said}`;
 }
+async function rolesToInit(ctx, module, available) {
+  const requested = ctx.targets.filter((type) => available.includes(type));
+  if (ctx.targetsExplicit || ctx.allTargets) return requested;
+  const adopted = await adoptedTargets({
+    module,
+    targets: requested,
+    preset: ctx.preset,
+    runner: ctx.runner
+  });
+  if (adopted.length === 0) return requested;
+  process.stderr.write(
+    palette(process.stderr).dim(
+      `  re-initializing the roles this module has adopted (${adopted.map((t) => `--${t}`).join(", ")}); to adopt another, name it (sentinel --init --<role>), or pass --all for every role
+`
+    )
+  );
+  return adopted;
+}
 async function runInit(ctx) {
   const { modules, scope } = resolveContext(ctx.cwd, { module: ctx.module, ci: false });
   const [module] = modules;
@@ -219,7 +406,7 @@ async function runInit(ctx) {
       );
     }
   }
-  const named = ctx.targets.filter((type) => available.includes(type));
+  const named = await rolesToInit(ctx, module, available);
   const paired = pairedTargets(named, available);
   const toRun = [...named, ...paired].sort(
     (a, b) => Number(a === "format") - Number(b === "format")
@@ -340,7 +527,7 @@ async function runValidate(ctx) {
     );
   }
   if (!ctx.targets.includes("test")) return 1;
-  const { validateModuleTests } = await import("../validate-S6PIOVAH.js");
+  const { validateModuleTests } = await import("../validate-TIPIECG6.js");
   const outcomes = modules.flatMap(
     (module) => validateModuleTests(module.name, module.root)
   );
@@ -354,162 +541,6 @@ async function runValidate(ctx) {
   return outcomes.every((outcome) => outcome.ok) ? 0 : 1;
 }
 
-// src/core/orchestrate.ts
-async function analyse(params) {
-  const results = [];
-  let worstCode = 0;
-  let done = 0;
-  for (const module of params.modules) {
-    let preset2;
-    if (params.preset) {
-      preset2 = params.preset;
-    } else {
-      const detection = describeFramework(readProjectPackageJson(module.root));
-      preset2 = detection.preset;
-      if (detection.ambiguous) {
-        const warn = palette(process.stderr);
-        process.stderr.write(
-          warn.warn(
-            `sentinel: ${module.name}: preset is ambiguous, detected "${preset2}" (from ${detection.source}), also found ${detection.conflicts.join(", ")}. Pass --preset to be explicit.`
-          ) + "\n"
-        );
-      }
-      preset2 = correctingSignal(preset2, module.root)?.preset ?? preset2;
-    }
-    for (const target of params.targets) {
-      let adapter;
-      const declared = declaredPresetFor(target, module.root);
-      const corrected = params.preset ?? declared ?? correctingSignal(preset2, module.root)?.preset ?? preset2;
-      const resolutionPreset = corrected;
-      try {
-        adapter = resolve(target, resolutionPreset, params.runner);
-      } catch (error) {
-        if (params.targetsExplicit) {
-          const reason = error instanceof Error ? error.message : String(error);
-          results.push({
-            project: module.name,
-            target,
-            flavour: preset2,
-            ok: false,
-            status: "unsupported",
-            data: { reason }
-          });
-        }
-        continue;
-      }
-      const effectiveFlavour = params.preset ?? adapter.declaredPreset?.(module.root) ?? preset2;
-      const ctx = {
-        module: module.name,
-        cwd: module.root,
-        preset: effectiveFlavour,
-        ci: params.ci,
-        fix: params.fix,
-        maxDiagnostics: params.maxDiagnostics,
-        toolArgs: params.toolArgs,
-        output: params.output
-      };
-      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);
-            process.stderr.write(
-              `
-  ${err.accent("\u25B6")} ${err.strong(module.name)} ${err.dim(`(${effectiveFlavour})`)} ${target}
-`
-            );
-          }
-          const result = await adapter.run(ctx);
-          results.push({
-            project: module.name,
-            target,
-            flavour: effectiveFlavour,
-            ok: result.ok,
-            status: result.ok ? "ok" : "failed",
-            data: { ...adoptionFields }
-          });
-          worstCode = Math.max(worstCode, result.code);
-        } else if (params.verb === "report") {
-          const result = await adapter.report(ctx);
-          results.push({
-            project: module.name,
-            target,
-            flavour: effectiveFlavour,
-            ok: result.ok,
-            status: result.ok ? "ok" : "failed",
-            // 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, adoption2] = await Promise.all([adapter.inspect(ctx), adapter.status(ctx)]);
-          const ok = !adoption2.unreadable && (!adoption2.adopted || adoption2.conformant);
-          results.push({
-            project: module.name,
-            target,
-            flavour: effectiveFlavour,
-            ok,
-            status: ok ? "ok" : "failed",
-            // `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, ...adoption2 } : { ...adoption2 }
-          });
-          if (!ok) worstCode = Math.max(worstCode, 1);
-        } else {
-          const status = await adapter.status(ctx);
-          const ok = !status.unreadable && (!status.adopted || status.conformant);
-          results.push({
-            project: module.name,
-            target,
-            flavour: effectiveFlavour,
-            ok,
-            status: ok ? "ok" : "failed",
-            data: status
-          });
-          if (!ok) worstCode = Math.max(worstCode, 1);
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        results.push({
-          project: module.name,
-          target,
-          flavour: effectiveFlavour,
-          ok: false,
-          status: "failed",
-          data: { error: message }
-        });
-        worstCode = Math.max(worstCode, 1);
-      }
-    }
-    params.onProgress?.(done += 1, params.modules.length, module.name);
-  }
-  return { results, worstCode };
-}
-function generateSummary(result) {
-  const { project, target, flavour, ok, status, data } = result;
-  const details = data && typeof data === "object" ? data : { value: data };
-  return { project, target, flavour, ok, status, ...details };
-}
-function generateSummaries(results, requestedTargets) {
-  const available = new Set(availableTargets());
-  return {
-    schemaVersion: 2,
-    executed: requestedTargets.filter((t) => available.has(t)),
-    skipped: requestedTargets.filter((t) => !available.has(t)),
-    results: results.map(generateSummary)
-  };
-}
-
 // src/core/render.ts
 var HEAD_KEYS = /* @__PURE__ */ new Set([
   "project",
@@ -821,7 +852,8 @@ program.name("sentinel").description("One CLI that guards code health: presets,
     // Deliberately not enumerated here. A hand-written list drifts, and this one did: it
     // still said "lint, format, typescript" after the build role shipped, so the help told
     // adopters the build was not covered when it was. "Available now", below, is derived.
-    "  sentinel --init --preset react                     # adopt every available role (see below)",
+    "  sentinel --init --preset react                     # a new module: adopt every available role",
+    "  sentinel --init                                    # an adopted module: re-init the roles it has",
     "  sentinel --init --typescript --preset react       # set up the current module + workspace",
     "  sentinel --run --typescript -- --noImplicitAny     # ask the tool a question of your own"
   ].join("\n")
@@ -945,6 +977,7 @@ async function main() {
     cwd,
     targets,
     targetsExplicit,
+    allTargets: Boolean(opts.all),
     preset,
     toolArgs,
     maxDiagnostics,