@clearlydev/nx-archweave 0.3.2 → 0.4.0

package/dist/generators/_chunks/chunk-L2RZ2LBO.js

@@ -0,0 +1,132 @@
+import {
+  maskComments
+} from "./chunk-6ZTIUBB2.js";
+
+// ../templates/dist/fsd/fsd-eslint.js
+var FSD_ESLINT_MODULE = "@clearlydev/nx-archweave/eslint";
+function buildFsdEslintImportLine() {
+  return `import { fsdBoundaries } from '${FSD_ESLINT_MODULE}';`;
+}
+function buildFsdEslintEntry(severity, root = "src", framework = {}) {
+  const list = (key, values) => values === void 0 || values.length === 0 ? "" : `, ${key}: [${values.map((value) => `'${value}'`).join(", ")}]`;
+  return `...fsdBoundaries({ severity: '${severity}', cwd: import.meta.dirname, root: '${root}'${list("platformSuffixes", framework.platformSuffixes)}${list("routerDirs", framework.routerDirs)} }),`;
+}
+function buildFsdEslintSnippet({ severity, locale, root, framework }) {
+  const lines = locale === "ko" ? [
+    "// nx-archweave FSD \uB808\uC774\uC5B4 \uADDC\uCE59 \u2014 \uD504\uB860\uD2B8\uC5D4\uB4DC \uC571\uC758 eslint.config.mjs\uC5D0 \uC9C1\uC811 \uB123\uC73C\uC138\uC694:",
+    "// 1) \uB9C8\uC9C0\uB9C9 import \uB4A4\uC5D0 \uC544\uB798 import\uB97C,",
+    "// 2) \uC124\uC815 \uBC30\uC5F4(export default [...], \uB610\uB294 export default \uD558\uB294 \uBCC0\uC218\uC758 \uBC30\uC5F4)\uC758 \uB9C8\uC9C0\uB9C9 \uD56D\uBAA9\uC73C\uB85C \uC544\uB798 spread\uB97C \uCD94\uAC00\uD569\uB2C8\uB2E4."
+  ] : [
+    "// nx-archweave FSD layer rules \u2014 add these to the frontend app's eslint.config.mjs yourself:",
+    "// 1) the import after the last import,",
+    "// 2) the spread as the last element of the config array (export default [...], or the array your config exports by name)."
+  ];
+  return [...lines, buildFsdEslintImportLine(), buildFsdEslintEntry(severity, root, framework)].join("\n");
+}
+var LAYER_GUIDE_EN = {
+  app: "composition root: providers, routing, global styles (the framework entry point lives here)",
+  pages: "one slice per screen, composed from the layers below",
+  features: "one slice per user-facing capability (add-to-cart, sign-in)",
+  entities: "one slice per business object (user, product)",
+  shared: "segments, not slices: ui, api, lib, model, config \u2014 named by purpose"
+};
+var LAYER_GUIDE_KO = {
+  app: "\uC870\uD569 \uB8E8\uD2B8: providers, \uB77C\uC6B0\uD305, \uC804\uC5ED \uC2A4\uD0C0\uC77C (\uD504\uB808\uC784\uC6CC\uD06C \uC9C4\uC785\uC810\uC774 \uC5EC\uAE30 \uC788\uC74C)",
+  pages: "\uD654\uBA74 \uD558\uB098\uB2F9 \uC2AC\uB77C\uC774\uC2A4 \uD558\uB098 \u2014 \uC544\uB798 \uB808\uC774\uC5B4\uB4E4\uC744 \uC870\uD569",
+  features: "\uC0AC\uC6A9\uC790 \uAE30\uB2A5 \uD558\uB098\uB2F9 \uC2AC\uB77C\uC774\uC2A4 \uD558\uB098 (add-to-cart, sign-in)",
+  entities: "\uBE44\uC988\uB2C8\uC2A4 \uAC1D\uCCB4 \uD558\uB098\uB2F9 \uC2AC\uB77C\uC774\uC2A4 \uD558\uB098 (user, product)",
+  shared: "\uC2AC\uB77C\uC774\uC2A4\uAC00 \uC544\uB2C8\uB77C \uC138\uADF8\uBA3C\uD2B8: ui, api, lib, model, config \u2014 \uBAA9\uC801\uC73C\uB85C \uC774\uB984 \uC9D3\uAE30"
+};
+function buildFsdLayerGuide({ layers, directories, sourceRoot, locale }) {
+  const guide = locale === "ko" ? LAYER_GUIDE_KO : LAYER_GUIDE_EN;
+  const width = Math.max(...directories.map((d) => d.length));
+  const rows = layers.map((layer, index) => `  ${sourceRoot}/${directories[index].padEnd(width)}  ${guide[layer] ?? ""}`);
+  const footer = locale === "ko" ? [
+    "\uB808\uC774\uC5B4 \uD3F4\uB354\uB294 \uCCAB \uC2AC\uB77C\uC774\uC2A4\uAC00 \uC0DD\uAE38 \uB54C \uB9CC\uB4E4\uC5B4\uC9D1\uB2C8\uB2E4 (\uC815\uC2DD FSD):",
+    "  nx g @clearlydev/nx-archweave:feature --name=<name>   (page, entity, shared\uB3C4 \uAC19\uC740 \uBC29\uC2DD; --segments=ui,api)",
+    "  widgets/ \uB808\uC774\uC5B4\uB294 \uAE30\uBCF8 \uBC94\uC704 \uBC16\uC774\uC9C0\uB9CC nx g @clearlydev/nx-archweave:widget \uC73C\uB85C \uC4F8 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
+    "\uC704\uC5D0\uC11C \uC544\uB798\uB85C\uB9CC import\uD560 \uC218 \uC788\uACE0, \uAC19\uC740 \uB808\uC774\uC5B4\uC758 \uC2AC\uB77C\uC774\uC2A4\uB07C\uB9AC\uB294 import\uD558\uC9C0 \uC54A\uC73C\uBA70, \uC2AC\uB77C\uC774\uC2A4\uB294",
+    "index.ts\uB97C \uD1B5\uD574\uC11C\uB9CC import\uD569\uB2C8\uB2E4 \u2014 archweave/fsd-boundaries ESLint \uADDC\uCE59\uC774 \uC704\uBC18\uC744 \uC54C\uB824 \uC90D\uB2C8\uB2E4."
+  ] : [
+    "Layer directories appear with their first slice (canonical FSD):",
+    "  nx g @clearlydev/nx-archweave:feature --name=<name>   (page, entity and shared work the same way; --segments=ui,api)",
+    "  widgets/ is outside the default scope but one command away: nx g @clearlydev/nx-archweave:widget",
+    "Imports go downward only, slices on one layer never import each other, and a slice is",
+    "imported through its index.ts \u2014 the archweave/fsd-boundaries ESLint rule reports violations."
+  ];
+  return [...rows, ...footer].join("\n");
+}
+
+// ../template-engine/dist/fsd/fsd-eslint-config.js
+function classifyFsdEslintConfig(configText) {
+  return maskComments(configText).includes(FSD_ESLINT_MODULE) ? "applied" : "absent";
+}
+var EXPORT_DEFAULT_ARRAY = /export\s+default\s+\[/g;
+var IMPORT_STATEMENT = /^import\b[^;]*?\bfrom\s+['"][^'"]+['"]\s*;?[ \t]*$/gm;
+var CLOSING_BRACKET = /\]\s*;?\s*$/;
+function closingBracketOf(masked, open) {
+  let depth = 0;
+  for (let i = open; i < masked.length; i++) {
+    const ch = masked[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      for (i++; i < masked.length && masked[i] !== ch; i++)
+        if (masked[i] === "\\")
+          i++;
+      continue;
+    }
+    if (ch === "[")
+      depth++;
+    else if (ch === "]" && --depth === 0)
+      return i;
+  }
+  return -1;
+}
+function namedConfigArrayEnd(masked) {
+  const exported = [...masked.matchAll(/export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/g)];
+  if (exported.length !== 1)
+    return -1;
+  const declaration = new RegExp(`(?:const|let|var)\\s+${exported[0][1].replace(/\$/g, "\\$")}\\s*=\\s*(?:defineConfig\\s*\\(\\s*)?\\[`).exec(masked);
+  if (declaration === null)
+    return -1;
+  return closingBracketOf(masked, declaration.index + declaration[0].length - 1);
+}
+function applyFsdEslintConfig(configText, severity, root = "src", framework = {}) {
+  if (classifyFsdEslintConfig(configText) === "applied")
+    return { status: "already-applied" };
+  const masked = maskComments(configText);
+  EXPORT_DEFAULT_ARRAY.lastIndex = 0;
+  const exportMatches = masked.match(EXPORT_DEFAULT_ARRAY) ?? [];
+  const closing = CLOSING_BRACKET.exec(masked);
+  const closingIndex = exportMatches.length === 1 && closing !== null ? closing.index : namedConfigArrayEnd(masked);
+  if (closingIndex === -1)
+    return { status: "unrecognized" };
+  const eol = configText.includes("\r\n") ? "\r\n" : "\n";
+  const before = configText.slice(0, closingIndex);
+  const lastNonSpace = before.replace(/\s+$/, "");
+  const needsComma = !lastNonSpace.endsWith(",") && !lastNonSpace.endsWith("[");
+  const entryText = `${needsComma ? "," : ""}${eol}  ${buildFsdEslintEntry(severity, root, framework)}${eol}`;
+  const withEntry = `${lastNonSpace}${entryText}${configText.slice(closingIndex)}`;
+  IMPORT_STATEMENT.lastIndex = 0;
+  let lastImportEnd = -1;
+  const maskedWithEntry = maskComments(withEntry);
+  for (let m = IMPORT_STATEMENT.exec(maskedWithEntry); m !== null; m = IMPORT_STATEMENT.exec(maskedWithEntry)) {
+    lastImportEnd = m.index + m[0].length;
+  }
+  const importLine = buildFsdEslintImportLine();
+  const text = lastImportEnd === -1 ? `${importLine}${eol}${eol}${withEntry}` : `${withEntry.slice(0, lastImportEnd)}${eol}${importLine}${withEntry.slice(lastImportEnd)}`;
+  return { status: "applied", text };
+}
+function buildFsdEslintPasteSnippet(severity, locale, root = "src", framework = {}) {
+  return buildFsdEslintSnippet({ severity, locale, root, framework });
+}
+function composeFsdLayerGuide({ profile, sourceRoot, locale }) {
+  const layers = [...profile.layers];
+  return buildFsdLayerGuide({ layers, directories: layers.map((layer) => profile.layerDirs[layer] ?? layer), sourceRoot, locale });
+}
+
+export {
+  classifyFsdEslintConfig,
+  applyFsdEslintConfig,
+  buildFsdEslintPasteSnippet,
+  composeFsdLayerGuide
+};

