@clearlydev/nx-archweave 0.3.2 → 0.4.0

package/dist/generators/_chunks/chunk-34V6HAJT.js

@@ -0,0 +1,55 @@
+// ../shared/dist/lib/spawnable-command.js
+import { statSync } from "node:fs";
+import { win32 } from "node:path";
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_ENV = { platform: process.platform, env: process.env, isFile };
+function envValue(env, name) {
+  const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
+  return key === void 0 ? void 0 : env[key];
+}
+function resolveWindowsCommand(command, environment) {
+  const exts = (envValue(environment.env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  const candidates = (base) => win32.extname(base) !== "" ? [base] : exts.map((ext) => base + ext);
+  if (win32.isAbsolute(command) || /[\\/]/.test(command)) {
+    return candidates(command).find(environment.isFile);
+  }
+  const dirs = (envValue(environment.env, "PATH") ?? "").split(";").filter(Boolean);
+  for (const dir of dirs) {
+    const found = candidates(win32.join(dir, command)).find(environment.isFile);
+    if (found !== void 0)
+      return found;
+  }
+  return void 0;
+}
+var META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
+var BIN_SHIM = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
+function escapeCmdArgument(arg, doubleEscape = false) {
+  let quoted = arg.replace(/(\\*)"/g, '$1$1\\"');
+  quoted = quoted.replace(/(\\*)$/, "$1$1");
+  const escaped = `"${quoted}"`.replace(META_CHARS, "^$1");
+  return doubleEscape ? escaped.replace(META_CHARS, "^$1") : escaped;
+}
+function spawnableCommand(command, args, environment = DEFAULT_ENV) {
+  if (environment.platform !== "win32")
+    return { command, args: [...args] };
+  const resolved = resolveWindowsCommand(command, environment);
+  if (resolved === void 0 || !/\.(cmd|bat)$/i.test(resolved))
+    return { command, args: [...args] };
+  const doubleEscape = BIN_SHIM.test(resolved);
+  const line = [resolved.replace(META_CHARS, "^$1"), ...args.map((arg) => escapeCmdArgument(arg, doubleEscape))].join(" ");
+  return {
+    command: envValue(environment.env, "COMSPEC") ?? "cmd.exe",
+    args: ["/d", "/s", "/c", `"${line}"`],
+    windowsVerbatimArguments: true
+  };
+}
+
+export {
+  spawnableCommand
+};

package/dist/generators/_chunks/chunk-3A6RZUCZ.js

@@ -0,0 +1,114 @@
+// src/generators/add-review/render.ts
+var DEPENDABOT_PATH = ".github/dependabot.yml";
+var PROVIDER_STATUS_URL = "https://github.com/clearlydev/nx-archweave/blob/main/docs/pr-review.md#provider-status";
+function renderLineDiff(existing, generated) {
+  const a = existing.split("\n");
+  const b = generated.split("\n");
+  const m = a.length;
+  const n = b.length;
+  const lcs = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = m - 1; i2 >= 0; i2--) {
+    for (let j2 = n - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  const out = ["--- existing", "+++ generated"];
+  let i = 0;
+  let j = 0;
+  while (i < m && j < n) {
+    if (a[i] === b[j]) {
+      out.push(`  ${a[i]}`);
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+      out.push(`- ${a[i]}`);
+      i++;
+    } else {
+      out.push(`+ ${b[j]}`);
+      j++;
+    }
+  }
+  while (i < m) out.push(`- ${a[i++]}`);
+  while (j < n) out.push(`+ ${b[j++]}`);
+  return out.join("\n");
+}
+var WORKFLOW_ACTION_LINES = {
+  created: "created",
+  overwritten: "overwritten with the generated version (per --onConflict=overwrite)",
+  unchanged: "unchanged (already matches the generated version)",
+  proposed: "NOT written \u2014 differs from the generated version (merge proposal below)",
+  skipped: "left as-is (per --onConflict=skip)",
+  alternate: "generated alongside the existing file",
+  aborted: "NOT written"
+};
+var CONFIG_ACTION_LINES = {
+  created: "created with the review field",
+  updated: "review field updated",
+  unchanged: "review field unchanged",
+  "not-updated": "NOT updated \u2014 kept consistent with the workflow file that is actually in effect",
+  aborted: "NOT updated"
+};
+function renderAddReviewReport(report) {
+  const lines = [];
+  if (report.packageManagerNote !== void 0) {
+    lines.push(`Note: ${report.packageManagerNote}`);
+  }
+  if (report.workflowAction === "aborted") {
+    lines.push("add-review aborted \u2014 nothing was written.");
+    lines.push(`  toolkit.config.json: ${report.configError ?? "unusable"}`);
+    lines.push("  Fix the config file manually, then rerun the generator.");
+    return lines.join("\n");
+  }
+  if (report.dryRun) {
+    lines.push("add-review dry-run \u2014 no files were written.");
+    lines.push("");
+    lines.push("Generated workflow YAML:");
+    lines.push(report.workflowYaml ?? "");
+    lines.push("");
+    lines.push("toolkit.config.json review field:");
+    lines.push(report.configSnippetJson ?? "");
+    lines.push("");
+    lines.push("Effective decision:");
+  }
+  lines.push(`  ${report.workflowPath}: ${WORKFLOW_ACTION_LINES[report.workflowAction]}`);
+  lines.push(`  toolkit.config.json: ${CONFIG_ACTION_LINES[report.configAction]}`);
+  if (report.workflowAction === "proposed" && report.diff) {
+    lines.push("");
+    lines.push(report.diff);
+    lines.push("");
+    lines.push("To resolve, rerun with one of:");
+    lines.push("  --onConflict=overwrite            replace the existing file with the generated version");
+    lines.push("  --onConflict=skip                 keep the existing file");
+    lines.push("  --onConflict=alternate-filename   write the generated version alongside it");
+  }
+  if (report.dependabot === "created") {
+    lines.push(`  ${DEPENDABOT_PATH}: created \u2014 Dependabot proposes newer pins for the workflow's actions`);
+  } else if (report.dependabot === "present") {
+    lines.push(`  ${DEPENDABOT_PATH}: already updates github-actions`);
+  } else if (report.dependabot === "proposed") {
+    lines.push(`  ${DEPENDABOT_PATH}: NOT changed \u2014 it has no github-actions entry. The workflow pins each action`);
+    lines.push("  to a commit SHA; add this entry under `updates:` so those pins get update pull requests:");
+    lines.push("");
+    lines.push(report.dependabotProposal ?? "");
+  }
+  if (report.workflowAction === "alternate") {
+    lines.push("");
+    lines.push("  Review the generated file, then replace the main workflow file with it yourself;");
+    lines.push("  the config stays pointing at the workflow that is actually in effect until you do.");
+  }
+  lines.push("");
+  lines.push(`Note: the review workflow stays green-skipped until you register the ${report.requiredSecretName} secret.`);
+  if (report.betaProvider !== void 0) {
+    lines.push(`Note: the ${report.betaProvider} provider is in beta \u2014 its workflow hasn't finished a review end to end on`);
+    lines.push(`GitHub Actions yet. Status, costs and known issues: ${PROVIDER_STATUS_URL}`);
+  }
+  lines.push("Note: this workflow runs with elevated permissions only after it is merged to the default branch \u2014");
+  lines.push("merging is the first real validation.");
+  return lines.join("\n");
+}
+
+export {
+  DEPENDABOT_PATH,
+  renderLineDiff,
+  renderAddReviewReport
+};

package/dist/generators/_chunks/chunk-47T7NOPP.js

@@ -0,0 +1,30 @@
+import {
+  TOOLKIT_CONFIG_PATH,
+  workspacePackageManager
+} from "./chunk-EXYZLL7A.js";
+import {
+  packageManagerCommands
+} from "./chunk-FQHFT5IH.js";
+
+// src/generators/shared/run-nx.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function runNxFor(exists, read) {
+  let config = null;
+  try {
+    const parsed = JSON.parse(read(TOOLKIT_CONFIG_PATH) ?? "null");
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) config = parsed;
+  } catch {
+  }
+  return packageManagerCommands(workspacePackageManager(exists, read, config) ?? "pnpm").runNx;
+}
+function diskRunNx(root) {
+  return runNxFor(
+    (path) => existsSync(join(root, path)),
+    (path) => existsSync(join(root, path)) ? readFileSync(join(root, path), "utf-8") : void 0
+  );
+}
+
+export {
+  diskRunNx
+};

package/dist/generators/_chunks/chunk-4FJ7CLEU.js

@@ -0,0 +1,189 @@
+import {
+  composeReviewSetup,
+  judgeReviewFileConflict
+} from "./chunk-ALSXKTLM.js";
+import {
+  DEPENDABOT_PATH,
+  renderAddReviewReport,
+  renderLineDiff
+} from "./chunk-3A6RZUCZ.js";
+import {
+  generatorFilesDir,
+  renderTemplateFiles
+} from "./chunk-YNMLB4DL.js";
+import {
+  resolveDryRun
+} from "./chunk-TUN34LAQ.js";
+import {
+  applyJsonEdits,
+  treePackageManager
+} from "./chunk-EXYZLL7A.js";
+
+// src/generators/add-review/generator.ts
+var CONFIG_PATH = "toolkit.config.json";
+function deriveAltWorkflowPath(mainWorkflowPath) {
+  return mainWorkflowPath.replace(/\.yml$/, ".archweave.yml");
+}
+function readConfig(tree) {
+  const raw = tree.read(CONFIG_PATH, "utf-8");
+  if (raw === null) return { raw: null, parsed: null, error: null };
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { raw, parsed: null, error: `${CONFIG_PATH} must contain a top-level JSON object` };
+    }
+    return { raw, parsed, error: null };
+  } catch {
+    return { raw, parsed: null, error: `${CONFIG_PATH} is not valid JSON` };
+  }
+}
+function resolveLocale(option, config) {
+  if (option) return option;
+  const fromConfig = config.parsed?.["locale"];
+  return fromConfig === "ko" || fromConfig === "en" ? fromConfig : "en";
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((value, index) => deepEqual(value, b[index]));
+  }
+  const aKeys = Object.keys(a).sort();
+  const bKeys = Object.keys(b).sort();
+  if (aKeys.length !== bKeys.length || aKeys.some((key, index) => key !== bKeys[index])) return false;
+  return aKeys.every((key) => deepEqual(a[key], b[key]));
+}
+var PROVIDERS = ["claude", "gemini", "gpt", "cursor"];
+var BETA_PROVIDERS = ["gemini", "gpt", "cursor"];
+var MODES = ["fast", "standard", "thorough"];
+function recordedReview(config) {
+  const review = config?.["review"];
+  if (typeof review !== "object" || review === null || Array.isArray(review)) return {};
+  const record = review;
+  const pick = (value, allowed) => typeof value === "string" && allowed.includes(value) ? value : void 0;
+  const rounds = record["maxRounds"];
+  return {
+    provider: pick(record["provider"], PROVIDERS),
+    mode: pick(record["mode"], MODES),
+    maxRounds: rounds === 1 || rounds === 2 || rounds === 3 || rounds === 4 || rounds === 5 ? rounds : void 0
+  };
+}
+function runAddReview(tree, options) {
+  const config = readConfig(tree);
+  const detectedPm = treePackageManager(tree, config.parsed);
+  const packageManager = options.packageManager ?? detectedPm ?? "pnpm";
+  const packageManagerNote = options.packageManager === void 0 && detectedPm === null ? "the package manager could not be detected (no pnpm, yarn, bun or npm lockfile) \u2014 the workflow was rendered for pnpm; re-run with --packageManager=npm|yarn|bun if that is wrong." : void 0;
+  const recorded = recordedReview(config.parsed);
+  const provider = options.provider ?? recorded.provider ?? "claude";
+  const plan = composeReviewSetup({
+    enabled: true,
+    provider,
+    mode: options.mode ?? recorded.mode ?? "standard",
+    locale: resolveLocale(options.locale, config),
+    maxRounds: options.maxRounds ?? recorded.maxRounds ?? 3,
+    packageManager
+  });
+  if (plan === null) throw new Error("unreachable: add-review always composes with enabled: true");
+  if (config.error !== null) {
+    return {
+      dryRun: options.dryRun ?? false,
+      workflowPath: plan.workflowFilePath,
+      workflowAction: "aborted",
+      configAction: "aborted",
+      requiredSecretName: plan.requiredSecretName,
+      diff: null,
+      workflowYaml: null,
+      configSnippetJson: null,
+      configError: config.error,
+      dependabot: "not-applied",
+      dependabotProposal: null
+    };
+  }
+  const existing = tree.read(plan.workflowFilePath, "utf-8");
+  const verdict = judgeReviewFileConflict(existing, plan.workflowYaml);
+  let workflowAction;
+  let workflowPath = plan.workflowFilePath;
+  let writeWorkflowTo = null;
+  let diff = null;
+  let mainFileMatchesOptions;
+  if (verdict.kind === "create") {
+    workflowAction = "created";
+    writeWorkflowTo = plan.workflowFilePath;
+    mainFileMatchesOptions = true;
+  } else if (verdict.kind === "unchanged") {
+    workflowAction = "unchanged";
+    mainFileMatchesOptions = true;
+  } else {
+    switch (options.onConflict) {
+      case "overwrite":
+        workflowAction = "overwritten";
+        writeWorkflowTo = plan.workflowFilePath;
+        mainFileMatchesOptions = true;
+        break;
+      case "skip":
+        workflowAction = "skipped";
+        mainFileMatchesOptions = false;
+        break;
+      case "alternate-filename": {
+        const altWorkflowPath = deriveAltWorkflowPath(plan.workflowFilePath);
+        workflowAction = "alternate";
+        workflowPath = altWorkflowPath;
+        writeWorkflowTo = altWorkflowPath;
+        mainFileMatchesOptions = false;
+        break;
+      }
+      default:
+        workflowAction = "proposed";
+        diff = renderLineDiff(verdict.existing, verdict.generated);
+        mainFileMatchesOptions = false;
+    }
+  }
+  let configAction;
+  let newConfigContent = null;
+  if (!mainFileMatchesOptions) {
+    configAction = "not-updated";
+  } else {
+    const existingReview = config.parsed?.["review"];
+    if (deepEqual(existingReview, plan.configSnippet)) {
+      configAction = "unchanged";
+    } else {
+      configAction = config.raw === null ? "created" : "updated";
+      newConfigContent = applyJsonEdits(config.raw, [[["review"], plan.configSnippet]]);
+    }
+  }
+  const [dependabotFile] = renderTemplateFiles(generatorFilesDir("add-review", import.meta.url), ".github", {});
+  const existingDependabot = tree.read(DEPENDABOT_PATH, "utf-8");
+  const dependabot = existingDependabot === null ? "created" : /github-actions/.test(existingDependabot) ? "present" : "proposed";
+  const dryRun = options.dryRun ?? false;
+  if (!dryRun) {
+    if (writeWorkflowTo !== null) tree.write(writeWorkflowTo, plan.workflowYaml);
+    if (newConfigContent !== null) tree.write(CONFIG_PATH, newConfigContent);
+    if (dependabot === "created") tree.write(DEPENDABOT_PATH, dependabotFile.content);
+  }
+  return {
+    dryRun,
+    workflowPath,
+    workflowAction,
+    configAction,
+    requiredSecretName: plan.requiredSecretName,
+    diff,
+    workflowYaml: dryRun ? plan.workflowYaml : null,
+    configSnippetJson: dryRun ? JSON.stringify(plan.configSnippet, null, 2) : null,
+    configError: null,
+    dependabot,
+    dependabotProposal: dependabot === "proposed" ? dependabotFile.content : null,
+    ...packageManagerNote !== void 0 ? { packageManagerNote } : {},
+    ...BETA_PROVIDERS.includes(provider) ? { betaProvider: provider } : {}
+  };
+}
+async function addReviewGenerator(tree, options) {
+  console.log(renderAddReviewReport(runAddReview(tree, { ...options, dryRun: resolveDryRun(options) })));
+}
+var generator_default = addReviewGenerator;
+
+export {
+  recordedReview,
+  runAddReview,
+  addReviewGenerator,
+  generator_default
+};

