@clearlydev/nx-archweave 0.0.0-stage → 0.1.1

package/dist/generators/add-backend/render.js

@@ -0,0 +1,102 @@
+import { packageManagerCommands } from '@nx-archweave/template-engine';
+/** Section body, no header — init prints its own `## add-backend` title and
+ * dry-run marker, so the body must not repeat them. */
+export function renderAddBackendBody(report) {
+    const lines = [];
+    if (report.refused === 'no-frontend') {
+        lines.push(`Refused: no frontend application and no "${report.apiName}" app found in this workspace.`);
+        lines.push('  add-backend wires a backend app — beside a frontend, or on its own in a backend-only');
+        lines.push(`  workspace (create one with: npx create-nx-workspace --preset=${report.backend} --appName=${report.apiName}).`);
+        lines.push('  If the backend app has another name, pass --apiName=<its directory name>.');
+        return lines.join('\n');
+    }
+    if (report.refused === 'frontend-not-found') {
+        lines.push(`Refused: --frontendProject "${report.frontendProject}" does not match any project.`);
+        lines.push('  Nothing was written. Check the name with `nx show projects`.');
+        return lines.join('\n');
+    }
+    if (report.refused === 'ambiguous-frontend') {
+        lines.push('Refused: multiple frontend applications found — add-backend will not guess:');
+        for (const name of report.frontendCandidates ?? [])
+            lines.push(`  - ${name}`);
+        lines.push('  Nothing was written. Re-run with --frontendProject=<name> to pick one.');
+        return lines.join('\n');
+    }
+    if (report.refused === 'invalid-project-json') {
+        lines.push('Refused: a project.json this run must update could not be parsed:');
+        for (const path of report.invalidProjects ?? [])
+            lines.push(`  - ${path}`);
+        lines.push('  Nothing was written — fix the JSON, then re-run add-backend.');
+        return lines.join('\n');
+    }
+    if (report.refused === 'missing-api-project') {
+        lines.push(`Refused: no "${report.apiName}" application project found.`);
+        lines.push('  Create it with the official commands first (copy-paste, names already filled in),');
+        lines.push('  then re-run add-backend to wire it up:');
+        lines.push('');
+        for (const command of report.commands ?? [])
+            lines.push(`    ${command}`);
+        if (report.expressRange !== undefined) {
+            lines.push('');
+            lines.push(`  The express line declares express@${report.expressRange}, the range this workspace's @nx/react supports —`);
+            lines.push('  the official generator then keeps it instead of adding express 5, which npm rejects as a peer conflict.');
+        }
+        return lines.join('\n');
+    }
+    if (report.packageManagerNote !== undefined)
+        lines.push(`  note: ${report.packageManagerNote}`);
+    lines.push(`  frontend project: ${report.frontendProject ?? 'none (backend-only workspace)'}`);
+    lines.push(report.sharedTypes === 'created'
+        ? `  libs/shared-types: created (import it as ${report.sharedTypesPackage})`
+        : '  libs/shared-types: already exists — skipped');
+    if (report.config !== undefined && report.config !== 'unchanged') {
+        lines.push(`  toolkit.config.json: backend "${report.backend}" recorded (${report.config}) — doctor's backend checks now run`);
+    }
+    if (report.workspaceGlob !== undefined) {
+        const pmName = report.packageManager ?? 'pnpm';
+        const registry = packageManagerCommands(pmName).workspaceRegistration;
+        lines.push({
+            added: `  ${registry}: 'libs/shared-types' registered — run \`${pmName} install\` once to link it`,
+            present: `  ${registry}: already covers libs/shared-types`,
+            unrecognized: 
+            // an integrated layout lists no workspace packages: the paths alias below links it
+            report.tsconfigPaths === 'added' || report.tsconfigPaths === 'present'
+                ? `  ${registry}: no workspace package list (integrated layout) — the tsconfig paths alias links libs/shared-types`
+                : `  ${registry}: shape not recognized — add 'libs/shared-types' to its workspace list yourself`,
+        }[report.workspaceGlob]);
+    }
+    for (const tag of report.tags) {
+        lines.push(`  tag ${tag.project}: ${tag.action === 'added' ? 'added' : 'already present'}`);
+    }
+    lines.push({
+        added: `  tsconfig.base.json paths: ${report.sharedTypesPackage} added (a classic or integrated setup — libs resolve through paths)`,
+        present: '  tsconfig.base.json paths: already wired',
+        'workspace-link': '  tsconfig paths: not needed — the workspace package link is the wiring',
+        unrecognized: '  tsconfig.base.json: could not be parsed — left untouched',
+    }[report.tsconfigPaths]);
+    switch (report.eslint) {
+        case 'applied':
+            lines.push('  ESLint boundaries: cross-side deny rules written (existing imports stay allowed)');
+            break;
+        case 'already-applied':
+            lines.push('  ESLint boundaries: already enforced — no change');
+            break;
+        case 'degraded-unrecognized':
+            lines.push('  ESLint boundaries: your config was NOT recognized — left untouched.');
+            lines.push('  Merge this yourself (then boundaries are actually enforced):');
+            break;
+        case 'snippet-only':
+            lines.push('  ESLint boundaries: report-only (pass --applyEslint to write them).');
+            lines.push('  Paste-ready snippet:');
+            break;
+    }
+    if (report.snippet) {
+        lines.push('');
+        lines.push(report.snippet);
+    }
+    return lines.join('\n');
+}
+/** Standalone rendering (the add-backend generator's own console output). */
+export function renderAddBackendReport(report, dryRun) {
+    return [`add-backend (${report.backend})${dryRun ? ' — dry run' : ''}`, '', renderAddBackendBody(report)].join('\n');
+}