package/dist/generators/_chunks/chunk-MQNQJOWA.js

@@ -0,0 +1,217 @@
+import {
+  globToRegExp,
+  resolveFsdPolicy
+} from "./chunk-5MI3O4VZ.js";
+
+// src/eslint/fsd-boundaries.ts
+import { posix, relative, resolve, sep } from "node:path";
+
+// src/eslint/slice-groups.ts
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+var SEGMENTS = [
+  "ui",
+  "model",
+  "api",
+  "lib",
+  "config",
+  "components",
+  "hooks",
+  "types",
+  "utils",
+  "helpers",
+  "constants",
+  "consts",
+  "store",
+  "stores",
+  "styles",
+  "assets",
+  "services",
+  "context"
+];
+var IGNORED = /^(\.|readme(\.|$))/i;
+var listings = /* @__PURE__ */ new Map();
+function list(dir) {
+  let mtimeMs;
+  try {
+    mtimeMs = statSync(dir).mtimeMs;
+  } catch {
+    listings.delete(dir);
+    return null;
+  }
+  const cached = listings.get(dir);
+  if (cached !== void 0 && cached.mtimeMs === mtimeMs) return cached.entries;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true }).map((entry) => ({ name: entry.name, directory: entry.isDirectory() }));
+    listings.set(dir, { mtimeMs, entries });
+    return entries;
+  } catch {
+    return null;
+  }
+}
+function createGroupDetector(rootAbsolute, policy, isIndexFile, listDirectory = list) {
+  const groups = policy.sliceGroups;
+  if (groups === false) return () => false;
+  const segments = /* @__PURE__ */ new Set([...SEGMENTS, ...policy.segments]);
+  return (layerDir, name) => {
+    const key = `${layerDir}/${name}`;
+    if (groups.include.includes(key)) return true;
+    if (groups.exclude.includes(key) || !groups.auto) return false;
+    const entries = listDirectory(join(rootAbsolute, layerDir, name))?.filter((entry) => !IGNORED.test(entry.name)) ?? null;
+    if (entries === null || entries.length === 0) return false;
+    if (entries.some((entry) => !entry.directory || segments.has(entry.name))) return false;
+    return entries.some((entry) => listDirectory(join(rootAbsolute, layerDir, name, entry.name))?.some((child) => !child.directory && isIndexFile(child.name)) ?? false);
+  };
+}
+
+// src/eslint/fsd-boundaries.ts
+var LAYER_ORDER = ["app", "pages", "widgets", "features", "entities", "shared"];
+var LAYER_BY_DIR = {
+  app: "app",
+  _app: "app",
+  pages: "pages",
+  _pages: "pages",
+  widgets: "widgets",
+  features: "features",
+  entities: "entities",
+  shared: "shared"
+};
+var SLICED_LAYERS = /* @__PURE__ */ new Set(["pages", "widgets", "features", "entities"]);
+function indexFilePattern(platformSuffixes) {
+  const platforms = platformSuffixes.length === 0 ? "" : `(\\.(${platformSuffixes.map((suffix) => suffix.replace(/[^a-z0-9-]/gi, "")).join("|")}))?`;
+  return new RegExp(`^index${platforms}(\\.[cm]?[jt]sx?)?$`);
+}
+var DEFAULT_POLICY = resolveFsdPolicy(void 0);
+var NO_GROUPS = () => false;
+function locate(rootRelativePath, policy = DEFAULT_POLICY, isGroup = NO_GROUPS) {
+  const segments = rootRelativePath.split("/").filter((s) => s.length > 0 && s !== ".");
+  if (segments.length === 0) return null;
+  const layer = policy.routerDirs.includes(segments[0]) ? "app" : LAYER_BY_DIR[segments[0]];
+  if (layer === void 0) return null;
+  let unit;
+  let rest;
+  if (layer === "app") {
+    unit = null;
+    rest = segments.slice(1);
+  } else if (layer === "shared") {
+    const component = policy.sharedPublicApi === "component" && segments.length > 2;
+    unit = segments[1] === void 0 ? null : component ? `${segments[1]}/${segments[2]}` : segments[1];
+    rest = policy.sharedPublicApi === "file" ? [] : segments.slice(component ? 3 : 2);
+  } else if (segments[1] !== void 0 && isGroup(segments[0], segments[1])) {
+    if (segments[2] === void 0) return { layer, unit: segments[1], rest: [], group: true };
+    unit = `${segments[1]}/${segments[2]}`;
+    rest = segments.slice(3);
+  } else {
+    unit = segments[1] ?? null;
+    rest = segments.slice(2);
+  }
+  if (rest.length > 0 && indexFilePattern(policy.platformSuffixes).test(rest[rest.length - 1])) rest.pop();
+  return { layer, unit, rest };
+}
+function judge(from, to) {
+  if (LAYER_ORDER.indexOf(to.layer) < LAYER_ORDER.indexOf(from.layer)) return { kind: "upward", from, to };
+  if (to.unit === null) return null;
+  if (to.group) return { kind: "group", from, to };
+  const sameUnit = from.layer === to.layer && from.unit === to.unit;
+  if (sameUnit) return null;
+  const importerSlice = from.unit?.split("/").pop();
+  const viaCrossImportApi = to.rest[0] === "@x" && to.rest[1] === importerSlice && from.layer === to.layer;
+  if (viaCrossImportApi) return null;
+  if (from.layer === to.layer && SLICED_LAYERS.has(to.layer)) return { kind: "cross-slice", from, to };
+  if (to.rest.length > 0) return { kind: "sidestep", from, to };
+  return null;
+}
+function describeLocation(location) {
+  return location.unit === null ? location.layer : `${location.layer}/${location.unit}`;
+}
+function resolveSpecifier(specifier, importerRootRelative, options) {
+  let rootRelative = null;
+  if (specifier.startsWith("./") || specifier.startsWith("../") || specifier === "." || specifier === "..") {
+    rootRelative = posix.normalize(posix.join(posix.dirname(importerRootRelative), specifier));
+  } else {
+    for (const [prefix, target] of Object.entries(options.aliases)) {
+      if (!specifier.startsWith(prefix)) continue;
+      const absolute = resolve(resolve(options.cwd, target), specifier.slice(prefix.length));
+      rootRelative = toPosix(relative(options.rootAbsolute, absolute)) || ".";
+      break;
+    }
+  }
+  if (rootRelative === null) return null;
+  if (rootRelative === ".." || rootRelative.startsWith("../")) return null;
+  return rootRelative;
+}
+function toPosix(path) {
+  return sep === "/" ? path : path.split(sep).join("/");
+}
+var fsdBoundariesRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce canonical Feature-Sliced Design import rules inside a frontend app",
+      url: "https://github.com/clearlydev/nx-archweave#fsd-lite"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          root: { type: "string" },
+          aliases: { type: "object", additionalProperties: { type: "string" } },
+          policy: { type: "object" }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      upward: 'FSD: "{{from}}" may not import from "{{to}}" (a higher layer).',
+      crossSlice: 'FSD: "{{from}}" may not import a sibling slice "{{to}}" \u2014 move the shared part down a layer, or expose it through "{{to}}/@x/{{fromUnit}}".',
+      sidestep: 'FSD: import "{{to}}" through its public API (index.ts), not its internal file "{{path}}".',
+      group: 'FSD: "{{to}}" is a group of slices, not a slice \u2014 import one of its slices through its index.ts.'
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const root = options.root ?? "src";
+    const aliases = options.aliases ?? { "@/": root };
+    const cwd = context.cwd;
+    const rootAbsolute = resolve(cwd, root);
+    const importerRootRelative = toPosix(relative(rootAbsolute, context.filename));
+    if (importerRootRelative === "" || importerRootRelative.startsWith("..")) return {};
+    const policy = resolveFsdPolicy(void 0, options.policy ?? {});
+    const isIndexFile = (name) => indexFilePattern(policy.platformSuffixes).test(name);
+    const isGroup = createGroupDetector(rootAbsolute, policy, isIndexFile);
+    const from = locate(importerRootRelative, policy, isGroup);
+    if (from === null) return {};
+    const isTestFile = policy.testFiles !== false && policy.testFiles.some((glob) => globToRegExp(glob).test(importerRootRelative));
+    const check = (node, specifier) => {
+      if (typeof specifier !== "string") return;
+      const target = resolveSpecifier(specifier, importerRootRelative, { rootAbsolute, cwd, aliases });
+      if (target === null) return;
+      const to = locate(target, policy, isGroup);
+      if (to === null) return;
+      const violation = judge(from, to);
+      if (violation === null || isTestFile && violation.kind !== "upward") return;
+      const data = { from: describeLocation(from), to: describeLocation(to), fromUnit: from.unit?.split("/").pop() ?? "", path: target };
+      context.report({
+        node,
+        messageId: violation.kind === "cross-slice" ? "crossSlice" : violation.kind,
+        data
+      });
+    };
+    const fromSource = (node) => check(node, node.source?.value);
+    return {
+      ImportDeclaration: fromSource,
+      ExportNamedDeclaration: fromSource,
+      ExportAllDeclaration: fromSource,
+      ImportExpression: (node) => {
+        const argument = node.source;
+        if (argument && argument.type === "Literal") check(node, argument.value);
+      }
+    };
+  }
+};
+
+export {
+  createGroupDetector,
+  indexFilePattern,
+  fsdBoundariesRule
+};