package/dist/generators/_chunks/chunk-5MI3O4VZ.js

@@ -0,0 +1,99 @@
+// src/eslint/fsd-policy.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var PRESETS = {
+  basic: {
+    sliceGroups: { auto: true, include: [], exclude: [] },
+    sharedPublicApi: "segment",
+    testFiles: false,
+    segments: [],
+    platformSuffixes: [],
+    routerDirs: []
+  },
+  practical: {
+    sliceGroups: { auto: true, include: [], exclude: [] },
+    sharedPublicApi: "file",
+    testFiles: ["**/*.{spec,test}.*", "**/__tests__/**"],
+    segments: [],
+    platformSuffixes: [],
+    routerDirs: []
+  }
+};
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function resolveFsdPolicy(recorded, overrides = {}) {
+  const fsd = typeof recorded === "object" && recorded !== null ? recorded : {};
+  const preset = fsd["preset"] === "practical" ? "practical" : "basic";
+  const policy = { ...PRESETS[preset] };
+  const groups = fsd["sliceGroups"];
+  if (groups === false) policy.sliceGroups = false;
+  else if (groups === "auto") policy.sliceGroups = { auto: true, include: [], exclude: [] };
+  else if (typeof groups === "object" && groups !== null) {
+    const value = groups;
+    policy.sliceGroups = {
+      auto: value["auto"] !== false,
+      include: isStringArray(value["include"]) ? value["include"] : [],
+      exclude: isStringArray(value["exclude"]) ? value["exclude"] : []
+    };
+  }
+  const shared = fsd["sharedPublicApi"];
+  if (shared === "segment" || shared === "component" || shared === "file") policy.sharedPublicApi = shared;
+  const tests = fsd["testFiles"];
+  if (tests === false || isStringArray(tests)) policy.testFiles = tests;
+  if (isStringArray(fsd["segments"])) policy.segments = fsd["segments"];
+  if (isStringArray(fsd["platformSuffixes"])) policy.platformSuffixes = fsd["platformSuffixes"];
+  if (isStringArray(fsd["routerDirs"])) policy.routerDirs = fsd["routerDirs"];
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value !== void 0) policy[key] = value;
+  }
+  return policy;
+}
+function readRecordedFsd(from) {
+  for (let dir = from; ; dir = dirname(dir)) {
+    const file = join(dir, "toolkit.config.json");
+    if (existsSync(file)) {
+      try {
+        return JSON.parse(readFileSync(file, "utf-8"))["fsd"];
+      } catch {
+        return void 0;
+      }
+    }
+    if (dirname(dir) === dir) return void 0;
+  }
+}
+var escapeLiteral = (text) => text.replace(/[.+^$()|[\]\\{}]/g, "\\$&");
+function wildcardsToRegExp(glob) {
+  let source = "";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*" && glob[i + 1] === "*") {
+      const slash = glob[i + 2] === "/";
+      source += slash ? "(?:.*/)?" : ".*";
+      i += slash ? 2 : 1;
+    } else if (ch === "*") source += "[^/]*";
+    else if (ch === "?") source += "[^/]";
+    else source += escapeLiteral(ch);
+  }
+  return source;
+}
+function globToRegExp(glob) {
+  let source = "";
+  let rest = glob;
+  for (; ; ) {
+    const open = rest.indexOf("{");
+    const close = open === -1 ? -1 : rest.indexOf("}", open);
+    if (open === -1 || close === -1) {
+      source += wildcardsToRegExp(rest);
+      break;
+    }
+    source += wildcardsToRegExp(rest.slice(0, open));
+    source += `(?:${rest.slice(open + 1, close).split(",").map(wildcardsToRegExp).join("|")})`;
+    rest = rest.slice(close + 1);
+  }
+  return new RegExp(`^${source}$`);
+}
+
+export {
+  resolveFsdPolicy,
+  readRecordedFsd,
+  globToRegExp
+};

