@hublo/sentinel 0.1.0-alpha.0

package/dist/chunk-D6QBEHMF.js

@@ -0,0 +1,609 @@
+// 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 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`);
+  }
+};
+
+// src/shared/package-json.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function readOwnVersion() {
+  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 pkg.version;
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return "0.0.0";
+    dir = parent;
+  }
+}
+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 existsSync4, readFileSync as readFileSync3 } from "fs";
+import { basename, join as join4 } 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/presets.ts
+var SHIPPED_FLAVOURS = ["react", "nest", "node"];
+function hasShippedPreset(flavour) {
+  return SHIPPED_FLAVOURS.includes(flavour);
+}
+
+// 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/adapters/tsc/tsc.adapter.ts
+var TYPECHECK_SCRIPT = { typecheck: "sentinel --run --typescript" };
+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. `--update` 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;
+  }
+  /**
+   * Plan `--update`: make the module extend the sentinel preset with a THIN,
+   * conformant stub, and route type-checking through the CLI. The engine applies
+   * the ops; ensuring the `@hublo/sentinel` dependency is an adoption step
+   * (`pnpm add`), not a file write.
+   *
+   * Per resolved case:
+   *   - extends-base: set `extends` + 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: [],
+        notes: [`skipped: no TypeScript preset for flavour "${context.flavour}" yet`]
+      };
+    }
+    const target = resolveTsconfigTarget(context.cwd);
+    const preset = `@hublo/sentinel/tsconfig/${context.flavour}`;
+    const addScript = this.typecheckScriptOperation(context.cwd);
+    if (target.reason === "other-chain") {
+      return {
+        operations: [],
+        notes: [`skipped: ${target.path} extends a non-base config; handled separately`]
+      };
+    }
+    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)`]
+      };
+    }
+    const existing = parseJsonc(
+      readFileSync3(join4(context.cwd, target.path), "utf8"),
+      target.path
+    );
+    const drift = presetOwnedKeys(existing.compilerOptions);
+    const operations = [
+      { kind: "merge-json", path: target.path, value: { extends: preset } }
+    ];
+    const notes = [];
+    if (drift.length > 0) {
+      operations.push({
+        kind: "remove-json-keys",
+        path: target.path,
+        keys: drift.map((key) => ["compilerOptions", key])
+      });
+      notes.push(`stripped preset-owned compilerOptions: ${drift.join(", ")}`);
+    }
+    operations.push(addScript);
+    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 then receive the `@hublo/sentinel` devDep (added via `pnpm add` at
+   * adoption, never written here, so the lockfile stays authoritative).
+   */
+  typecheckScriptOperation(cwd) {
+    if (existsSync4(join4(cwd, "package.json"))) {
+      return { kind: "merge-json", path: "package.json", value: { scripts: TYPECHECK_SCRIPT } };
+    }
+    const name = readNxProjectName(cwd) ?? basename(cwd);
+    return {
+      kind: "merge-json",
+      path: "package.json",
+      value: { name, private: true, scripts: TYPECHECK_SCRIPT }
+    };
+  }
+  /**
+   * Run `tsc --noEmit` on the module's type-check config (the one that extends the
+   * base/preset), using the module's own tsc. No tsconfig to check is a pass.
+   */
+  async run(ctx) {
+    const target = resolveTsconfigTarget(ctx.cwd);
+    if (target.reason === "none") {
+      process.stderr.write("sentinel typescript(tsc): no tsconfig to check\n");
+      return { ok: true, code: 0 };
+    }
+    const tsc = resolveBin(ctx.cwd, "tsc") ?? "tsc";
+    const result = spawnSync(tsc, ["--noEmit", "--project", target.path], {
+      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 module's resolved TypeScript config: which preset, which file, and how. */
+  async inspect(ctx) {
+    const target = resolveTsconfigTarget(ctx.cwd);
+    return {
+      module: ctx.module,
+      target: "typescript",
+      flavour: ctx.flavour,
+      configFile: target.path,
+      configState: target.reason,
+      preset: target.reason === "none" ? null : `@hublo/sentinel/tsconfig/${ctx.flavour}`
+    };
+  }
+  /**
+   * Report conformance for the module: run tsc and count total type errors and the
+   * implicit-`any` subset (TS7006), the signal that drives the noImplicitAny
+   * migration. No tsconfig is a clean, empty report.
+   */
+  async report(ctx) {
+    const target = resolveTsconfigTarget(ctx.cwd);
+    if (target.reason === "none") {
+      return { ok: true, code: 0, metrics: { errors: 0, implicitAny: 0 } };
+    }
+    const tsc = resolveBin(ctx.cwd, "tsc") ?? "tsc";
+    const result = spawnSync(tsc, ["--noEmit", "--project", target.path], {
+      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 implicitAny = (output.match(/error TS7006/g) ?? []).length;
+    return { ok: errors === 0, code: result.status ?? 0, metrics: { errors, implicitAny } };
+  }
+};
+
+// 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: "svelte", dependency: "svelte" },
+  { flavour: "react", dependency: "react" }
+];
+function detectFramework(packageJson) {
+  const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  for (const { flavour, dependency } of FRAMEWORK_SIGNALS) {
+    if (dependency in dependencies) return flavour;
+  }
+  return "node";
+}
+
+// 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 existsSync5, readFileSync as readFileSync4, 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 existsSync5(absolutePath) ? readFileSync4(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 prepared = preparePlan(cwd, plan);
+  for (const file of prepared) writeFileAtomic(file.absolutePath, file.after);
+  return prepared.map((file) => file.path);
+}
+
+// src/core/dispatch.ts
+function resolveFlavour(opts) {
+  return opts.flavour ?? detectFramework(readProjectPackageJson(opts.cwd));
+}
+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) {
+  const adapter = resolve(opts.target, opts.flavour, opts.runner);
+  const flavour = resolveFlavour(opts);
+  const ctx = {
+    module: opts.module,
+    cwd: opts.cwd,
+    flavour,
+    ci: opts.ci,
+    fix: opts.fix
+  };
+  switch (opts.verb) {
+    case "run": {
+      const res = await adapter.run(ctx);
+      return res.code;
+    }
+    case "inspect": {
+      const config = await adapter.inspect(ctx);
+      process.stdout.write(JSON.stringify(config, null, 2) + "\n");
+      return 0;
+    }
+    case "update": {
+      const context = { cwd: opts.cwd, flavour };
+      const plan = await adapter.plan(context);
+      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;
+    }
+    case "report": {
+      const res = await adapter.report(ctx);
+      if (res.metrics) {
+        process.stdout.write(JSON.stringify(res.metrics, null, 2) + "\n");
+      }
+      return res.code;
+    }
+    default: {
+      const unreachable = opts.verb;
+      throw new Error(`Unknown verb: ${String(unreachable)}`);
+    }
+  }
+}
+
+export {
+  register,
+  setDefaultRunner,
+  all,
+  resolve,
+  BaseAdapter,
+  readOwnVersion,
+  readProjectPackageJson,
+  resolveBin,
+  registerAdapters,
+  detectFramework,
+  dispatch
+};
+//# sourceMappingURL=chunk-D6QBEHMF.js.map