package/dist/generators/_chunks/chunk-QQNDYJTR.js

@@ -0,0 +1,243 @@
+import {
+  DEFAULT_BOUNDARY_TAGS
+} from "./chunk-6ZTIUBB2.js";
+
+// ../templates/dist/backend/shared-types.js
+function sharedTypesIndexContent() {
+  return `export * from './lib/api-types.js';
+`;
+}
+function sharedTypesApiTypesContent() {
+  return [
+    "// Types shared between the frontend and the backend live here.",
+    "// Example: the api app returns this from GET /api/health, and the",
+    "// frontend consumes the same shape \u2014 one definition, no drift.",
+    "export interface ApiHealthResponse {",
+    "  status: 'ok';",
+    "}",
+    ""
+  ].join("\n");
+}
+function sharedTypesPackageJsonContent(packageName, sharedTag = "scope:shared") {
+  return `${JSON.stringify({
+    name: packageName,
+    version: "0.0.1",
+    private: true,
+    type: "module",
+    main: "./src/index.ts",
+    types: "./src/index.ts",
+    exports: {
+      ".": {
+        types: "./src/index.ts",
+        import: "./src/index.ts",
+        default: "./src/index.ts"
+      }
+    },
+    nx: {
+      projectType: "library",
+      tags: [sharedTag],
+      targets: {}
+    }
+  }, null, 2)}
+`;
+}
+
+// ../template-engine/dist/backend/compose-backend-wiring.js
+var DEFAULT_SHARED_TYPES_ROOT = "libs/shared-types";
+function readSharedTypesConfig(config) {
+  const value = config?.["sharedTypes"];
+  if (value === false)
+    return false;
+  if (typeof value !== "object" || value === null)
+    return { path: DEFAULT_SHARED_TYPES_ROOT };
+  const record = value;
+  const path = typeof record["path"] === "string" && record["path"].trim() !== "" ? record["path"].replace(/\/+$/, "") : DEFAULT_SHARED_TYPES_ROOT;
+  const importPath = typeof record["importPath"] === "string" && record["importPath"].trim() !== "" ? record["importPath"] : void 0;
+  return importPath === void 0 ? { path } : { path, importPath };
+}
+function composeBackendWiring(input) {
+  const scoped = /^@([^/]+)\//.exec(input.workspaceName);
+  const scope = scoped ? `@${scoped[1]}` : `@${input.workspaceName.split("/").pop() || "workspace"}`;
+  const sharedTypesRoot = input.sharedTypes?.path ?? DEFAULT_SHARED_TYPES_ROOT;
+  const sharedTypesPackageName = input.sharedTypes?.importPath ?? `${scope}/shared-types`;
+  const tagByRole = input.tags ?? DEFAULT_BOUNDARY_TAGS;
+  return {
+    sharedTypesFiles: [
+      { filePath: `${sharedTypesRoot}/package.json`, content: sharedTypesPackageJsonContent(sharedTypesPackageName, tagByRole.shared) },
+      { filePath: `${sharedTypesRoot}/src/index.ts`, content: sharedTypesIndexContent() },
+      { filePath: `${sharedTypesRoot}/src/lib/api-types.ts`, content: sharedTypesApiTypesContent() }
+    ],
+    sharedTypesPackageName,
+    sharedTypesRoot,
+    tagByRole
+  };
+}
+function addSharedTypesNpmWorkspace(packageJsonText, entry = DEFAULT_SHARED_TYPES_ROOT) {
+  let parsed;
+  try {
+    parsed = JSON.parse(packageJsonText);
+  } catch {
+    return { status: "unrecognized" };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+    return { status: "unrecognized" };
+  const pkg = parsed;
+  const field = pkg["workspaces"];
+  let target;
+  if (field === void 0) {
+    target = [];
+  } else if (Array.isArray(field)) {
+    target = field;
+  } else if (field !== null && typeof field === "object" && Array.isArray(field.packages)) {
+    target = field.packages;
+  } else {
+    return { status: "unrecognized" };
+  }
+  const parentGlob = `${entry.split("/").slice(0, -1).join("/")}/*`;
+  if (target.some((existing) => existing === entry || existing === parentGlob))
+    return { status: "present" };
+  const surgical = insertSharedTypesWorkspace(packageJsonText, field === void 0 ? "absent" : Array.isArray(field) ? "array" : "object", JSON.stringify(entry));
+  if (surgical !== null)
+    return { status: "added", text: surgical };
+  if (field === void 0)
+    pkg["workspaces"] = target;
+  target.push(entry);
+  const indent = /\n([ \t]+)"/.exec(packageJsonText)?.[1] ?? "  ";
+  const trailing = packageJsonText.endsWith("\n") ? "\n" : "";
+  return { status: "added", text: `${JSON.stringify(pkg, null, indent)}${trailing}` };
+}
+function skipJsonValue(text, start) {
+  if (text[start] === '"') {
+    let i = start + 1;
+    while (i < text.length && text[i] !== '"')
+      i += text[i] === "\\" ? 2 : 1;
+    return i + 1;
+  }
+  if (text[start] === "[" || text[start] === "{") {
+    let depth = 0;
+    let i = start;
+    while (i < text.length) {
+      const c = text[i];
+      if (c === '"') {
+        i = skipJsonValue(text, i);
+        continue;
+      }
+      if (c === "[" || c === "{")
+        depth++;
+      if (c === "]" || c === "}") {
+        depth--;
+        if (depth === 0)
+          return i + 1;
+      }
+      i++;
+    }
+    return -1;
+  }
+  const literal = /^[^,}\]\s]+/.exec(text.slice(start));
+  return literal ? start + literal[0].length : -1;
+}
+function objectMembers(text, open) {
+  const members = [];
+  let i = open + 1;
+  for (; ; ) {
+    while (/[\s,]/.test(text[i] ?? ""))
+      i++;
+    if (text[i] === "}")
+      return members;
+    if (text[i] !== '"')
+      return null;
+    const keyEnd = skipJsonValue(text, i);
+    const key = JSON.parse(text.slice(i, keyEnd));
+    i = keyEnd;
+    while (/\s/.test(text[i] ?? ""))
+      i++;
+    if (text[i] !== ":")
+      return null;
+    i++;
+    while (/\s/.test(text[i] ?? ""))
+      i++;
+    const valueEnd = skipJsonValue(text, i);
+    if (valueEnd === -1)
+      return null;
+    members.push({ key, valueStart: i, valueEnd });
+    i = valueEnd;
+  }
+}
+function appendToArray(text, open, close, eol, quoted) {
+  const inner = text.slice(open + 1, close - 1);
+  if (inner.trim() === "")
+    return `${text.slice(0, open + 1)}${quoted}${text.slice(close - 1)}`;
+  if (!inner.includes("\n")) {
+    const body = inner.replace(/\s+$/, "");
+    return `${text.slice(0, open + 1)}${body}, ${quoted}${inner.slice(body.length)}${text.slice(close - 1)}`;
+  }
+  const lastEntryLineStart = text.lastIndexOf("\n", open + 1 + inner.trimEnd().length - 1) + 1;
+  const itemIndent = /^[ \t]*/.exec(text.slice(lastEntryLineStart))?.[0] ?? "  ";
+  const bodyEnd = open + 1 + inner.trimEnd().length;
+  return `${text.slice(0, bodyEnd)},${eol}${itemIndent}${quoted}${text.slice(bodyEnd)}`;
+}
+function insertSharedTypesWorkspace(text, form, quoted) {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const rootOpen = text.indexOf("{");
+  if (rootOpen === -1)
+    return null;
+  const members = objectMembers(text, rootOpen);
+  if (members === null)
+    return null;
+  const workspaces = members.find((member) => member.key === "workspaces");
+  if (form === "absent") {
+    const last = members[members.length - 1];
+    const indent = /\n([ \t]+)"/.exec(text)?.[1] ?? "  ";
+    if (last === void 0) {
+      const close = skipJsonValue(text, rootOpen) - 1;
+      return `${text.slice(0, rootOpen + 1)}${eol}${indent}"workspaces": [${quoted}]${eol}${text.slice(close)}`;
+    }
+    return `${text.slice(0, last.valueEnd)},${eol}${indent}"workspaces": [${quoted}]${text.slice(last.valueEnd)}`;
+  }
+  if (workspaces === void 0)
+    return null;
+  if (form === "array") {
+    if (text[workspaces.valueStart] !== "[")
+      return null;
+    return appendToArray(text, workspaces.valueStart, workspaces.valueEnd, eol, quoted);
+  }
+  if (text[workspaces.valueStart] !== "{")
+    return null;
+  const packages = objectMembers(text, workspaces.valueStart)?.find((member) => member.key === "packages");
+  if (packages === void 0 || text[packages.valueStart] !== "[")
+    return null;
+  return appendToArray(text, packages.valueStart, packages.valueEnd, eol, quoted);
+}
+function addSharedTypesWorkspaceGlob(yamlText, entry = DEFAULT_SHARED_TYPES_ROOT) {
+  const escape = (value) => value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+  const parentGlob = `${entry.split("/").slice(0, -1).join("/")}/*`;
+  if (new RegExp(`^\\s*-\\s*['"]?(${escape(entry)}|${escape(parentGlob)})['"]?\\s*$`, "m").test(yamlText)) {
+    return { status: "present" };
+  }
+  const lines = yamlText.split("\n");
+  const packagesIndex = lines.findIndex((line) => /^packages:\s*$/.test(line));
+  if (packagesIndex === -1)
+    return { status: "unrecognized" };
+  let lastEntry = packagesIndex;
+  for (let i = packagesIndex + 1; i < lines.length; i++) {
+    if (/^\s+-\s+\S/.test(lines[i])) {
+      lastEntry = i;
+    } else if (lines[i].trim() === "") {
+      continue;
+    } else {
+      break;
+    }
+  }
+  if (lastEntry === packagesIndex)
+    return { status: "unrecognized" };
+  const indent = /^(\s+)-/.exec(lines[lastEntry])?.[1] ?? "  ";
+  lines.splice(lastEntry + 1, 0, `${indent}- '${entry}'`);
+  return { status: "added", text: lines.join("\n") };
+}
+
+export {
+  readSharedTypesConfig,
+  composeBackendWiring,
+  addSharedTypesNpmWorkspace,
+  addSharedTypesWorkspaceGlob
+};