package/dist/generators/_chunks/chunk-6ZTIUBB2.js

@@ -0,0 +1,139 @@
+// ../template-engine/dist/backend/eslint-boundaries.js
+var DEFAULT_BOUNDARY_TAGS = { frontend: "scope:frontend", backend: "scope:backend", shared: "scope:shared" };
+function readBoundaryTags(config) {
+  const boundaries = config?.["boundaries"];
+  const tags = typeof boundaries === "object" && boundaries !== null ? boundaries["tags"] : void 0;
+  const pick = (role) => {
+    const value = typeof tags === "object" && tags !== null ? tags[role] : void 0;
+    return typeof value === "string" && value.trim() !== "" ? value : DEFAULT_BOUNDARY_TAGS[role];
+  };
+  return { frontend: pick("frontend"), backend: pick("backend"), shared: pick("shared") };
+}
+function scopeConstraints(tags = DEFAULT_BOUNDARY_TAGS) {
+  return [
+    { sourceTag: tags.frontend, notDependOnLibsWithTags: [tags.backend] },
+    { sourceTag: tags.backend, notDependOnLibsWithTags: [tags.frontend] },
+    { sourceTag: tags.shared, notDependOnLibsWithTags: [tags.frontend, tags.backend] }
+  ];
+}
+var SCOPE_CONSTRAINTS = scopeConstraints();
+var ESLINT_CONFIG_CANDIDATES = ["eslint.config.mjs", "eslint.config.js", "eslint.config.cjs"];
+var appliedMarker = (tags) => `sourceTag: '${tags.frontend}'`;
+var ALLOW_ALL_BLOCK = /depConstraints:\s*\[\s*\{\s*sourceTag:\s*'\*',\s*onlyDependOnLibsWithTags:\s*\[\s*'\*'\s*\],?\s*\},?\s*\]/g;
+function maskComments(text) {
+  const out = text.split("");
+  let mode = "code";
+  let quote = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const d = text[i + 1];
+    if (mode === "code") {
+      if (c === "'" || c === '"' || c === "`") {
+        mode = "string";
+        quote = c;
+      } else if (c === "/" && d === "/") {
+        mode = "line";
+        out[i] = " ";
+      } else if (c === "/" && d === "*") {
+        mode = "block";
+        out[i] = " ";
+      }
+    } else if (mode === "string") {
+      if (c === "\\") {
+        i++;
+      } else if (c === quote) {
+        mode = "code";
+      }
+    } else if (mode === "line") {
+      if (c === "\n") {
+        mode = "code";
+      } else {
+        out[i] = " ";
+      }
+    } else {
+      if (c === "*" && d === "/") {
+        out[i] = " ";
+        out[i + 1] = " ";
+        i++;
+        mode = "code";
+      } else if (c !== "\n") {
+        out[i] = " ";
+      }
+    }
+  }
+  return out.join("");
+}
+function findAllowAllMatches(masked) {
+  const matches = [];
+  ALLOW_ALL_BLOCK.lastIndex = 0;
+  for (let m = ALLOW_ALL_BLOCK.exec(masked); m !== null; m = ALLOW_ALL_BLOCK.exec(masked)) {
+    matches.push({ index: m.index, length: m[0].length });
+  }
+  return matches;
+}
+function classifyBoundaryConstraints(configText, tags = DEFAULT_BOUNDARY_TAGS) {
+  const masked = maskComments(configText);
+  if (masked.includes(appliedMarker(tags)))
+    return "enforced";
+  if (findAllowAllMatches(masked).length > 0)
+    return "allow-all";
+  return "unknown";
+}
+function renderConstraintsBlock(indent, eol, tags) {
+  const renderList = (list) => list.map((t) => `'${t}'`).join(", ");
+  const inner = scopeConstraints(tags).map((c) => {
+    const field = c.notDependOnLibsWithTags ? `notDependOnLibsWithTags: [${renderList(c.notDependOnLibsWithTags)}]` : `onlyDependOnLibsWithTags: [${renderList(c.onlyDependOnLibsWithTags ?? [])}]`;
+    return [`${indent}  {`, `${indent}    sourceTag: '${c.sourceTag}',`, `${indent}    ${field},`, `${indent}  },`].join(eol);
+  }).join(eol);
+  return [
+    `// nx-archweave boundaries \u2014 the frontend and the backend may never import each other`,
+    `${indent}depConstraints: [`,
+    inner,
+    [
+      `${indent}  // baseline: everything else stays allowed (constraints apply conjunctively)`,
+      `${indent}  {`,
+      `${indent}    sourceTag: '*',`,
+      `${indent}    onlyDependOnLibsWithTags: ['*'],`,
+      `${indent}  },`
+    ].join(eol),
+    `${indent}]`
+  ].join(eol);
+}
+function applyBoundaryConstraints(configText, tags = DEFAULT_BOUNDARY_TAGS) {
+  const classification = classifyBoundaryConstraints(configText, tags);
+  if (classification === "enforced")
+    return { status: "already-applied" };
+  if (classification === "unknown")
+    return { status: "unrecognized" };
+  const masked = maskComments(configText);
+  const matches = findAllowAllMatches(masked);
+  if (matches.length !== 1) {
+    return { status: "unrecognized" };
+  }
+  const [match] = matches;
+  const eol = configText.includes("\r\n") ? "\r\n" : "\n";
+  const lineStart = configText.lastIndexOf("\n", match.index) + 1;
+  const indent = /^[ \t]*/.exec(configText.slice(lineStart, match.index))?.[0] ?? "";
+  const replacement = renderConstraintsBlock(indent, eol, tags);
+  const text = configText.slice(0, match.index) + replacement + configText.slice(match.index + match.length);
+  return { status: "applied", text };
+}
+function buildBoundarySnippet(tags = DEFAULT_BOUNDARY_TAGS) {
+  return [
+    "// nx-archweave project boundaries \u2014 merge these entries into the depConstraints",
+    "// array of the '@nx/enforce-module-boundaries' rule in your root ESLint config.",
+    "// They ride on top of your existing entries: constraints apply conjunctively,",
+    "// so the allow-all baseline can stay.",
+    renderConstraintsBlock("", "\n", tags)
+  ].join("\n");
+}
+
+export {
+  DEFAULT_BOUNDARY_TAGS,
+  readBoundaryTags,
+  ESLINT_CONFIG_CANDIDATES,
+  maskComments,
+  classifyBoundaryConstraints,
+  applyBoundaryConstraints,
+  buildBoundarySnippet
+};