package/dist/generators/add-fsd-lite/generator.js

@@ -0,0 +1,553 @@
+// ../shared/dist/lib/toolkit-config.js
+function readFsdEnforcement(fsd) {
+  if (typeof fsd !== "object" || fsd === null)
+    return void 0;
+  const enforcement = fsd["enforcement"];
+  return enforcement === "error" || enforcement === "warn" ? enforcement : void 0;
+}
+
+// ../template-engine/dist/environment/package-manager.js
+var LOCKFILES = [
+  ["yarn", ["yarn.lock"]],
+  ["bun", ["bun.lock", "bun.lockb"]],
+  ["npm", ["package-lock.json"]]
+];
+function detectWorkspacePackageManager(exists, read = () => void 0) {
+  if (exists("pnpm-lock.yaml") || exists("pnpm-workspace.yaml"))
+    return "pnpm";
+  const found = LOCKFILES.filter(([, files]) => files.some((file) => exists(file))).map(([pm]) => pm);
+  if (found.length <= 1)
+    return found[0] ?? null;
+  const declared = /"packageManager"\s*:\s*"(npm|yarn|bun)@/.exec(read("package.json") ?? "")?.[1];
+  const named = found.find((pm) => pm === declared);
+  if (named)
+    return named;
+  return found.includes("npm") ? "npm" : found[0];
+}
+function detectYarnFlavor(exists, read) {
+  if (exists(".yarnrc.yml"))
+    return "berry";
+  if (/^__metadata:/m.test(read("yarn.lock") ?? ""))
+    return "berry";
+  const major = /"packageManager"\s*:\s*"yarn@(\d+)\./.exec(read("package.json") ?? "")?.[1];
+  return major !== void 0 && Number(major) >= 2 ? "berry" : "classic";
+}
+function packageManagerCommands(pm, flavor = "classic") {
+  switch (pm) {
+    case "pnpm":
+      return { addDevAtRoot: (spec) => `pnpm add -D -w ${spec}`, addAtRoot: (spec) => `pnpm add -w ${spec}`, runNx: "pnpm nx", install: "pnpm install", workspaceRegistration: "pnpm-workspace.yaml" };
+    case "yarn":
+      return {
+        addDevAtRoot: (spec) => flavor === "berry" ? `yarn add -D ${spec}` : `yarn add -D -W ${spec}`,
+        addAtRoot: (spec) => flavor === "berry" ? `yarn add ${spec}` : `yarn add -W ${spec}`,
+        runNx: "yarn nx",
+        install: "yarn install",
+        workspaceRegistration: "package.json workspaces"
+      };
+    case "bun":
+      return { addDevAtRoot: (spec) => `bun add -d ${spec}`, addAtRoot: (spec) => `bun add ${spec}`, runNx: "bun nx", install: "bun install", workspaceRegistration: "package.json workspaces" };
+    case "npm":
+      return { addDevAtRoot: (spec) => `npm install -D ${spec}`, addAtRoot: (spec) => `npm install ${spec}`, runNx: "npm exec nx --", install: "npm install", workspaceRegistration: "package.json workspaces" };
+  }
+}
+
+// ../template-engine/dist/backend/eslint-boundaries.js
+var ESLINT_CONFIG_CANDIDATES = ["eslint.config.mjs", "eslint.config.js", "eslint.config.cjs"];
+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("");
+}
+
+// ../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) {
+  return `...fsdBoundaries({ severity: '${severity}' }),`;
+}
+function buildFsdEslintSnippet({ severity, locale }) {
+  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) export default [...] \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 export default [...] array."
+  ];
+  return [...lines, buildFsdEslintImportLine(), buildFsdEslintEntry(severity)].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");
+}
+
+// ../templates/dist/fsd/fsd-steiger.js
+var STEIGER_DEPENDENCIES = {
+  steiger: "^0.7.0",
+  "@feature-sliced/steiger-plugin": "^0.8.0"
+};
+var STEIGER_CONFIG_FILE = "steiger.config.mjs";
+var FSD_CHECK_TARGET = "fsd-check";
+function buildFsdCheckTarget(sourceRootName = "src") {
+  return { command: `steiger ${sourceRootName}`, options: { cwd: "{projectRoot}" } };
+}
+function buildSteigerConfig({ frontend, locale }) {
+  const ko = locale === "ko";
+  const lines = [
+    "import { defineConfig } from 'steiger';",
+    "import fsd from '@feature-sliced/steiger-plugin';",
+    "",
+    ko ? "// nx-archweave: \uC815\uC2DD FSD \uADDC\uCE59 \uC804\uCCB4(recommended). \uAD6C\uC870\uB294 generator\uAC00 \uC815\uC2DD\uB300\uB85C \uB9CC\uB4E4\uBBC0\uB85C \uADF8\uB300\uB85C \uB9DE\uBB3C\uB9BD\uB2C8\uB2E4." : "// nx-archweave: the canonical rule set (recommended). The generators scaffold canonical FSD, so it fits as is.",
+    "export default defineConfig([",
+    "  ...fsd.configs.recommended,",
+    "  {",
+    "    rules: {",
+    ko ? "      // \uC544\uBB34\uB3C4 \uCC38\uC870\uD558\uC9C0 \uC54A\uB294 \uC2AC\uB77C\uC774\uC2A4 = \uBC29\uAE08 \uC0DD\uC131\uD55C \uC2AC\uB77C\uC774\uC2A4. \uACBD\uACE0\uB85C \uBCF4\uC774\uB418 \uAC80\uC0AC\uB97C \uB9C9\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." : "      // a slice nothing references yet is every freshly generated slice: visible, not blocking",
+    "      'fsd/insignificant-slice': 'warn',",
+    ...frontend === "next" ? [
+      ko ? "      // Next.js: pages \uB808\uC774\uC5B4\uB294 _pages/ (FSD \uACF5\uC2DD Next.js \uAC00\uC774\uB4DC) \u2014 steiger 0.7\uC740 \uC544\uC9C1 \uC624\uD0C0\uB85C \uBD05\uB2C8\uB2E4." : "      // Next.js: the pages layer is _pages/ (FSD's own Next.js guide) \u2014 steiger 0.7 still reads it as a typo",
+      "      'fsd/typo-in-layer-name': 'off',"
+    ] : [],
+    "    },",
+    "  },",
+    "]);",
+    ""
+  ];
+  return lines.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 applyFsdEslintConfig(configText, severity) {
+  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);
+  if (exportMatches.length !== 1 || closing === null)
+    return { status: "unrecognized" };
+  const eol = configText.includes("\r\n") ? "\r\n" : "\n";
+  const closingIndex = closing.index;
+  const before = configText.slice(0, closingIndex);
+  const lastNonSpace = before.replace(/\s+$/, "");
+  const needsComma = !lastNonSpace.endsWith(",") && !lastNonSpace.endsWith("[");
+  const entryText = `${needsComma ? "," : ""}${eol}  ${buildFsdEslintEntry(severity)}${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) {
+  return buildFsdEslintSnippet({ severity, locale });
+}
+var REACT_VITE_LAYERS = ["app", "pages", "features", "entities", "shared"];
+var NEXT_LAYERS = ["pages", "features", "entities", "shared"];
+function fsdLayerDirName(frontend, layer) {
+  return frontend === "next" && (layer === "pages" || layer === "app") ? `_${layer}` : layer;
+}
+function fsdLayersFor(frontend) {
+  return frontend === "next" ? [...NEXT_LAYERS] : [...REACT_VITE_LAYERS];
+}
+function composeFsdLayerGuide({ frontend, sourceRoot, locale }) {
+  const layers = fsdLayersFor(frontend);
+  return buildFsdLayerGuide({ layers, directories: layers.map((layer) => fsdLayerDirName(frontend, layer)), sourceRoot, locale });
+}
+
+// src/generators/shared/dry-run.ts
+function resolveDryRun(options) {
+  return process.env["NX_DRY_RUN"] === "true" || (options.dryRun ?? false);
+}
+
+// src/generators/shared/frontend-app.ts
+import { getProjects } from "@nx/devkit";
+
+// src/generators/shared/project-type.ts
+import { parseJson } from "@nx/devkit";
+function resolveProjectType(tree, root, declared) {
+  if (declared) return declared === "library" ? "library" : "application";
+  const prefix = root === "" || root === "." ? "" : `${root}/`;
+  if (tree.exists(`${prefix}tsconfig.lib.json`)) return "library";
+  if (tree.exists(`${prefix}tsconfig.app.json`)) return "application";
+  const raw = tree.read(`${prefix}package.json`, "utf-8");
+  if (raw === null) return "library";
+  try {
+    const manifest = parseJson(raw);
+    if (manifest && !["exports", "main", "module", "bin"].some((key) => Boolean(manifest[key]))) return "application";
+  } catch {
+  }
+  return "library";
+}
+
+// src/generators/shared/frontend-app.ts
+var baseNameOf = (root) => root.split("/").pop() ?? root;
+function isEndToEnd(root) {
+  const dir = baseNameOf(root);
+  return dir === "e2e" || dir.endsWith("-e2e");
+}
+function isBackend(root, config) {
+  return baseNameOf(root) === "api" || (config.tags ?? []).includes("scope:backend");
+}
+function sourceRootOf(config) {
+  if (config.sourceRoot) return config.sourceRoot;
+  return config.root === "" || config.root === "." ? "src" : `${config.root}/src`;
+}
+function resolveFrontendApp(tree, explicitProject) {
+  let projects;
+  try {
+    projects = getProjects(tree);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const pathMatch = /Cannot parse ([^:]+):/.exec(message);
+    return { kind: "invalid-project-json", detail: pathMatch ? pathMatch[1] : message };
+  }
+  const found = (project2, config2) => ({
+    kind: "found",
+    project: project2,
+    root: config2.root,
+    sourceRoot: sourceRootOf(config2)
+  });
+  if (explicitProject !== void 0) {
+    const config2 = projects.get(explicitProject);
+    return config2 ? found(explicitProject, config2) : { kind: "not-found", project: explicitProject };
+  }
+  const eligible = [...projects.entries()].filter(([, config2]) => !isEndToEnd(config2.root) && !isBackend(config2.root, config2));
+  const declared = eligible.filter(([, config2]) => config2.projectType === "application");
+  const inferred = eligible.filter(
+    ([, config2]) => config2.projectType === void 0 && config2.root !== "" && config2.root !== "." && resolveProjectType(tree, config2.root, void 0) === "application"
+  );
+  const candidates = (declared.length > 0 ? declared : inferred).sort(([a], [b]) => a.localeCompare(b));
+  if (candidates.length === 0) return { kind: "none" };
+  if (candidates.length > 1) return { kind: "ambiguous", candidates: candidates.map(([name]) => name) };
+  const [project, config] = candidates[0];
+  return found(project, config);
+}
+
+// src/generators/shared/toolkit-config-file.ts
+var TOOLKIT_CONFIG_PATH = "toolkit.config.json";
+function detectIndent(raw) {
+  for (const line of raw.split("\n")) {
+    const match = /^(\t+| +)/.exec(line);
+    if (match) return match[1];
+  }
+  return "  ";
+}
+function readToolkitConfigFile(tree) {
+  const raw = tree.read(TOOLKIT_CONFIG_PATH, "utf-8");
+  if (raw === null) return { raw: null, parsed: null };
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      raw,
+      parsed: typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null
+    };
+  } catch {
+    return { raw, parsed: null };
+  }
+}
+function readToolkitConfig(tree) {
+  return readToolkitConfigFile(tree).parsed;
+}
+function resolveLocaleOption(option, config) {
+  if (option) return option;
+  const locale = config?.["locale"];
+  return locale === "ko" || locale === "en" ? locale : "en";
+}
+function recordedChoice(config, key, allowed) {
+  const value = config?.[key];
+  return typeof value === "string" && allowed.includes(value) ? value : void 0;
+}
+var RECORDED_FRONTENDS = ["react-vite", "next", "none"];
+var RECORDED_PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+function resolveFrontendOption(option, config, generator) {
+  const frontend = option ?? recordedChoice(config, "frontend", RECORDED_FRONTENDS);
+  if (frontend === void 0) {
+    throw new Error(`${generator}: pass --frontend=react-vite|next (toolkit.config.json records none \u2014 init writes it).`);
+  }
+  if (frontend === "none") {
+    throw new Error(
+      `${generator}: this is a backend-only workspace (toolkit.config.json frontend: none) \u2014 FSD structures a frontend app. Pass --frontend=react-vite|next if you added one.`
+    );
+  }
+  return frontend;
+}
+function workspacePackageManager(exists, read, config) {
+  return detectWorkspacePackageManager(exists, read) ?? recordedChoice(config, "packageManager", RECORDED_PACKAGE_MANAGERS) ?? null;
+}
+function treePackageManager(tree, config) {
+  return workspacePackageManager((p) => tree.exists(p), (p) => tree.read(p, "utf-8"), config);
+}
+
+// src/generators/add-fsd-lite/render.ts
+function renderAddFsdLiteReport(report) {
+  const lines = [];
+  if (report.aborted) {
+    lines.push("add-fsd-lite aborted \u2014 nothing was written.");
+    const refusal = report.appRefusal;
+    if (refusal !== null) {
+      lines.push("");
+      lines.push("  FSD layers live inside the frontend app's source root (e.g. apps/web/src), and no app could be picked:");
+      if (refusal.reason === "project-not-found") {
+        lines.push(`    --project=${refusal.project} names no project in this workspace.`);
+      } else if (refusal.reason === "ambiguous-frontend") {
+        lines.push("    more than one frontend app was found \u2014 rerun with --project=<one of them>:");
+        for (const name of refusal.candidates) lines.push(`      - ${name}`);
+      } else if (refusal.reason === "invalid-project-json") {
+        lines.push(`    a project.json could not be parsed (${refusal.detail}) \u2014 fix it, then rerun.`);
+      } else {
+        lines.push("    the workspace has no frontend application \u2014 create one (e.g. nx g @nx/react:app) or pass --project.");
+      }
+    }
+    return lines.join("\n");
+  }
+  if (report.dryRun) {
+    lines.push("add-fsd-lite dry-run \u2014 no files were written.");
+    lines.push("");
+  }
+  lines.push(`FSD layers (in ${report.project}, ${report.sourceRoot}):`);
+  if (report.layerGuide !== null) lines.push(report.layerGuide);
+  lines.push("");
+  const where = report.eslintPath ?? `${report.project}'s eslint.config.mjs`;
+  switch (report.eslint) {
+    case "applied":
+      lines.push(`ESLint: archweave/fsd-boundaries (${report.enforcement}) written to ${where}`);
+      break;
+    case "already-applied":
+      lines.push(`ESLint: archweave/fsd-boundaries already wired in ${where} \u2014 no change`);
+      break;
+    case "degraded-unrecognized":
+      lines.push(`ESLint: ${report.eslintPath === null ? `no ESLint config found for ${report.project}` : `${where} was NOT recognized \u2014 left untouched`}.`);
+      lines.push("  Add the rule yourself (then the layer rules are actually enforced):");
+      break;
+    case "snippet-only":
+      lines.push(`ESLint: report-only (pass --applyEslint to write the rule into ${where}).`);
+      break;
+    case "not-applied":
+      break;
+  }
+  if (report.snippet !== null) lines.push(report.snippet);
+  if (report.steiger !== null) {
+    const st = report.steiger;
+    lines.push("");
+    lines.push("steiger (official FSD linter, opt-in):");
+    lines.push(
+      `  ${st.configPath}: ${st.config === "created" ? "created" : st.config === "unchanged" ? "unchanged" : "kept \u2014 an existing config with other content is never replaced"}`
+    );
+    lines.push(
+      st.target === "added" ? `  target ${"fsd-check"}: added to ${st.targetPath}` : st.target === "present" ? `  target ${"fsd-check"}: already present in ${st.targetPath}` : "  target fsd-check: NOT added \u2014 no parseable project.json / package.json for the app"
+    );
+    lines.push(
+      st.dependencies === "added" ? `  devDependencies: steiger + @feature-sliced/steiger-plugin added to package.json \u2014 run \`${st.installCommand}\`` : st.dependencies === "present" ? "  devDependencies: already present" : "  devDependencies: NOT added \u2014 the root package.json could not be parsed"
+    );
+    lines.push(`  run it with: ${st.runCommand}  (steiger needs Node >= 22.18)`);
+  }
+  return lines.join("\n");
+}
+
+// src/generators/add-fsd-lite/generator.ts
+function resolveEnforcement(option, config) {
+  if (option === "error" || option === "warn") return option;
+  return readFsdEnforcement(config?.["fsd"]) ?? "warn";
+}
+function runAddFsdLite(tree, options) {
+  const config = readToolkitConfig(tree);
+  const locale = resolveLocaleOption(options.locale, config);
+  const enforcement = resolveEnforcement(options.enforcement, config);
+  const frontend = resolveFrontendOption(options.frontend, config, "add-fsd-lite");
+  const dryRun = options.dryRun ?? false;
+  const applyEslint = options.applyEslint ?? false;
+  const snippet = buildFsdEslintPasteSnippet(enforcement, locale);
+  const app = resolveFrontendApp(tree, options.project);
+  if (app.kind !== "found") {
+    const appRefusal = app.kind === "not-found" ? { reason: "project-not-found", project: app.project } : app.kind === "ambiguous" ? { reason: "ambiguous-frontend", candidates: app.candidates } : app.kind === "invalid-project-json" ? { reason: "invalid-project-json", detail: app.detail } : { reason: "no-frontend-app" };
+    return { dryRun, aborted: true, appRefusal, project: null, sourceRoot: null, enforcement, eslint: "not-applied", eslintPath: null, snippet, layerGuide: null, steiger: null };
+  }
+  const appDir = app.root === "" || app.root === "." ? "" : `${app.root}/`;
+  const eslintPath = ESLINT_CONFIG_CANDIDATES.map((name) => `${appDir}${name}`).find((path) => tree.exists(path)) ?? null;
+  const configText = eslintPath === null ? null : tree.read(eslintPath, "utf-8");
+  let eslint;
+  if (!applyEslint) {
+    eslint = configText !== null && applyFsdEslintConfig(configText, enforcement).status === "already-applied" ? "already-applied" : "snippet-only";
+  } else if (configText === null) {
+    eslint = "degraded-unrecognized";
+  } else {
+    const result = applyFsdEslintConfig(configText, enforcement);
+    eslint = result.status === "applied" ? "applied" : result.status === "already-applied" ? "already-applied" : "degraded-unrecognized";
+    if (result.status === "applied" && !dryRun && eslintPath !== null) tree.write(eslintPath, result.text);
+  }
+  const steiger = options.steiger ? addSteiger(tree, { appDir, appRoot: app.root, sourceRoot: app.sourceRoot, frontend, locale, write: !dryRun, config }) : null;
+  return {
+    dryRun,
+    aborted: false,
+    appRefusal: null,
+    project: app.project,
+    sourceRoot: app.sourceRoot,
+    steiger,
+    enforcement,
+    eslint,
+    eslintPath,
+    snippet: eslint === "applied" || eslint === "already-applied" ? null : snippet,
+    layerGuide: composeFsdLayerGuide({ frontend, sourceRoot: app.sourceRoot, locale })
+  };
+}
+function readJsonObject(tree, path) {
+  const raw = tree.read(path, "utf-8");
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? { raw, parsed } : null;
+  } catch {
+    return null;
+  }
+}
+function addSteiger(tree, input) {
+  const configPath = `${input.appDir}${STEIGER_CONFIG_FILE}`;
+  const configText = buildSteigerConfig({ frontend: input.frontend, locale: input.locale });
+  const existing = tree.read(configPath, "utf-8");
+  let configAction;
+  if (existing === null) {
+    configAction = "created";
+    if (input.write) tree.write(configPath, configText);
+  } else {
+    configAction = existing === configText ? "unchanged" : "kept";
+  }
+  const rootPrefix = input.appRoot === "" || input.appRoot === "." ? "" : `${input.appRoot}/`;
+  const sourceRootName = input.sourceRoot.startsWith(rootPrefix) ? input.sourceRoot.slice(rootPrefix.length) : "src";
+  const target = buildFsdCheckTarget(sourceRootName);
+  let targetAction = "unrecognized";
+  let targetPath = null;
+  for (const candidate of [`${input.appDir}project.json`, `${input.appDir}package.json`]) {
+    const file = readJsonObject(tree, candidate);
+    if (file === null) continue;
+    targetPath = candidate;
+    const holder = candidate.endsWith("project.json") ? file.parsed : file.parsed["nx"] ??= {};
+    if (typeof holder !== "object" || holder === null) break;
+    const targets = holder["targets"] ??= {};
+    if (typeof targets !== "object" || targets === null) break;
+    if (targets[FSD_CHECK_TARGET] !== void 0) {
+      targetAction = "present";
+    } else {
+      targets[FSD_CHECK_TARGET] = target;
+      targetAction = "added";
+      if (input.write) tree.write(candidate, `${JSON.stringify(file.parsed, null, detectIndent(file.raw))}
+`);
+    }
+    break;
+  }
+  let dependenciesAction = "unrecognized";
+  const rootPackage = readJsonObject(tree, "package.json");
+  if (rootPackage !== null) {
+    const devDependencies = rootPackage.parsed["devDependencies"] ??= {};
+    const dependencies = rootPackage.parsed["dependencies"] ?? {};
+    const missing = Object.entries(STEIGER_DEPENDENCIES).filter(([name]) => devDependencies[name] === void 0 && dependencies[name] === void 0);
+    if (missing.length === 0) {
+      dependenciesAction = "present";
+    } else {
+      for (const [name, range] of missing) devDependencies[name] = range;
+      dependenciesAction = "added";
+      if (input.write) tree.write("package.json", `${JSON.stringify(rootPackage.parsed, null, detectIndent(rootPackage.raw))}
+`);
+    }
+  }
+  const pm = treePackageManager(tree, input.config) ?? "pnpm";
+  const commands = packageManagerCommands(pm, pm === "yarn" ? detectYarnFlavor((p) => tree.exists(p), (p) => tree.read(p, "utf-8")) : void 0);
+  return {
+    configPath,
+    config: configAction,
+    targetPath,
+    target: targetAction,
+    dependencies: dependenciesAction,
+    installCommand: commands.install,
+    runCommand: `${commands.runNx} run <project>:${FSD_CHECK_TARGET}`
+  };
+}
+async function addFsdLiteGenerator(tree, options) {
+  console.log(renderAddFsdLiteReport(runAddFsdLite(tree, { ...options, dryRun: resolveDryRun(options) })));
+}
+var generator_default = addFsdLiteGenerator;
+export {
+  addFsdLiteGenerator,
+  generator_default as default,
+  runAddFsdLite
+};