@hublo/sentinel 1.2.0-alpha.27 → 1.2.0-alpha.29

package/dist/bin/sentinel.js

@@ -22,7 +22,7 @@ import {
   registerAdapters,
   resolve,
   resolveBin
-} from "../chunk-LNSAUFIM.js";
+} from "../chunk-37Y7RALA.js";
 
 // bin/sentinel.ts
 import { program } from "commander";

package/dist/{chunk-LNSAUFIM.js → chunk-37Y7RALA.js}

@@ -298,6 +298,19 @@ function manifestOperation(cwd, scripts) {
   };
 }
 
+// src/core/config/project-json.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+function projectTargets(cwd) {
+  const path = join4(cwd, "project.json");
+  if (!existsSync4(path)) return void 0;
+  try {
+    return JSON.parse(readFileSync4(path, "utf8")).targets;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/roles/build/presets/requirements.json
 var requirements_default = {
   svelte: {
@@ -413,19 +426,6 @@ var SENTINEL_OWNED_BUILD_PACKAGES = OWNED_PACKAGES.map(
   (entry) => entry.package
 );
 
-// src/roles/build/project-json.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
-function projectTargets(cwd) {
-  const path = join4(cwd, "project.json");
-  if (!existsSync4(path)) return void 0;
-  try {
-    return JSON.parse(readFileSync4(path, "utf8")).targets;
-  } catch {
-    return void 0;
-  }
-}
-
 // src/roles/build/adoption-drift.ts
 function buildAdoptionDrift(cwd) {
   const drift = [];
@@ -5582,12 +5582,356 @@ function registerLint() {
   setDefaultRunner("lint", "oxlint");
 }
 
-// src/roles/typescript/adapters/tsc/tsc.adapter.ts
+// src/roles/test/adapters/vitest/vitest.adapter.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync24 } from "fs";
-import { createRequire as createRequire4 } from "module";
+import { existsSync as existsSync26 } from "fs";
 import { join as join30 } from "path";
 
+// src/roles/test/presets/toolchain.json
+var toolchain_default2 = {
+  $comment: "The test toolchain sentinel owns. Same shape and same rule as the build one: a single table drives what `--init` removes from a module's package.json, which import specifiers move, and the name each default import is re-exported under, so the three cannot disagree.",
+  owned: [
+    {
+      package: "vitest",
+      specifier: "vitest/config",
+      named: ["defineConfig", "mergeConfig"],
+      types: ["ConfigEnv", "TestUserConfig", "ViteUserConfig"],
+      why: "the runner itself, declared at the workspace ROOT today, which is what stops a module being testable on its own. Note the package is `vitest` and the specifier is `vitest/config`: the same split as nitro on the build side, and the reason one table holds both."
+    },
+    {
+      package: "vite",
+      specifier: "vite",
+      named: ["loadEnv"],
+      why: "`loadEnv` has no equivalent in `vitest/config`, and two of the six configs import it from vite to build their test env. Re-exported here rather than claimed: the BUILD role owns the `vite` package, and two roles owning one package is how a version conflict gets written down twice."
+    }
+  ]
+};
+
+// src/roles/test/preset-data.ts
+var OWNED_TEST_PACKAGES = toolchain_default2.owned;
+
+// src/roles/test/config-policy.ts
+var TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/react";
+var TEST_CONFIG_FILES = [
+  "vitest.config.ts",
+  "vitest.config.mts",
+  "vitest.config.js",
+  "vitest.config.mjs"
+];
+var TEST_OWNED_PACKAGES = OWNED_TEST_PACKAGES;
+var SENTINEL_OWNED_TEST_PACKAGES = TEST_OWNED_PACKAGES.filter(
+  (entry) => entry.package !== "vite"
+).map((entry) => entry.package);
+var TEST_TOOLCHAIN = {
+  presetSpecifier: TEST_PRESET_SPECIFIER,
+  owned: TEST_OWNED_PACKAGES
+};
+var TEST_SCRIPT_NAME = "test";
+var SENTINEL_TEST_COMMAND = "sentinel --run --test --";
+var VITEST_INVOCATION = /(^|&&\s*|\|\|\s*|;\s*)(?:npx\s+|pnpm\s+(?:exec\s+|dlx\s+)?)?vitest\b([^&|;]*)/g;
+function rewriteVitestScript(command) {
+  return command.replace(VITEST_INVOCATION, (_match, lead, tail) => {
+    const args = tail.trim().split(/\s+/).filter(Boolean);
+    const oneShot = args[0] === "run" || args.includes("--run");
+    const rest = args.filter((arg, index) => !(index === 0 && arg === "run") && arg !== "--run");
+    const passthrough = oneShot ? rest : ["--watch", ...rest];
+    const suffix = passthrough.length > 0 ? ` -- ${passthrough.join(" ")}` : "";
+    const trailing = /\s$/.test(tail) ? " " : "";
+    return `${lead}sentinel --run --test${suffix}${trailing}`;
+  });
+}
+function testTarget(options) {
+  const { configFiles, outputs } = options;
+  const cached = outputs !== void 0 && outputs.length > 0;
+  return {
+    [TEST_SCRIPT_NAME]: {
+      cache: cached,
+      inputs: ["default", "^default", ...configFiles.map((name) => `{projectRoot}/${name}`)],
+      ...cached ? { outputs: [...outputs] } : {}
+    }
+  };
+}
+
+// src/roles/test/read-adoption.ts
+import { existsSync as existsSync25, readFileSync as readFileSync23, readdirSync as readdirSync3 } from "fs";
+import { join as join29 } from "path";
+var JEST_CONFIG_FILES = [
+  "jest.config.ts",
+  "jest.config.js",
+  "jest.prisma.config.ts",
+  "jest.functional.config.ts",
+  "jest.integration-config.ts"
+];
+function testConfigFile(cwd) {
+  return TEST_CONFIG_FILES.find((name) => existsSync25(join29(cwd, name)));
+}
+function jestConfigFiles(cwd) {
+  return JEST_CONFIG_FILES.filter((name) => existsSync25(join29(cwd, name)));
+}
+function rootJestConfigFiles(cwd) {
+  const root = findWorkspaceRoot(cwd);
+  if (root === void 0 || root === cwd) return [];
+  return JEST_CONFIG_FILES.filter((name) => existsSync25(join29(root, name)));
+}
+var TEST_FILE = /[.-](spec|test)\.[cm]?[jt]sx?$/;
+var NOT_WALKED = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git", ".nx", ".turbo"]);
+function hasTestFiles(cwd) {
+  const stack = [cwd];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync3(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!NOT_WALKED.has(entry.name)) stack.push(join29(dir, entry.name));
+      } else if (TEST_FILE.test(entry.name)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function readTestConfigSource(cwd, fileName) {
+  try {
+    return readFileSync23(join29(cwd, fileName), "utf8");
+  } catch {
+    return "";
+  }
+}
+function importsPreset2(source) {
+  const escaped = TEST_PRESET_SPECIFIER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(String.raw`(?:from|import)\s*\(?\s*['"]${escaped}['"]`).test(source);
+}
+function readTestAdoption(cwd) {
+  const manifest = readProjectPackageJson(cwd);
+  const jestConfigs = jestConfigFiles(cwd);
+  const configFile = testConfigFile(cwd);
+  const declared = { ...manifest.dependencies, ...manifest.devDependencies };
+  const ownDeclarations = ["vitest", "jest", "@nx/jest", "jest-mock-extended", "@swc/jest"].filter((name) => declared[name] !== void 0).map((name) => ({ name, version: declared[name] }));
+  if (configFile === void 0) {
+    const hasTests = hasTestFiles(cwd);
+    const inheritsRootConfig = hasTests && jestConfigs.length === 0 && rootJestConfigFiles(cwd).length > 0;
+    return {
+      configFile: null,
+      preset: null,
+      adopted: false,
+      conformant: false,
+      drift: [],
+      unreadable: null,
+      state: hasTests ? "jest" : "no-tests",
+      runner: hasTests ? "jest" : "none",
+      jestConfigs,
+      inheritsRootConfig,
+      ownDeclarations
+    };
+  }
+  const source = readTestConfigSource(cwd, configFile);
+  if (source === "") {
+    return {
+      configFile,
+      preset: null,
+      adopted: false,
+      conformant: false,
+      drift: [],
+      unreadable: `${configFile} could not be read`,
+      state: "vitest-own-toolchain",
+      runner: "vitest",
+      jestConfigs,
+      inheritsRootConfig: false,
+      // it has a config of its own, readable or not
+      ownDeclarations
+    };
+  }
+  const adopted = importsPreset2(source);
+  const script = moduleScripts(cwd)["test"];
+  return {
+    configFile,
+    preset: adopted ? "react" : null,
+    adopted,
+    conformant: adopted && script !== void 0 && jestConfigs.length === 0,
+    drift: [],
+    unreadable: null,
+    state: adopted ? "adopted" : "vitest-own-toolchain",
+    runner: "vitest",
+    jestConfigs,
+    inheritsRootConfig: false,
+    // local always wins: this module is out of the root's reach
+    ownDeclarations
+  };
+}
+
+// src/roles/test/plan.ts
+function ownedTestDependencies(cwd, declared) {
+  return declared.filter((entry) => SENTINEL_OWNED_TEST_PACKAGES.includes(entry.name)).flatMap((entry) => [
+    ["dependencies", entry.name],
+    ["devDependencies", entry.name]
+  ]).filter(([section]) => section !== void 0);
+}
+function plan3(context) {
+  const configFile = testConfigFile(context.cwd);
+  const adoption = readTestAdoption(context.cwd);
+  if (configFile === void 0) {
+    return {
+      operations: [],
+      skipped: adoption.state === "jest" ? `this module tests with jest (${adoption.jestConfigs.join(", ")}). Migrating it moves its test FILES as well as its config, which is the next step of this role and not this one.` : `this module has no test config and no test files, so there is nothing to point at sentinel. What it needs is its jest leftovers removed, which is a cleanup rather than an adoption.`
+    };
+  }
+  const operations = [];
+  const notes = [];
+  const rewrite = rewriteToolchainImports(
+    TEST_TOOLCHAIN,
+    readTestConfigSource(context.cwd, configFile),
+    configFile
+  );
+  if (rewrite.kind === "blocked") {
+    return {
+      operations: [],
+      skipped: `${configFile} could not be pointed at sentinel, so nothing was written: ${rewrite.why}. Nothing here is broken; this needs a look before the role applies.`
+    };
+  }
+  if (rewrite.kind === "rewritten") {
+    operations.push({ kind: "write", path: configFile, contents: rewrite.source });
+    notes.push(
+      `${configFile} now imports ${rewrite.moved.join(", ")} from sentinel. Only the import lines changed: every alias, setup file, timeout and coverage path is untouched, so this suite runs what it ran before.`
+    );
+  }
+  const existing = projectTargets(context.cwd)?.[TEST_SCRIPT_NAME];
+  const outputs = existing?.outputs ?? [];
+  if (outputs.length === 0) {
+    notes.push(
+      `this target declares no \`outputs\`, so it is left UNCACHED. Caching a run that restores nothing is the defect where nx reports a hit and the coverage directory is empty; if this module writes coverage, declare where and the target can cache.`
+    );
+  }
+  const siblingScripts = {};
+  for (const [name, command] of Object.entries(moduleScripts(context.cwd))) {
+    if (name === TEST_SCRIPT_NAME || typeof command !== "string") continue;
+    const rewritten = rewriteVitestScript(command);
+    if (rewritten !== command) siblingScripts[name] = rewritten;
+  }
+  if (Object.keys(siblingScripts).length > 0) {
+    notes.push(
+      `rewrote ${Object.keys(siblingScripts).join(", ")} to run through sentinel: they called vitest directly, and the dependency they relied on is removed below. A watch script keeps watching, through \`-- --watch\`.`
+    );
+  }
+  operations.push(
+    manifestOperation(context.cwd, {
+      [TEST_SCRIPT_NAME]: SENTINEL_TEST_COMMAND,
+      ...siblingScripts
+    })
+  );
+  operations.push(
+    ...nxTargetOperations({
+      cwd: context.cwd,
+      targets: testTarget({ configFiles: [configFile], outputs })
+    })
+  );
+  const owned = ownedTestDependencies(context.cwd, adoption.ownDeclarations);
+  if (owned.length > 0) {
+    operations.push({ kind: "remove-json-keys", path: "package.json", keys: owned });
+    notes.push(
+      `removed ${[...new Set(owned.map(([, name]) => name))].join(", ")} from this module: sentinel owns the runner now, and two copies of Vitest in one run give the plugins a different Vite than the one running them.`
+    );
+  }
+  if (adoption.jestConfigs.length > 0) {
+    notes.push(
+      `${adoption.jestConfigs.join(", ")} is still here beside the Vitest config. It is not this step's to delete, since something may still run it, but the workspace cannot drop jest while it exists.`
+    );
+  }
+  return { operations, notes };
+}
+
+// src/roles/test/adapters/vitest/vitest.adapter.ts
+function resolveVitest(cwd) {
+  const fromSentinel = join30(
+    new URL("../../../../../node_modules/.bin/vitest", import.meta.url).pathname
+  );
+  if (existsSync26(fromSentinel)) return { bin: fromSentinel, origin: "sentinel" };
+  const fromModule = join30(cwd, "node_modules", ".bin", "vitest");
+  return existsSync26(fromModule) ? { bin: fromModule, origin: "module" } : { bin: void 0, origin: "module" };
+}
+var VitestAdapter = class extends BaseAdapter {
+  target = "test";
+  runner = "vitest";
+  appliesTo(_preset) {
+    return true;
+  }
+  plan(context) {
+    return plan3(context);
+  }
+  async status(ctx) {
+    return Promise.resolve(readTestAdoption(ctx.cwd));
+  }
+  async inspect(ctx) {
+    const adoption = readTestAdoption(ctx.cwd);
+    return Promise.resolve({
+      state: adoption.state,
+      runner: adoption.runner,
+      configFile: adoption.configFile,
+      jestConfigs: adoption.jestConfigs,
+      adopted: adoption.adopted,
+      conformant: adoption.conformant,
+      drift: adoption.drift,
+      unreadable: adoption.unreadable
+    });
+  }
+  /**
+   * Run the module's tests.
+   *
+   * A module that has not adopted is reported and PASSES, the stance every role takes: `--run`
+   * with no named target sweeps the workspace, so failing here would exit non-zero on the 107
+   * modules still on jest, which says nothing anyone can act on.
+   */
+  async run(ctx) {
+    const adoption = readTestAdoption(ctx.cwd);
+    if (!adoption.adopted) {
+      this.say(
+        adoption.state === "jest" ? `this module tests with jest (${adoption.jestConfigs.join(", ")}); run \`sentinel --init --test\` to migrate it.` : adoption.state === "no-tests" ? `this module has no tests.` : `no sentinel preset in this module's Vitest config; run \`sentinel --init --test\` to adopt.`
+      );
+      return Promise.resolve({ ok: true, code: 0 });
+    }
+    const { bin, origin } = resolveVitest(ctx.cwd);
+    if (bin === void 0) {
+      this.say(`could not find the vitest binary. Run \`pnpm install\` in the module.`);
+      return Promise.resolve({ ok: false, code: 1 });
+    }
+    if (origin === "module") {
+      this.say(
+        `using the MODULE's vitest, not sentinel's. An adopted config gets its plugins from sentinel, and two copies fail in ways that never mention a version. Remove vitest from this module's package.json.`
+      );
+    }
+    const { options, paths } = splitToolArgs(ctx.cwd, ctx.toolArgs, { valueFlags: [] });
+    const watching = options.includes("--watch") || options.includes("-w");
+    const argv = watching ? [...options, ...paths] : ["run", ...options, ...paths];
+    const result = spawnSync5(bin, argv, { cwd: ctx.cwd, stdio: "inherit" });
+    if (result.error) {
+      this.say(`could not run vitest (${result.error.message})`);
+      return Promise.resolve({ ok: false, code: 1 });
+    }
+    const code = result.status ?? 1;
+    return Promise.resolve({ ok: code === 0, code });
+  }
+  say(message) {
+    process.stderr.write(`sentinel test(vitest): ${message}
+`);
+  }
+};
+
+// src/roles/test/register.ts
+function registerTest() {
+  register(new VitestAdapter());
+  setDefaultRunner("test", "vitest");
+}
+
+// src/roles/typescript/adapters/tsc/tsc.adapter.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import { existsSync as existsSync27, readFileSync as readFileSync25 } from "fs";
+import { createRequire as createRequire4 } from "module";
+import { join as join32 } from "path";
+
 // src/roles/typescript/presets/nest.json
 var nest_default2 = {
   compilerOptions: {
@@ -5767,8 +6111,8 @@ function readTsconfigAdoption(cwd) {
 }
 
 // src/roles/typescript/adapters/tsc/plan.ts
-import { readFileSync as readFileSync23 } from "fs";
-import { join as join29 } from "path";
+import { readFileSync as readFileSync24 } from "fs";
+import { join as join31 } from "path";
 
 // src/roles/typescript/typecheck-script.ts
 var SENTINEL_TYPECHECK_COMMAND = "sentinel --run --typescript";
@@ -5861,7 +6205,7 @@ function planAdoption(context) {
     };
   }
   const existing = parseJsonc(
-    readFileSync23(join29(context.cwd, target.path), "utf8"),
+    readFileSync24(join31(context.cwd, target.path), "utf8"),
     target.path
   );
   const extendsChain = composeExtends(existing.extends, preset);
@@ -5999,7 +6343,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     let chain;
     try {
       const parsed = parseJsonc(
-        readFileSync24(join30(cwd, target.path), "utf8"),
+        readFileSync25(join32(cwd, target.path), "utf8"),
         target.path
       );
       chain = parsed.extends;
@@ -6012,7 +6356,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     );
     if (preset === void 0) return void 0;
     try {
-      createRequire4(join30(cwd, "noop.js")).resolve(preset);
+      createRequire4(join32(cwd, "noop.js")).resolve(preset);
       return void 0;
     } catch {
       return preset;
@@ -6053,7 +6397,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
       return { ok: false, code: 1 };
     }
     if (options.length > 0) return this.runWithOptions(ctx, tsc, config);
-    const result = spawnSync5(tsc, ["-b", config], { cwd: ctx.cwd, stdio: "inherit" });
+    const result = spawnSync6(tsc, ["-b", config], { cwd: ctx.cwd, stdio: "inherit" });
     if (result.error) {
       process.stderr.write(
         `sentinel typescript(tsc): could not run tsc (${result.error.message}); is TypeScript installed in the module?
@@ -6088,7 +6432,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     let worst = 0;
     for (const project of this.referencedProjects(ctx.cwd, config)) {
       const args = ["-p", project, "--noEmit", "--composite", "false", ...ctx.toolArgs ?? []];
-      const result = spawnSync5(tsc, args, { cwd: ctx.cwd, stdio: "inherit" });
+      const result = spawnSync6(tsc, args, { cwd: ctx.cwd, stdio: "inherit" });
       if (result.error) {
         process.stderr.write(
           `sentinel typescript(tsc): could not run tsc (${result.error.message}); is TypeScript installed in the module?
@@ -6108,7 +6452,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
   referencedProjects(cwd, config) {
     try {
       const parsed = parseJsonc(
-        readFileSync24(join30(cwd, config), "utf8"),
+        readFileSync25(join32(cwd, config), "utf8"),
         config
       );
       const referenced = (parsed.references ?? []).map((reference) => reference.path).filter((path) => typeof path === "string" && path.length > 0);
@@ -6124,7 +6468,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
    * check.
    */
   typecheckTarget(cwd) {
-    if (existsSync25(join30(cwd, "tsconfig.json"))) return "tsconfig.json";
+    if (existsSync27(join32(cwd, "tsconfig.json"))) return "tsconfig.json";
     const target = resolveTsconfigTarget(cwd);
     return target.reason === "none" ? null : target.path;
   }
@@ -6177,7 +6521,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
       return { ok: true, code: 0, metrics: _TscAdapter.NOTHING_TO_REPORT };
     }
     const tsc = resolveBin(ctx.cwd, "tsc") ?? "tsc";
-    const result = spawnSync5(tsc, ["-b", config], { cwd: ctx.cwd, encoding: "utf8" });
+    const result = spawnSync6(tsc, ["-b", config], { cwd: ctx.cwd, encoding: "utf8" });
     if (result.error) {
       process.stderr.write(
         `sentinel typescript(tsc): could not run tsc (${result.error.message}); is TypeScript installed in the module?
@@ -6220,7 +6564,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
    * errors in the output mean the rule must be on.
    */
   noImplicitAnyEnabled(cwd, tsc, config, mainOutput) {
-    const shown = spawnSync5(tsc, ["-p", config, "--showConfig"], { cwd, encoding: "utf8" });
+    const shown = spawnSync6(tsc, ["-p", config, "--showConfig"], { cwd, encoding: "utf8" });
     if (shown.status === 0 && shown.stdout) {
       try {
         const co = parseJsonc(
@@ -6247,6 +6591,7 @@ function registerAdapters() {
   registerLint();
   registerFormat();
   registerBuild();
+  registerTest();
 }
 
 // src/core/detect-framework.ts
@@ -6328,7 +6673,7 @@ function replaceLines(current, replacements) {
 }
 
 // src/core/apply-plan.ts
-import { existsSync as existsSync26, readFileSync as readFileSync25, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync26, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve4, sep } from "path";
 import { applyEdits, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
 
@@ -6347,7 +6692,7 @@ function resolveWithinRoot(cwd, relativePath) {
   return absolutePath;
 }
 function readIfExists(absolutePath) {
-  return existsSync26(absolutePath) ? readFileSync25(absolutePath, "utf8") : void 0;
+  return existsSync28(absolutePath) ? readFileSync26(absolutePath, "utf8") : void 0;
 }
 function* leaves(value, prefix = []) {
   for (const [key, keyValue] of Object.entries(value)) {
@@ -6428,9 +6773,9 @@ function applyOperationTo(current, operation) {
     }
   }
 }
-function preparePlan(cwd, plan3) {
+function preparePlan(cwd, plan4) {
   const prepared = /* @__PURE__ */ new Map();
-  for (const operation of plan3.operations) {
+  for (const operation of plan4.operations) {
     const absolutePath = resolveWithinRoot(cwd, operation.path);
     const existing = prepared.get(operation.path);
     const before = existing?.before ?? readIfExists(absolutePath) ?? "";
@@ -6452,8 +6797,8 @@ function writeFileAtomic(absolutePath, contents) {
   writeFileSync4(tempPath, contents);
   renameSync(tempPath, absolutePath);
 }
-function applyPlan(cwd, plan3) {
-  const changed = preparePlan(cwd, plan3).filter((file) => file.before !== file.after);
+function applyPlan(cwd, plan4) {
+  const changed = preparePlan(cwd, plan4).filter((file) => file.before !== file.after);
   for (const file of changed) {
     if (file.deleted) {
       rmSync3(file.absolutePath, { force: true });
@@ -6465,8 +6810,8 @@ function applyPlan(cwd, plan3) {
 }
 
 // src/core/config/preset-evidence.ts
-import { existsSync as existsSync27, readdirSync as readdirSync3, readFileSync as readFileSync26 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync29, readdirSync as readdirSync4, readFileSync as readFileSync27 } from "fs";
+import { join as join33 } from "path";
 var PATH_SIGNALS = [
   {
     preset: "nest",
@@ -6480,11 +6825,11 @@ var DEPENDENCY_SIGNALS = [
   { preset: "nest", pattern: /^@nestjs\// }
 ];
 function dependencyNames(cwd) {
-  const path = join31(cwd, "package.json");
-  if (!existsSync27(path)) return [];
+  const path = join33(cwd, "package.json");
+  if (!existsSync29(path)) return [];
   try {
     const manifest = parseJsonc(
-      readFileSync26(path, "utf8"),
+      readFileSync27(path, "utf8"),
       path
     );
     return [
@@ -6498,7 +6843,7 @@ function dependencyNames(cwd) {
 function declaresJsx(cwd) {
   let entries;
   try {
-    entries = readdirSync3(cwd).filter(
+    entries = readdirSync4(cwd).filter(
       (name) => name.startsWith("tsconfig") && name.endsWith(".json")
     );
   } catch {
@@ -6507,7 +6852,7 @@ function declaresJsx(cwd) {
   for (const name of entries) {
     try {
       const config = parseJsonc(
-        readFileSync26(join31(cwd, name), "utf8"),
+        readFileSync27(join33(cwd, name), "utf8"),
         name
       );
       if (config.compilerOptions?.jsx !== void 0) return true;
@@ -6558,14 +6903,14 @@ function resolveFlavour(opts) {
   }
   return detection.preset;
 }
-function previewPlan(opts, plan3) {
-  const changed = preparePlan(opts.cwd, plan3).filter((file) => file.before !== file.after);
+function previewPlan(opts, plan4) {
+  const changed = preparePlan(opts.cwd, plan4).filter((file) => file.before !== file.after);
   if (opts.json) {
     process.stdout.write(
       JSON.stringify(
         {
           dryRun: true,
-          notes: plan3.notes ?? [],
+          notes: plan4.notes ?? [],
           files: changed.map(({ path, before, after, deleted }) => ({
             path,
             action: deleted ? "delete" : before.length === 0 ? "create" : "update",
@@ -6580,7 +6925,7 @@ function previewPlan(opts, plan3) {
     return 0;
   }
   process.stderr.write("  dry run: no files written\n");
-  for (const note of plan3.notes ?? []) process.stderr.write(`  ${note}
+  for (const note of plan4.notes ?? []) process.stderr.write(`  ${note}
 `);
   if (changed.length === 0) {
     process.stderr.write("  nothing to change\n");
@@ -6624,25 +6969,25 @@ async function dispatch(opts) {
     }
   }
   const context = { cwd: opts.cwd, preset: effective };
-  const plan3 = await adapter.plan(context);
-  if (plan3.blocked) {
-    process.stderr.write(`sentinel (${opts.target}): ${plan3.blocked}
+  const plan4 = await adapter.plan(context);
+  if (plan4.blocked) {
+    process.stderr.write(`sentinel (${opts.target}): ${plan4.blocked}
 `);
     return 1;
   }
-  if (plan3.skipped) {
-    process.stderr.write(`  ${palette(process.stderr).dim(`${opts.target}: ${plan3.skipped}`)}
+  if (plan4.skipped) {
+    process.stderr.write(`  ${palette(process.stderr).dim(`${opts.target}: ${plan4.skipped}`)}
 `);
     return 0;
   }
   if (opts.dryRun) {
-    return previewPlan(opts, plan3);
+    return previewPlan(opts, plan4);
   }
-  for (const change of applyPlan(opts.cwd, plan3)) {
+  for (const change of applyPlan(opts.cwd, plan4)) {
     process.stderr.write(`  ${change.deleted ? "removed" : "wrote"} ${change.path}
 `);
   }
-  for (const note of plan3.notes ?? []) process.stderr.write(`  ${note}
+  for (const note of plan4.notes ?? []) process.stderr.write(`  ${note}
 `);
   if (adapter.afterInit) {
     process.stderr.write(`  fixing what ${opts.target} can fix automatically...
@@ -6687,4 +7032,4 @@ export {
   detectFramework,
   dispatch
 };
-//# sourceMappingURL=chunk-LNSAUFIM.js.map
+//# sourceMappingURL=chunk-37Y7RALA.js.map

package/dist/index.js

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

package/package.json

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