package/dist/generators/_chunks/chunk-SNBIVIMI.js

@@ -0,0 +1,89 @@
+import {
+  generatorFilesDir,
+  renderTemplateFiles
+} from "./chunk-YNMLB4DL.js";
+import {
+  resolveDryRun
+} from "./chunk-TUN34LAQ.js";
+import {
+  readToolkitConfig,
+  resolveLocaleOption
+} from "./chunk-EXYZLL7A.js";
+
+// src/generators/add-github-templates/generator.ts
+import { join } from "node:path";
+
+// src/generators/add-github-templates/render.ts
+var ACTION_LINES = {
+  created: "created",
+  unchanged: "unchanged (already matches the generated version)",
+  skipped: "left as-is (a different file already exists there \u2014 never overwritten)"
+};
+function renderAddGithubTemplatesReport(report) {
+  const lines = [];
+  if (report.files.length === 0) {
+    lines.push("add-github-templates: nothing selected (issue/pr/codeowners all false) \u2014 no files to install.");
+    return lines.join("\n");
+  }
+  if (report.dryRun) {
+    lines.push("add-github-templates dry-run \u2014 no files were written.");
+    lines.push("");
+    for (const file of report.files) {
+      lines.push(`${file.filePath}:`);
+      lines.push(file.content);
+      lines.push("");
+    }
+    lines.push("Effective decision:");
+  }
+  for (const file of report.files) {
+    lines.push(`  ${file.filePath}: ${ACTION_LINES[file.action]}`);
+  }
+  return lines.join("\n");
+}
+
+// src/generators/add-github-templates/generator.ts
+var BUG_REPORT_PATH = ".github/ISSUE_TEMPLATE/bug-report.yml";
+var FEATURE_REQUEST_PATH = ".github/ISSUE_TEMPLATE/feature-request.yml";
+var PULL_REQUEST_TEMPLATE_PATH = ".github/PULL_REQUEST_TEMPLATE.md";
+var CODEOWNERS_PATH = ".github/CODEOWNERS";
+function composeGithubTemplates(groups, locale) {
+  const files = generatorFilesDir("add-github-templates", import.meta.url);
+  return ["issue", "pr", "codeowners"].filter((group) => groups[group]).flatMap((group) => renderTemplateFiles(join(files, locale, group), ".", {}));
+}
+function runAddGithubTemplates(tree, options) {
+  const locale = resolveLocaleOption(options.locale, readToolkitConfig(tree));
+  const plan = composeGithubTemplates(
+    { issue: options.issue ?? false, pr: options.pr ?? true, codeowners: options.codeowners ?? false },
+    locale
+  );
+  const dryRun = options.dryRun ?? false;
+  const files = plan.map(({ filePath, content }) => {
+    const existing = tree.read(filePath, "utf-8");
+    let action;
+    if (existing === null) {
+      action = "created";
+      if (!dryRun) tree.write(filePath, content);
+    } else if (existing === content) {
+      action = "unchanged";
+    } else {
+      action = "skipped";
+    }
+    return { filePath, action, content };
+  });
+  return { dryRun, files };
+}
+async function addGithubTemplatesGenerator(tree, options) {
+  console.log(renderAddGithubTemplatesReport(runAddGithubTemplates(tree, { ...options, dryRun: resolveDryRun(options) })));
+}
+var generator_default = addGithubTemplatesGenerator;
+
+export {
+  renderAddGithubTemplatesReport,
+  BUG_REPORT_PATH,
+  FEATURE_REQUEST_PATH,
+  PULL_REQUEST_TEMPLATE_PATH,
+  CODEOWNERS_PATH,
+  runAddGithubTemplates,
+  addGithubTemplatesGenerator,
+  generator_default
+};