@hublo/sentinel 1.0.2 → 1.1.0-alpha.2

package/dist/chunk-SK6E5EM4.js

@@ -1,818 +0,0 @@
-// src/core/registry.ts
-var adapters = [];
-var defaultRunner = {
-  // Filled in by tool branches, e.g. lint: 'eslint', typescript: 'tsc'.
-};
-function register(adapter) {
-  adapters.push(adapter);
-}
-function setDefaultRunner(target, runner) {
-  defaultRunner[target] = runner;
-}
-function all() {
-  return adapters;
-}
-function availableTargets() {
-  return [...new Set(adapters.map((a) => a.target))];
-}
-function resolve(target, flavour, runner) {
-  const forTarget = adapters.filter((a) => a.target === target);
-  if (forTarget.length === 0) {
-    throw new Error(
-      `No adapter registered for target "${target}" yet (it ships in a later ticket).`
-    );
-  }
-  const candidates = flavour ? forTarget.filter((a) => a.appliesTo(flavour)) : forTarget;
-  if (candidates.length === 0) {
-    throw new Error(`No adapter for target "${target}" handles flavour "${flavour}".`);
-  }
-  const wanted = runner ?? defaultRunner[target];
-  const available = candidates.map((a) => a.runner).join(", ");
-  if (!wanted) {
-    const [first, ...rest] = candidates;
-    if (first && rest.length === 0) return first;
-    throw new Error(
-      `Multiple runners for target "${target}" (${available}); pass --runner or set a default.`
-    );
-  }
-  const matching = candidates.filter((a) => a.runner === wanted);
-  if (matching.length === 0) {
-    throw new Error(
-      `No runner "${wanted}" for target "${target}" (flavour "${flavour}"). Available: ${available}.`
-    );
-  }
-  if (matching.length > 1) {
-    throw new Error(
-      `Ambiguous: ${matching.length} adapters claim target "${target}", runner "${wanted}", flavour "${flavour}".`
-    );
-  }
-  return matching[0];
-}
-
-// src/core/base-adapter.ts
-var BaseAdapter = class {
-  inspect(_ctx) {
-    throw new Error(`${this.runner}: --inspect not implemented yet`);
-  }
-  report(_ctx) {
-    throw new Error(`${this.runner}: --report not implemented yet`);
-  }
-  status(_ctx) {
-    throw new Error(`${this.runner}: --status not implemented yet`);
-  }
-};
-
-// 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) {
-  const paint = (format, text) => styleText(format, text, { stream });
-  return {
-    ok: (text) => paint(["green", "bold"], text),
-    fail: (text) => paint(["red", "bold"], text),
-    warn: (text) => paint("yellow", text),
-    strong: (text) => paint("bold", text),
-    dim: (text) => paint("dim", text),
-    accent: (text) => paint("cyan", text)
-  };
-}
-
-// src/shared/package-json.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-function readOwnPackage() {
-  let dir = dirname(fileURLToPath(import.meta.url));
-  for (; ; ) {
-    const pkgPath = join(dir, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-        if (typeof pkg.version === "string") {
-          return { name: pkg.name ?? "@hublo/sentinel", version: pkg.version };
-        }
-      } catch {
-      }
-    }
-    const parent = dirname(dir);
-    if (parent === dir) return { name: "@hublo/sentinel", version: "0.0.0" };
-    dir = parent;
-  }
-}
-function readOwnVersion() {
-  return readOwnPackage().version;
-}
-function readProjectPackageJson(dir) {
-  const path = join(dir, "package.json");
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    process.stderr.write(`sentinel: could not parse ${path}; ignoring for detection.
-`);
-    return {};
-  }
-}
-function readNxProjectName(dir) {
-  const path = join(dir, "project.json");
-  if (!existsSync(path)) return void 0;
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
-    return typeof parsed.name === "string" ? parsed.name : void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-// 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";
-
-// src/shared/jsonc.ts
-import { parse, printParseErrorCode } from "jsonc-parser";
-function parseJsonc(text, source = "config") {
-  const errors = [];
-  const value = parse(text, errors, { allowTrailingComma: true });
-  if (errors.length > 0) {
-    const details = errors.map((error) => printParseErrorCode(error.error)).join(", ");
-    throw new Error(`${source}: malformed JSONC (${details}).`);
-  }
-  return value;
-}
-
-// src/shared/resolve-bin.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-function resolveBin(fromDir, name) {
-  let dir = fromDir;
-  for (; ; ) {
-    const candidate = join2(dir, "node_modules", ".bin", name);
-    if (existsSync2(candidate)) return candidate;
-    const parent = dirname2(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-
-// src/roles/typescript/config-policy.ts
-var PERMITTED_COMPILER_OPTIONS = [
-  "paths",
-  "baseUrl",
-  "rootDir",
-  "outDir",
-  "tsBuildInfoFile"
-];
-function presetOwnedKeys(compilerOptions) {
-  if (!compilerOptions) return [];
-  return Object.keys(compilerOptions).filter((key) => !PERMITTED_COMPILER_OPTIONS.includes(key));
-}
-
-// src/roles/typescript/phased-rules.ts
-var DEFERRED_RULES = [
-  { rule: "noImplicitAny", phase: 2, reason: "the implicit-any migration (TS70xx)" },
-  { rule: "noUnusedLocals", phase: 2, reason: "unused-local cleanup (TS6133)" },
-  { rule: "noUnusedParameters", phase: 2, reason: "unused-parameter cleanup (TS6133)" }
-];
-function deferredRuleNames() {
-  return DEFERRED_RULES.map((entry) => entry.rule);
-}
-
-// src/roles/typescript/presets.ts
-var SHIPPED_FLAVOURS = ["react", "nest", "node"];
-function hasShippedPreset(flavour) {
-  return SHIPPED_FLAVOURS.includes(flavour);
-}
-
-// src/roles/typescript/read-adoption.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
-
-// src/roles/typescript/resolve-tsconfig-target.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join3 } 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);
-  } catch {
-    return [];
-  }
-  if (typeof parsed.extends === "string") return [parsed.extends];
-  if (Array.isArray(parsed.extends)) {
-    return parsed.extends.filter((entry) => typeof entry === "string");
-  }
-  return [];
-}
-function resolveTsconfigTarget(moduleDir) {
-  let existing;
-  for (const candidate of CANDIDATES) {
-    const absolutePath = join3(moduleDir, candidate);
-    if (!existsSync3(absolutePath)) continue;
-    existing ??= candidate;
-    const extendsValues = readExtends(absolutePath);
-    const extendsBase = extendsValues.some(
-      (value) => TARGET_EXTENDS_MARKERS.some((marker) => value.includes(marker))
-    );
-    if (extendsBase) {
-      return { path: candidate, reason: "extends-base" };
-    }
-  }
-  if (existing) return { path: existing, reason: "other-chain" };
-  return { path: "tsconfig.json", reason: "none" };
-}
-
-// src/roles/typescript/read-adoption.ts
-var SENTINEL_PRESET = /^@hublo\/sentinel\/tsconfig\/[a-z-]+$/;
-function normaliseExtends(value) {
-  if (typeof value === "string") return [value];
-  if (Array.isArray(value))
-    return value.filter((entry) => typeof entry === "string");
-  return [];
-}
-var NOT_ADOPTED = (configFile) => ({
-  configFile,
-  preset: null,
-  adopted: false,
-  conformant: false,
-  drift: []
-});
-function readTsconfigAdoption(cwd) {
-  const target = resolveTsconfigTarget(cwd);
-  if (target.reason === "none" || !existsSync4(join4(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);
-  } catch {
-    return NOT_ADOPTED(target.path);
-  }
-  const preset = normaliseExtends(parsed.extends).find((entry) => SENTINEL_PRESET.test(entry)) ?? null;
-  if (preset === null) return NOT_ADOPTED(target.path);
-  const drift = presetOwnedKeys(parsed.compilerOptions);
-  return { configFile: target.path, preset, adopted: true, conformant: drift.length === 0, drift };
-}
-
-// src/roles/typescript/adapters/tsc/tsc.adapter.ts
-var TYPECHECK_SCRIPT = { typecheck: "sentinel --run --typescript" };
-var INSTALL_NOTE = "run `pnpm install` to fetch @hublo/sentinel (added to the module devDependencies) so `extends` and the typecheck script resolve";
-var DEFAULT_MAX_DIAGNOSTICS = 100;
-var DIAGNOSTIC_RE = /^(.+?)\((\d+),(\d+)\): error (TS\d+): (.+)$/;
-function parseDiagnostics(output) {
-  const diagnostics = [];
-  for (const raw of output.split("\n")) {
-    const m = DIAGNOSTIC_RE.exec(raw.trim());
-    if (m) {
-      diagnostics.push({
-        file: m[1],
-        line: Number(m[2]),
-        col: Number(m[3]),
-        code: m[4],
-        message: m[5]
-      });
-    }
-  }
-  return diagnostics;
-}
-var PHASED_STRICTNESS_WARNING = `sentinel typescript: phase 1 (non-breaking) \u2014 deferred: ${deferredRuleNames().join(", ")}. Enabled centrally in a later wave; run \`sentinel --inspect --typescript\` for the list.`;
-function composeExtends(current, preset) {
-  const chain = typeof current === "string" ? [current] : Array.isArray(current) ? current.filter((entry) => typeof entry === "string") : [];
-  return chain.includes(preset) ? chain : [...chain, preset];
-}
-var TscAdapter = class extends BaseAdapter {
-  target = "typescript";
-  runner = "tsc";
-  /**
-   * The tsc adapter drives type-checking for any flavour: `--run`/`--report`/
-   * `--inspect` just execute tsc against the module's existing config, which is
-   * meaningful regardless of flavour. `--init` is the exception, it only WRITES a
-   * preset for flavours that ship one (gated inside `plan`), so svelte is not
-   * clobbered with a non-existent preset.
-   */
-  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
-   * `@hublo/sentinel` devDependency into the module. The engine applies the ops, so
-   * adoption is `--init` then `pnpm install`, with nothing to add by hand.
-   *
-   * Per resolved case:
-   *   - extends-base: append the preset to the `extends` chain (keep the base for
-   *     the monorepo's paths/structure) + strip preset-owned `compilerOptions`
-   *     (drift), keeping the project's own paths/include (the allowlist).
-   *   - none: create a fresh thin `tsconfig.json`.
-   *   - other-chain (svelte): skip, its config extends a different base.
-   */
-  plan(context) {
-    if (!hasShippedPreset(context.flavour)) {
-      return {
-        operations: [],
-        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 target = resolveTsconfigTarget(context.cwd);
-    const preset = `@hublo/sentinel/tsconfig/${context.flavour}`;
-    const addScript = this.packageJsonOperation(context.cwd);
-    if (target.reason === "other-chain") {
-      return {
-        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 === "none") {
-      const contents = JSON.stringify({ extends: preset, include: ["src"] }, null, 2) + "\n";
-      return {
-        operations: [{ kind: "write", path: target.path, contents }, addScript],
-        notes: [`created ${target.path} (no tsconfig found)`, INSTALL_NOTE]
-      };
-    }
-    const existing = parseJsonc(
-      readFileSync4(join5(context.cwd, target.path), "utf8"),
-      target.path
-    );
-    const extendsChain = composeExtends(existing.extends, preset);
-    const drift = presetOwnedKeys(existing.compilerOptions);
-    const operations = [
-      { kind: "merge-json", path: target.path, value: { extends: extendsChain } }
-    ];
-    const notes = [];
-    if (drift.length > 0) {
-      const localKeys = Object.keys(existing.compilerOptions ?? {});
-      const stripsAll = localKeys.length > 0 && localKeys.every((key) => drift.includes(key));
-      operations.push({
-        kind: "remove-json-keys",
-        path: target.path,
-        keys: stripsAll ? [["compilerOptions"]] : drift.map((key) => ["compilerOptions", key])
-      });
-      notes.push(`stripped preset-owned compilerOptions: ${drift.join(", ")}`);
-    }
-    operations.push(addScript);
-    notes.push(INSTALL_NOTE);
-    return { operations, notes };
-  }
-  /**
-   * The op that routes type-checking through the CLI. If the module already has a
-   * `package.json`, merge the script in and leave the rest untouched. If it does
-   * NOT (common for nx apps/services that carry only a `project.json`), scaffold a
-   * minimal, workspace-valid one, its nx name + `private: true`, so pnpm accepts it
-   * and it can carry the pinned `@hublo/sentinel` devDep this op also writes. The
-   * exact version is written (never a range), so `pnpm install` resolves the same
-   * build the stub's `extends` points at.
-   */
-  packageJsonOperation(cwd) {
-    const own = readOwnPackage();
-    const devDependencies = { [own.name]: own.version };
-    if (existsSync5(join5(cwd, "package.json"))) {
-      return {
-        kind: "merge-json",
-        path: "package.json",
-        value: { scripts: TYPECHECK_SCRIPT, devDependencies }
-      };
-    }
-    const name = readNxProjectName(cwd) ?? basename(cwd);
-    return {
-      kind: "merge-json",
-      path: "package.json",
-      value: { name, private: true, scripts: TYPECHECK_SCRIPT, devDependencies }
-    };
-  }
-  /**
-   * Type-check the module with `tsc -b` (build mode) on its solution config, the
-   * way the monorepo itself does. Build mode walks the config's `references`, so a
-   * references-only solution (Pattern A: app + spec) is actually checked instead of
-   * passing vacuously; it also only caches SUCCESSFUL builds, so errors are always
-   * re-reported. Uses the module's own tsc. Nothing to check is a pass.
-   */
-  async run(ctx) {
-    const config = this.typecheckTarget(ctx.cwd);
-    if (!config) {
-      process.stderr.write("sentinel typescript(tsc): no tsconfig to check\n");
-      return { ok: true, code: 0 };
-    }
-    process.stderr.write(`${palette(process.stderr).warn(PHASED_STRICTNESS_WARNING)}
-`);
-    const tsc = resolveBin(ctx.cwd, "tsc") ?? "tsc";
-    const result = spawnSync(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?
-`
-      );
-      return { ok: false, code: 1 };
-    }
-    const code = result.status ?? 1;
-    return { ok: code === 0, code };
-  }
-  /**
-   * The config to type-check with `tsc -b`. Prefer the module's root `tsconfig.json`
-   * (the solution the monorepo builds; `tsc -b` follows its `references` to cover
-   * app + spec), else the base-extending file, else null when there is nothing to
-   * check.
-   */
-  typecheckTarget(cwd) {
-    if (existsSync5(join5(cwd, "tsconfig.json"))) return "tsconfig.json";
-    const target = resolveTsconfigTarget(cwd);
-    return target.reason === "none" ? null : target.path;
-  }
-  /**
-   * The module's resolved TypeScript config: which preset, which file, how, and the
-   * phased-strictness state (`deferred` rules that are off in phase 1). This is the
-   * "list what's deferred" query, `sentinel --inspect --typescript`.
-   */
-  async inspect(ctx) {
-    const target = resolveTsconfigTarget(ctx.cwd);
-    const { preset, adopted } = readTsconfigAdoption(ctx.cwd);
-    return {
-      module: ctx.module,
-      target: "typescript",
-      flavour: ctx.flavour,
-      configFile: target.path,
-      configState: target.reason,
-      preset,
-      adopted,
-      phase: 1,
-      deferred: DEFERRED_RULES
-    };
-  }
-  /**
-   * Adoption + conformity from the committed tsconfig, for `--status`. No tsc run and
-   * no flavour guessing: reads the actual `extends` chain, so a workspace-wide scan is
-   * a cheap coverage + drift dashboard (adopted? which preset? drifted?).
-   */
-  async status(ctx) {
-    const { adopted, preset, conformant, drift } = readTsconfigAdoption(ctx.cwd);
-    return { adopted, preset, conformant, drift };
-  }
-  /**
-   * Report conformance for the module: `tsc -b` (build mode, so app + spec are
-   * covered) and count total type errors plus the implicit-`any` family (TS70xx:
-   * 7006/7031/7053/… ), the signal that drives the noImplicitAny migration. No
-   * tsconfig is a clean, empty report.
-   */
-  async report(ctx) {
-    const config = this.typecheckTarget(ctx.cwd);
-    if (!config) {
-      return { ok: true, code: 0, metrics: { errors: 0, implicitAny: "deferred", diagnostics: [] } };
-    }
-    const tsc = resolveBin(ctx.cwd, "tsc") ?? "tsc";
-    const result = spawnSync(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?
-`
-      );
-      return { ok: false, code: 1, metrics: { error: "tsc not available" } };
-    }
-    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    const errors = (output.match(/error TS\d+/g) ?? []).length;
-    const parsed = parseDiagnostics(output);
-    const cap = ctx.maxDiagnostics === 0 ? Infinity : ctx.maxDiagnostics ?? DEFAULT_MAX_DIAGNOSTICS;
-    const diagnostics = Number.isFinite(cap) ? parsed.slice(0, cap) : parsed;
-    return {
-      ok: errors === 0,
-      code: result.status ?? 0,
-      metrics: {
-        errors,
-        implicitAny: this.implicitAnyMetric(ctx.cwd, tsc, config, output),
-        diagnostics,
-        diagnosticsTruncated: diagnostics.length < parsed.length
-      }
-    };
-  }
-  /**
-   * The `implicitAny` report metric, honestly. Implicit-`any` violations (TS70xx) are
-   * only *visible* to tsc when `noImplicitAny` is ON. In phase 1 the rule is DEFERRED
-   * (off), so counting TS70xx from the committed-config run is structurally always 0 —
-   * a misleading "no implicit-any" when the rule simply was not applied. So: report the
-   * real count only when the rule is on, otherwise `'deferred'` (never a fake `0`). The
-   * remaining debt while deferred is a separate, opt-in probe (a later `--migration`).
-   */
-  implicitAnyMetric(cwd, tsc, config, mainOutput) {
-    return this.noImplicitAnyEnabled(cwd, tsc, config, mainOutput) ? (mainOutput.match(/error TS70\d\d/g) ?? []).length : "deferred";
-  }
-  /**
-   * Whether `noImplicitAny` is effectively ON in the module's resolved config. Read from
-   * `tsc --showConfig` (an explicit value wins; otherwise `strict` implies it). If
-   * `--showConfig` is unavailable, fall back to the run's own evidence: implicit-`any`
-   * errors in the output mean the rule must be on.
-   */
-  noImplicitAnyEnabled(cwd, tsc, config, mainOutput) {
-    const shown = spawnSync(tsc, ["-p", config, "--showConfig"], { cwd, encoding: "utf8" });
-    if (shown.status === 0 && shown.stdout) {
-      try {
-        const co = parseJsonc(
-          shown.stdout,
-          "tsconfig(--showConfig)"
-        ).compilerOptions;
-        if (co) return co.noImplicitAny ?? co.strict === true;
-      } catch {
-      }
-    }
-    return /error TS70\d\d/.test(mainOutput);
-  }
-};
-
-// src/roles/typescript/register.ts
-function registerTypescript() {
-  register(new TscAdapter());
-  setDefaultRunner("typescript", "tsc");
-}
-
-// src/adapters.ts
-function registerAdapters() {
-  registerTypescript();
-}
-
-// src/core/detect-framework.ts
-var FRAMEWORK_SIGNALS = [
-  { flavour: "nest", dependency: "@nestjs/core" },
-  { flavour: "react", dependency: "react" },
-  { flavour: "svelte", dependency: "svelte" }
-];
-var BACKEND_HINTS = ["sails", "express", "koa", "fastify", "@hapi/hapi"];
-function describeFramework(packageJson) {
-  const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
-  const matched = FRAMEWORK_SIGNALS.filter((s) => s.dependency in dependencies);
-  const chosen = matched[0];
-  const flavour = chosen?.flavour ?? "node";
-  const source = chosen?.dependency ?? "(no framework dependency)";
-  const otherFlavourSignals = matched.slice(1).map((s) => s.dependency);
-  const backendHints = flavour === "react" || flavour === "svelte" ? BACKEND_HINTS.filter((hint) => hint in dependencies) : [];
-  const conflicts = [...otherFlavourSignals, ...backendHints];
-  return { flavour, source, ambiguous: conflicts.length > 0, conflicts };
-}
-function detectFramework(packageJson) {
-  return describeFramework(packageJson).flavour;
-}
-
-// src/shared/text.ts
-function ensureLines(current, lines) {
-  const present = new Set(current.split("\n").map((line) => line.trim()));
-  const missing = lines.filter((line) => !present.has(line.trim()));
-  if (missing.length === 0) return current;
-  const prefix = current.length === 0 || current.endsWith("\n") ? current : current + "\n";
-  return prefix + missing.join("\n") + "\n";
-}
-function toLines(text) {
-  if (text.length === 0) return [];
-  return text.replace(/\n$/, "").split("\n");
-}
-function diffLines(before, after) {
-  const from = toLines(before);
-  const to = toLines(after);
-  const lcs = Array.from(
-    { length: from.length + 1 },
-    () => new Array(to.length + 1).fill(0)
-  );
-  const cell = (i2, j2) => lcs[i2]?.[j2] ?? 0;
-  for (let i2 = from.length - 1; i2 >= 0; i2--) {
-    const row = lcs[i2];
-    if (!row) continue;
-    for (let j2 = to.length - 1; j2 >= 0; j2--) {
-      row[j2] = from[i2] === to[j2] ? cell(i2 + 1, j2 + 1) + 1 : Math.max(cell(i2 + 1, j2), cell(i2, j2 + 1));
-    }
-  }
-  const out = [];
-  let i = 0;
-  let j = 0;
-  while (i < from.length && j < to.length) {
-    if (from[i] === to[j]) {
-      out.push(`  ${from[i] ?? ""}`);
-      i++;
-      j++;
-    } else if (cell(i + 1, j) >= cell(i, j + 1)) {
-      out.push(`- ${from[i] ?? ""}`);
-      i++;
-    } else {
-      out.push(`+ ${to[j] ?? ""}`);
-      j++;
-    }
-  }
-  while (i < from.length) out.push(`- ${from[i++] ?? ""}`);
-  while (j < to.length) out.push(`+ ${to[j++] ?? ""}`);
-  return out;
-}
-
-// src/core/apply-plan.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, renameSync, writeFileSync } from "fs";
-import { resolve as resolve2, sep } from "path";
-import { applyEdits, modify } from "jsonc-parser";
-
-// src/shared/deep-merge.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/core/apply-plan.ts
-function resolveWithinRoot(cwd, relativePath) {
-  const root = resolve2(cwd);
-  const absolutePath = resolve2(root, relativePath);
-  if (absolutePath !== root && !absolutePath.startsWith(root + sep)) {
-    throw new Error(`Refusing to write outside the module root: "${relativePath}".`);
-  }
-  return absolutePath;
-}
-function readIfExists(absolutePath) {
-  return existsSync6(absolutePath) ? readFileSync5(absolutePath, "utf8") : void 0;
-}
-function* leaves(value, prefix = []) {
-  for (const [key, keyValue] of Object.entries(value)) {
-    const path = [...prefix, key];
-    if (isPlainObject(keyValue)) yield* leaves(keyValue, path);
-    else yield [path, keyValue];
-  }
-}
-function mergeJsonc(current, value) {
-  let text = current.trim().length > 0 ? current : "{}\n";
-  for (const [path, leaf] of leaves(value)) {
-    const edits = modify(text, path, leaf, {
-      formattingOptions: { insertSpaces: true, tabSize: 2 }
-    });
-    text = applyEdits(text, edits);
-  }
-  return text.endsWith("\n") ? text : text + "\n";
-}
-function removeJsoncKeys(current, keys) {
-  let text = current.trim().length > 0 ? current : "{}\n";
-  for (const path of keys) {
-    const edits = modify(text, path, void 0, {
-      formattingOptions: { insertSpaces: true, tabSize: 2 }
-    });
-    text = applyEdits(text, edits);
-  }
-  return text.endsWith("\n") ? text : text + "\n";
-}
-function applyOperationTo(current, operation) {
-  switch (operation.kind) {
-    case "write":
-      return operation.contents;
-    case "merge-json":
-      return mergeJsonc(current, operation.value);
-    case "ensure-lines":
-      return ensureLines(current, operation.lines);
-    case "remove-json-keys":
-      return removeJsoncKeys(current, operation.keys);
-    default: {
-      const unreachable = operation;
-      throw new Error(`Unknown file operation: ${JSON.stringify(unreachable)}`);
-    }
-  }
-}
-function preparePlan(cwd, plan) {
-  const prepared = /* @__PURE__ */ new Map();
-  for (const operation of plan.operations) {
-    const absolutePath = resolveWithinRoot(cwd, operation.path);
-    const existing = prepared.get(operation.path);
-    const before = existing?.before ?? readIfExists(absolutePath) ?? "";
-    const current = existing?.after ?? before;
-    prepared.set(operation.path, {
-      path: operation.path,
-      absolutePath,
-      before,
-      after: applyOperationTo(current, operation)
-    });
-  }
-  return [...prepared.values()];
-}
-function writeFileAtomic(absolutePath, contents) {
-  const tempPath = `${absolutePath}.sentinel-${process.pid}.tmp`;
-  writeFileSync(tempPath, contents);
-  renameSync(tempPath, absolutePath);
-}
-function applyPlan(cwd, plan) {
-  const changed = preparePlan(cwd, plan).filter((file) => file.before !== file.after);
-  for (const file of changed) writeFileAtomic(file.absolutePath, file.after);
-  return changed.map((file) => file.path);
-}
-
-// src/core/dispatch.ts
-function resolveFlavour(opts) {
-  if (opts.flavour) return opts.flavour;
-  const detection = describeFramework(readProjectPackageJson(opts.cwd));
-  if (detection.ambiguous) {
-    const warn = palette(process.stderr);
-    process.stderr.write(
-      warn.warn(
-        `sentinel: flavour is ambiguous, detected "${detection.flavour}" (from ${detection.source}), also found ${detection.conflicts.join(", ")}. Pass --flavour to write the intended preset.`
-      ) + "\n"
-    );
-  }
-  return detection.flavour;
-}
-function previewPlan(opts, plan) {
-  const changed = preparePlan(opts.cwd, plan).filter((file) => file.before !== file.after);
-  if (opts.json) {
-    process.stdout.write(
-      JSON.stringify(
-        {
-          dryRun: true,
-          notes: plan.notes ?? [],
-          files: changed.map(({ path, before, after }) => ({
-            path,
-            action: before.length === 0 ? "create" : "update",
-            before,
-            after
-          }))
-        },
-        null,
-        2
-      ) + "\n"
-    );
-    return 0;
-  }
-  process.stderr.write("  dry run: no files written\n");
-  for (const note of plan.notes ?? []) process.stderr.write(`  ${note}
-`);
-  if (changed.length === 0) {
-    process.stderr.write("  nothing to change\n");
-    return 0;
-  }
-  for (const { path, before, after } of changed) {
-    const action = before.length === 0 ? "create" : "update";
-    process.stdout.write(`
-  ${action} ${path}
-`);
-    for (const line of diffLines(before, after)) process.stdout.write(`    ${line}
-`);
-  }
-  return 0;
-}
-async function dispatch(opts) {
-  if (opts.verb !== "init") {
-    throw new Error(`dispatch handles --init only; --${opts.verb} routes through analyse()`);
-  }
-  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) {
-    process.stderr.write(`sentinel (${opts.target}): ${plan.blocked}
-`);
-    return 1;
-  }
-  if (opts.dryRun) {
-    return previewPlan(opts, plan);
-  }
-  const written = applyPlan(opts.cwd, plan);
-  for (const path of written) process.stderr.write(`  wrote ${path}
-`);
-  for (const note of plan.notes ?? []) process.stderr.write(`  ${note}
-`);
-  return 0;
-}
-
-export {
-  register,
-  setDefaultRunner,
-  all,
-  availableTargets,
-  resolve,
-  BaseAdapter,
-  VERBS,
-  TARGETS,
-  FLAVOURS,
-  palette,
-  readOwnPackage,
-  readOwnVersion,
-  readProjectPackageJson,
-  readNxProjectName,
-  resolveBin,
-  registerAdapters,
-  describeFramework,
-  detectFramework,
-  dispatch
-};
-//# sourceMappingURL=chunk-SK6E5EM4.js.map