@hublo/sentinel 1.4.0-alpha.15 → 1.4.0-alpha.17

package/dist/bin/sentinel.js

@@ -16,7 +16,7 @@ import {
   registerAdapters,
   resolve,
   resolveBin
-} from "../chunk-BIDHDUUZ.js";
+} from "../chunk-I64KRL6O.js";
 import {
   WORKSPACE_ROOT_MARKER,
   ensureWorkspacePrep,

package/dist/{chunk-BIDHDUUZ.js → chunk-I64KRL6O.js}

@@ -6990,6 +6990,78 @@ function rewriteMockFactoryDefault(source, program, defaultImported) {
   };
 }
 
+// src/roles/test/codemod/mock-promise-resolve.ts
+var MOCK_FACTORY = /* @__PURE__ */ new Set(["fn", "spyOn"]);
+function isMockFactory(source, node) {
+  if (node.type !== "CallExpression") return false;
+  const callee = node.callee;
+  if (callee?.type !== "MemberExpression") return false;
+  const object = callee.object;
+  const property = callee.property;
+  if (object?.type !== "Identifier" || property?.type !== "Identifier") return false;
+  const runner = source.slice(object.start, object.end);
+  const method = source.slice(property.start, property.end);
+  return (runner === "jest" || runner === "vi") && MOCK_FACTORY.has(method);
+}
+function resolvedValue(source, executor) {
+  if (executor.type !== "ArrowFunctionExpression" && executor.type !== "FunctionExpression") {
+    return void 0;
+  }
+  const params = executor.params;
+  if (params?.length !== 1) return void 0;
+  const parameter = params[0];
+  if (parameter.type !== "Identifier") return void 0;
+  const resolveName = source.slice(parameter.start, parameter.end);
+  const body = executor.body;
+  if (body === void 0) return void 0;
+  let call;
+  if (body.type === "BlockStatement") {
+    const statements = body.body;
+    if (statements?.length !== 1) return void 0;
+    const only = statements[0];
+    if (only.type !== "ExpressionStatement") return void 0;
+    call = only.expression;
+  } else {
+    call = body;
+  }
+  if (call?.type !== "CallExpression") return void 0;
+  const callee = call.callee;
+  if (callee?.type !== "Identifier") return void 0;
+  if (source.slice(callee.start, callee.end) !== resolveName) return void 0;
+  const args = call.arguments;
+  if (args?.length !== 1) return void 0;
+  return args[0];
+}
+function rewriteMockPromiseResolve(source, program) {
+  const edits = [];
+  walk(program, (node) => {
+    if (!isMockFactory(source, node)) return;
+    for (const argument of node.arguments ?? []) {
+      walk(argument, (inner) => {
+        if (inner.type !== "NewExpression") return;
+        const callee = inner.callee;
+        if (callee?.type !== "Identifier") return;
+        if (source.slice(callee.start, callee.end) !== "Promise") return;
+        if ((inner.typeArguments ?? inner.typeParameters) !== void 0) return;
+        const executors = inner.arguments ?? [];
+        if (executors.length !== 1) return;
+        const value = resolvedValue(source, executors[0]);
+        if (value === void 0) return;
+        edits.push({
+          start: inner.start,
+          end: inner.end,
+          text: `Promise.resolve(${source.slice(value.start, value.end)})`
+        });
+      });
+    }
+  });
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return { source: result, rewritten: edits.length };
+}
+
 // src/roles/test/codemod/propagate-await.ts
 import { parseSync as parseSync5 } from "oxc-parser";
 var FUNCTIONS3 = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
@@ -7381,7 +7453,10 @@ function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new
   const afterEmpty = parse2(fileName, emptyImplementations.source);
   if (afterEmpty === void 0) return unparsable("empty mock implementation");
   const hooks = rewriteHookReturnValue(emptyImplementations.source, afterEmpty);
-  const awaited = propagateAwait(fileName, hooks.source, original, asyncHelpers);
+  const afterHooks = parse2(fileName, hooks.source);
+  if (afterHooks === void 0) return unparsable("hook return value");
+  const promises = rewriteMockPromiseResolve(hooks.source, afterHooks);
+  const awaited = propagateAwait(fileName, promises.source, original, asyncHelpers);
   const program = parse2(fileName, awaited.source);
   if (program === void 0) return unparsable("hook body");
   const hoist = hoistCapturedBindings(
@@ -8847,6 +8922,7 @@ function resolveVitest(cwd) {
   const fromModule = resolveBin(cwd, "vitest");
   return fromModule !== void 0 ? { bin: fromModule, origin: "module" } : { bin: void 0, origin: "module" };
 }
+var FORMATTABLE = /\.(m|c)?(j|t)sx?$|\.json$/;
 var VitestAdapter = class extends BaseAdapter {
   target = "test";
   runner = "vitest";
@@ -8885,21 +8961,48 @@ var VitestAdapter = class extends BaseAdapter {
    * MODULE's decision: `printWidth` lives in its own config, and 12 modules already set their
    * own. Guessing it is how a tool starts owning a setting it does not own.
    *
-   * The same delegation the build role asks a human to do by hand, done. A module that has not
-   * adopted the format role has no formatter to invoke, and this says nothing rather than
-   * choosing one for it.
+   * The same delegation the build role asks a human to do by hand, done.
+   *
+   * ## ⚠️ Two boundaries, both learned by crossing them
+   *
+   * ### Only a module that has a formatter CONFIG
+   *
+   * The question is not "can a formatter be found". It always can: sentinel depends on oxfmt and
+   * ships the binary, so `resolveOxfmt` falls back to its own install and never returns undefined
+   * once sentinel is installed. Asking it that way meant a module with no oxfmt config was
+   * formatted with oxfmt's DEFAULTS, which is a style nobody here chose.
+   *
+   * So the CONFIG is read. A module that wrote its own `.oxfmtrc.json` without adopting the role
+   * has still stated a style, and running it is delegation; running oxfmt with no config is us
+   * choosing one.
+   *
+   * Measured on `apps/nest/microservices/institution`, which has not adopted format and whose lint
+   * forbids semicolons: `institution:lint` went from green to failing, thousands of `semi`, on a
+   * module whose 2958 tests pass. So the adoption is read, not the binary.
+   *
+   * ### Only the files this just WROTE
+   *
+   * `--write .` is a whole-directory pass, and that is not a tidy-up. Same measurement: 1813 files
+   * changed, 47333 insertions, 55506 deletions, in a module whose migration touched 268. A
+   * migration diff is read by a person.
+   *
+   * A module that has not adopted format keeps what was written exactly as written, and is told so.
+   * The codemod rewrites tokens in place, so those files keep the shape they already had.
    */
   async afterInit(ctx) {
-    const oxfmt = resolveOxfmt(ctx.cwd);
-    if (oxfmt === void 0) {
+    const written = (ctx.written ?? []).filter((file) => FORMATTABLE.test(file));
+    if (written.length === 0) return Promise.resolve();
+    if (readFormatAdoption(ctx.cwd).configFile === null) {
       this.say(
-        `no formatter adopted here, so what was written keeps the shape it was written in. Run your own formatter over it before committing.`
+        `no formatter configured here, so the ${written.length} file(s) this wrote keep the shape they were written in. Run your own formatter over them before committing.`
       );
       return Promise.resolve();
     }
-    const pass = spawnSync5(oxfmt, ["--write", "."], { cwd: ctx.cwd, encoding: "utf8" });
+    const oxfmt = resolveOxfmt(ctx.cwd);
+    if (oxfmt === void 0) return Promise.resolve();
+    const pass = spawnSync5(oxfmt, ["--write", ...written], { cwd: ctx.cwd, encoding: "utf8" });
     this.say(
-      pass.status === 0 ? `formatted what this wrote with the module's own oxfmt config, so its \`--run --format\` passes on files it did not write itself.` : (
+      pass.status === 0 ? `formatted the ${written.length} file(s) this wrote with the module's own oxfmt config, so its \`--run --format\` passes on files it did not write itself.` : (
         // Adoption SUCCEEDED; only the tidy-up did not. Failing here would revert a migration
         // over a formatting pass, which is the wrong trade.
         `the module's formatter could not run over what this wrote (${pass.status ?? "no exit code"}). Adoption itself is applied; run \`sentinel --run --format --fix\` before committing.`
@@ -10134,9 +10237,11 @@ async function dispatch(opts) {
       fix: false
     });
   }
+  const written = [];
   for (const change of applyPlan(opts.cwd, plan4)) {
     process.stderr.write(`  ${change.deleted ? "removed" : "wrote"} ${change.path}
 `);
+    if (!change.deleted) written.push(change.path);
   }
   for (const note of plan4.notes ?? []) process.stderr.write(`  ${note}
 `);
@@ -10148,7 +10253,8 @@ async function dispatch(opts) {
       cwd: opts.cwd,
       preset,
       ci: false,
-      fix: true
+      fix: true,
+      written
     });
   }
   return 0;

package/dist/index.d.ts

@@ -66,6 +66,16 @@ interface RunContext {
     ci: boolean;
     /** Apply auto-fixes where the tool supports it. */
     fix: boolean;
+    /**
+     * The files `--init` just wrote, relative to `cwd`, for an `afterInit` that tidies up after
+     * itself.
+     *
+     * ⚠️ It exists because the alternative is a whole-directory pass, and that is not a tidy-up.
+     * Measured on `apps/nest/microservices/institution`: an `afterInit` running its formatter over
+     * `.` reformatted 1813 files, 47333 insertions and 55506 deletions, in a module whose migration
+     * touched 268. Only set by the `--init` path, so an adapter must treat it as optional.
+     */
+    written?: string[];
     /**
      * Cap on the number of structured diagnostics a `--report` embeds per module (the
      * full count still lives in `errors`, so nothing is hidden silently). `0` means no

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   registerAdapters,
   resolve,
   setDefaultRunner
-} from "./chunk-BIDHDUUZ.js";
+} from "./chunk-I64KRL6O.js";
 import "./chunk-WLFE5RUU.js";
 export {
   BaseAdapter,

package/package.json

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