@clearlydev/nx-archweave 0.3.2 → 0.3.3

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

@@ -0,0 +1,386 @@
+import {
+  addSharedTypesNpmWorkspace,
+  addSharedTypesWorkspaceGlob,
+  composeBackendWiring,
+  readSharedTypesConfig
+} from "./chunk-QQNDYJTR.js";
+import {
+  resolveProjectType
+} from "./chunk-TXAQ2GJC.js";
+import {
+  ESLINT_CONFIG_CANDIDATES,
+  applyBoundaryConstraints,
+  buildBoundarySnippet,
+  readBoundaryTags
+} from "./chunk-6ZTIUBB2.js";
+import {
+  resolveDryRun
+} from "./chunk-TUN34LAQ.js";
+import {
+  TOOLKIT_CONFIG_PATH,
+  appendJsonArrayItem,
+  applyJsonEdits,
+  readToolkitConfig,
+  readToolkitConfigFile,
+  setJsonValue,
+  treePackageManager
+} from "./chunk-EXYZLL7A.js";
+import {
+  detectYarnFlavor,
+  packageManagerCommands
+} from "./chunk-FQHFT5IH.js";
+
+// src/generators/add-backend/generator.ts
+import { getProjects } from "@nx/devkit";
+
+// src/generators/add-backend/render.ts
+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 \u2014 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 \u2014 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 \u2014 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 !== void 0) {
+      lines.push("");
+      lines.push(`  The express line declares express@${report.expressRange}, the range this workspace's @nx/react supports \u2014`);
+      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 !== void 0) lines.push(`  note: ${report.packageManagerNote}`);
+  lines.push(`  frontend project: ${report.frontendProject ?? "none (backend-only workspace)"}`);
+  const libPath = report.sharedTypesRoot ?? "libs/shared-types";
+  lines.push(
+    report.sharedTypes === "created" ? `  ${libPath}: created (import it as ${report.sharedTypesPackage})` : report.sharedTypes === "disabled" ? "  shared-types lib: none (sharedTypes: false in toolkit.config.json)" : `  ${libPath}: already exists \u2014 skipped`
+  );
+  if (report.config !== void 0 && report.config !== "unchanged") {
+    lines.push(`  toolkit.config.json: backend "${report.backend}" recorded (${report.config}) \u2014 doctor's backend checks now run`);
+  }
+  if (report.workspaceGlob !== void 0) {
+    const pmName = report.packageManager ?? "pnpm";
+    const registry = packageManagerCommands(pmName).workspaceRegistration;
+    lines.push(
+      {
+        added: `  ${registry}: '${libPath}' registered \u2014 run \`${pmName} install\` once to link it`,
+        present: `  ${registry}: already covers ${libPath}`,
+        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) \u2014 the tsconfig paths alias links ${libPath}` : `  ${registry}: shape not recognized \u2014 add '${libPath}' 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 \u2014 libs resolve through paths)`,
+      present: "  tsconfig.base.json paths: already wired",
+      "workspace-link": "  tsconfig paths: not needed \u2014 the workspace package link is the wiring",
+      unrecognized: "  tsconfig.base.json: could not be parsed \u2014 left untouched",
+      none: "  tsconfig paths: nothing to wire (no shared-types lib)"
+    }[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 \u2014 no change");
+      break;
+    case "degraded-unrecognized":
+      lines.push("  ESLint boundaries: your config was NOT recognized \u2014 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");
+}
+function renderAddBackendReport(report, dryRun) {
+  return [`add-backend (${report.backend})${dryRun ? " \u2014 dry run" : ""}`, "", renderAddBackendBody(report)].join("\n");
+}
+
+// src/generators/add-backend/generator.ts
+function runAddBackend(tree, options) {
+  const backend = options.backend;
+  const apiName = options.apiName ?? "api";
+  const applyEslint = options.applyEslint ?? false;
+  const dryRun = options.dryRun ?? false;
+  const write = !dryRun;
+  const base = { backend, apiName };
+  const refusalShape = {
+    sharedTypes: "skipped",
+    tags: [],
+    tsconfigPaths: "unrecognized",
+    eslint: "snippet-only"
+  };
+  let projects;
+  try {
+    projects = getProjects(tree);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const pathMatch = /Cannot parse ([^:]+):/.exec(message);
+    return {
+      ...base,
+      refused: "invalid-project-json",
+      invalidProjects: [pathMatch ? pathMatch[1] : message],
+      ...refusalShape
+    };
+  }
+  const detectedPm = treePackageManager(tree, readToolkitConfig(tree));
+  const packageManager = detectedPm ?? "pnpm";
+  const pmCommands = packageManagerCommands(
+    packageManager,
+    packageManager === "yarn" ? detectYarnFlavor((p) => tree.exists(p), (p) => tree.read(p, "utf-8")) : void 0
+  );
+  const packageManagerNote = detectedPm === null ? "the package manager could not be detected (no pnpm, yarn, bun or npm markers) \u2014 commands below assume pnpm." : void 0;
+  const baseNameOf = (root) => root.split("/").pop() ?? root;
+  const entries = [...projects.entries()];
+  const declaredApp = ([, config]) => config.projectType === "application";
+  const inferredApp = ([, config]) => config.projectType === void 0 && config.root !== "" && config.root !== "." && resolveProjectType(tree, config.root, void 0) === "application";
+  const apiNamed = entries.filter(([, config]) => baseNameOf(config.root) === apiName);
+  const apiEntry = apiNamed.find(declaredApp) ?? apiNamed.find((entry) => inferredApp(entry) && tree.exists(`${entry[1].root}/tsconfig.app.json`));
+  let frontendProject;
+  if (options.frontendProject !== void 0) {
+    if (!projects.has(options.frontendProject)) {
+      return { ...base, refused: "frontend-not-found", frontendProject: options.frontendProject, ...refusalShape };
+    }
+    frontendProject = options.frontendProject;
+  } else {
+    const eligible = entries.filter(([, config]) => {
+      const dir = baseNameOf(config.root);
+      return dir !== apiName && dir !== "e2e" && !dir.endsWith("-e2e");
+    });
+    const declared = eligible.filter(declaredApp);
+    const candidates = (declared.length > 0 ? declared : eligible.filter(inferredApp)).map(([name]) => name).sort();
+    if (candidates.length === 0 && !apiEntry) {
+      return { ...base, refused: "no-frontend", ...refusalShape };
+    }
+    if (candidates.length > 1) {
+      return { ...base, refused: "ambiguous-frontend", frontendCandidates: candidates, ...refusalShape };
+    }
+    frontendProject = candidates[0];
+  }
+  if (!apiEntry) {
+    if (frontendProject === void 0) return { ...base, refused: "no-frontend", ...refusalShape };
+    let nxPin = "";
+    let expressDeclared = false;
+    const rootPkgRaw = tree.read("package.json", "utf-8");
+    if (rootPkgRaw !== null) {
+      try {
+        const pkg = JSON.parse(rootPkgRaw);
+        const nxVersion = pkg.devDependencies?.["nx"] ?? pkg.dependencies?.["nx"];
+        if (nxVersion && /^[~^]?\d/.test(nxVersion)) nxPin = `@${nxVersion}`;
+        expressDeclared = pkg.dependencies?.["express"] !== void 0 || pkg.devDependencies?.["express"] !== void 0;
+      } catch {
+      }
+    }
+    const frontendRoot = projects.get(frontendProject)?.root ?? "";
+    const frontendParent = frontendRoot.split("/").slice(0, -1).join("/");
+    const apiDirectory = frontendRoot === "" || frontendRoot === "." ? `apps/${apiName}` : `${frontendParent === "" ? "" : `${frontendParent}/`}${apiName}`;
+    const expressAlignment = backend === "express" && !expressDeclared ? readExpressPeerRange(tree) : void 0;
+    const quotedExpress = expressAlignment ? `"express@${expressAlignment}"` : void 0;
+    return {
+      ...base,
+      refused: "missing-api-project",
+      frontendProject,
+      ...expressAlignment !== void 0 ? { expressRange: expressAlignment } : {},
+      commands: [
+        pmCommands.addDevAtRoot(`@nx/${backend}${nxPin}`),
+        ...quotedExpress ? [pmCommands.addAtRoot(quotedExpress)] : [],
+        `${pmCommands.runNx} g @nx/${backend}:application ${apiDirectory} --frontendProject=${frontendProject}`
+      ],
+      ...refusalShape
+    };
+  }
+  const recordedConfig = readToolkitConfigFile(tree).parsed;
+  const boundaryTags = readBoundaryTags(recordedConfig);
+  const sharedTypesConfig = readSharedTypesConfig(recordedConfig);
+  const withSharedTypes = sharedTypesConfig !== false;
+  const sharedTypesRoot = sharedTypesConfig === false ? "" : sharedTypesConfig.path;
+  const sharedTypesExists = withSharedTypes && (tree.exists(`${sharedTypesRoot}/package.json`) || tree.exists(`${sharedTypesRoot}/project.json`));
+  const rootPackageJson = tree.read("package.json", "utf-8");
+  const workspaceName = rootPackageJson ? JSON.parse(rootPackageJson).name ?? "workspace" : "workspace";
+  const wiring = composeBackendWiring({ workspaceName, tags: boundaryTags, ...sharedTypesConfig === false ? {} : { sharedTypes: sharedTypesConfig } });
+  const [apiProjectName, apiConfig] = apiEntry;
+  const tagTargets = [
+    ...frontendProject === void 0 ? [] : [{ project: frontendProject, root: projects.get(frontendProject)?.root ?? `apps/${frontendProject}` }],
+    { project: apiProjectName, root: apiConfig.root }
+  ];
+  if (sharedTypesExists) tagTargets.push({ project: wiring.sharedTypesPackageName, root: sharedTypesRoot });
+  const parsedTargets = /* @__PURE__ */ new Map();
+  const invalidProjects = [];
+  for (const target of tagTargets) {
+    const projectJsonPath = `${target.root}/project.json`;
+    const packageJsonPath = `${target.root}/package.json`;
+    const kind = tree.exists(projectJsonPath) ? "project" : "package";
+    const path = kind === "project" ? projectJsonPath : packageJsonPath;
+    const raw = tree.read(path, "utf-8");
+    if (raw === null) {
+      invalidProjects.push(path);
+      continue;
+    }
+    try {
+      parsedTargets.set(target.project, { path, raw, kind, parsed: JSON.parse(raw) });
+    } catch {
+      invalidProjects.push(path);
+    }
+  }
+  if (invalidProjects.length > 0) {
+    return { ...base, refused: "invalid-project-json", frontendProject, invalidProjects, ...refusalShape };
+  }
+  const sharedTypes = !withSharedTypes ? "disabled" : sharedTypesExists ? "skipped" : "created";
+  if (sharedTypes === "created" && write) {
+    for (const file of wiring.sharedTypesFiles) tree.write(file.filePath, file.content);
+  }
+  let configOutcome = "unchanged";
+  {
+    const { raw: configRaw, parsed: configParsed } = readToolkitConfigFile(tree);
+    const parseOk = configRaw === null || configParsed !== null;
+    const existing = configParsed ?? {};
+    if (parseOk && existing["backend"] !== backend) {
+      configOutcome = configRaw === null ? "created" : "updated";
+      if (write) tree.write(TOOLKIT_CONFIG_PATH, applyJsonEdits(configRaw, [[["backend"], backend]]));
+    }
+  }
+  let workspaceGlob = withSharedTypes ? "unrecognized" : void 0;
+  const workspaceYaml = withSharedTypes ? tree.read("pnpm-workspace.yaml", "utf-8") : null;
+  if (!withSharedTypes) {
+  } else if (workspaceYaml !== null) {
+    const globResult = addSharedTypesWorkspaceGlob(workspaceYaml, sharedTypesRoot);
+    workspaceGlob = globResult.status;
+    if (globResult.status === "added" && write) tree.write("pnpm-workspace.yaml", globResult.text);
+  } else if ((detectedPm === "npm" || detectedPm === "yarn" || detectedPm === "bun") && rootPackageJson !== null) {
+    const yarnNeedsPrivate = detectedPm === "yarn" && JSON.parse(rootPackageJson).private !== true;
+    const npmResult = yarnNeedsPrivate ? { status: "unrecognized" } : addSharedTypesNpmWorkspace(rootPackageJson, sharedTypesRoot);
+    workspaceGlob = npmResult.status;
+    if (npmResult.status === "added" && write) tree.write("package.json", npmResult.text);
+  }
+  const mergeTag = (project, tag) => {
+    const target = parsedTargets.get(project);
+    if (!target) return { project, action: "added" };
+    const holder = target.kind === "project" ? target.parsed : target.parsed.nx ??= {};
+    const tags2 = holder.tags ?? [];
+    if (tags2.includes(tag)) return { project, action: "present" };
+    holder.tags = [...tags2, tag];
+    target.raw = appendJsonArrayItem(target.raw, target.kind === "project" ? ["tags"] : ["nx", "tags"], tag);
+    if (write) tree.write(target.path, target.raw);
+    return { project, action: "added" };
+  };
+  const tags = [
+    ...frontendProject === void 0 ? [] : [mergeTag(frontendProject, wiring.tagByRole.frontend)],
+    mergeTag(apiProjectName, wiring.tagByRole.backend),
+    ...withSharedTypes ? [mergeTag(wiring.sharedTypesPackageName, wiring.tagByRole.shared)] : []
+  ];
+  let tsconfigPaths = withSharedTypes ? "workspace-link" : "none";
+  const tsconfigRaw = withSharedTypes ? tree.read("tsconfig.base.json", "utf-8") : null;
+  if (tsconfigRaw !== null) {
+    try {
+      const tsconfig = JSON.parse(tsconfigRaw);
+      const baseUrl = tsconfig.compilerOptions?.baseUrl;
+      if (tsconfig.compilerOptions && (baseUrl || tsconfig.compilerOptions.paths !== void 0)) {
+        const paths = tsconfig.compilerOptions.paths ?? {};
+        if (paths[wiring.sharedTypesPackageName]) {
+          tsconfigPaths = "present";
+        } else {
+          tsconfigPaths = "added";
+          const entry = [`${baseUrl ? "" : "./"}${sharedTypesRoot}/src/index.ts`];
+          if (write) tree.write("tsconfig.base.json", setJsonValue(tsconfigRaw, ["compilerOptions", "paths", wiring.sharedTypesPackageName], entry));
+        }
+      }
+    } catch {
+      tsconfigPaths = "unrecognized";
+    }
+  }
+  let eslint;
+  let snippet;
+  if (!applyEslint) {
+    eslint = "snippet-only";
+    snippet = buildBoundarySnippet(boundaryTags);
+  } else {
+    const configPath = ESLINT_CONFIG_CANDIDATES.find((candidate) => tree.exists(candidate));
+    const configText = configPath ? tree.read(configPath, "utf-8") : null;
+    const result = configText !== null ? applyBoundaryConstraints(configText, boundaryTags) : { status: "unrecognized" };
+    if (result.status === "applied") {
+      eslint = "applied";
+      if (write && configPath) tree.write(configPath, result.text);
+    } else if (result.status === "already-applied") {
+      eslint = "already-applied";
+    } else {
+      eslint = "degraded-unrecognized";
+      snippet = buildBoundarySnippet(boundaryTags);
+    }
+  }
+  return {
+    ...base,
+    frontendProject,
+    sharedTypes,
+    tags,
+    workspaceGlob,
+    tsconfigPaths,
+    eslint,
+    snippet,
+    sharedTypesPackage: withSharedTypes ? wiring.sharedTypesPackageName : void 0,
+    sharedTypesRoot: withSharedTypes ? sharedTypesRoot : void 0,
+    config: configOutcome,
+    packageManager,
+    ...packageManagerNote !== void 0 ? { packageManagerNote } : {}
+  };
+}
+function readExpressPeerRange(tree) {
+  const raw = tree.read("node_modules/@nx/react/package.json", "utf-8");
+  if (raw === null) return void 0;
+  try {
+    const range = JSON.parse(raw).peerDependencies?.["express"];
+    return typeof range === "string" && range.trim().length > 0 ? range.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function addBackendGenerator(tree, options) {
+  const dryRun = resolveDryRun(options);
+  const report = runAddBackend(tree, { ...options, dryRun });
+  console.log(renderAddBackendReport(report, dryRun));
+}
+var generator_default = addBackendGenerator;
+
+export {
+  renderAddBackendBody,
+  runAddBackend,
+  addBackendGenerator,
+  generator_default
+};

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

@@ -0,0 +1,234 @@
+import {
+  detectWorkspacePackageManager
+} from "./chunk-FQHFT5IH.js";
+
+// ../template-engine/dist/ai-hosts/ai-hosts.js
+var AI_HOSTS = [
+  { id: "claude-code", label: "Claude Code", nxAgent: "claude", rulesFile: "CLAUDE.md", reviewProvider: "claude" },
+  { id: "codex", label: "Codex", nxAgent: "codex", rulesFile: "AGENTS.md", reviewProvider: "gpt" },
+  { id: "cursor", label: "Cursor", nxAgent: "cursor", rulesFile: "AGENTS.md", reviewProvider: "cursor" },
+  { id: "gemini-cli", label: "Gemini CLI", nxAgent: "gemini", rulesFile: "AGENTS.md", reviewProvider: "gemini" }
+];
+var AI_HOST_IDS = AI_HOSTS.map((host) => host.id);
+var DEFAULT_AI_HOSTS = ["claude-code"];
+function isAiHost(value) {
+  return typeof value === "string" && AI_HOST_IDS.includes(value);
+}
+function definitionOf(id) {
+  const host = AI_HOSTS.find((candidate) => candidate.id === id);
+  if (!host)
+    throw new Error(`Unknown AI host "${id}"`);
+  return host;
+}
+function rulesFilesFor(hosts) {
+  const picked = hosts.length > 0 ? hosts : DEFAULT_AI_HOSTS;
+  const files = new Set(picked.map((id) => definitionOf(id).rulesFile));
+  return ["CLAUDE.md", "AGENTS.md"].filter((file) => files.has(file));
+}
+function reviewProviderFor(hosts) {
+  return definitionOf(hosts[0] ?? DEFAULT_AI_HOSTS[0]).reviewProvider;
+}
+
+// src/generators/shared/json-edit.ts
+import { findNodeAtLocation, parseTree } from "jsonc-parser";
+function detectIndent(raw) {
+  for (const line of raw.split("\n")) {
+    const match = /^(\t+| +)/.exec(line);
+    if (match) return match[1];
+  }
+  return "  ";
+}
+function styleOf(raw) {
+  return { eol: raw.includes("\r\n") ? "\r\n" : "\n", unit: detectIndent(raw) };
+}
+function lineIndentAt(raw, offset) {
+  const lineStart = raw.lastIndexOf("\n", offset - 1) + 1;
+  return /^[ \t]*/.exec(raw.slice(lineStart))?.[0] ?? "";
+}
+function isMultiline(raw, node) {
+  return raw.slice(node.offset, node.offset + node.length).includes("\n");
+}
+function isPrimitive(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function renderValue(value, indent, style) {
+  if (isPrimitive(value)) return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    if (value.every(isPrimitive)) return `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+    const inner2 = `${indent}${style.unit}`;
+    return `[${style.eol}${value.map((item) => `${inner2}${renderValue(item, inner2, style)}`).join(`,${style.eol}`)}${style.eol}${indent}]`;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) return "{}";
+  const inner = `${indent}${style.unit}`;
+  const body = entries.map(([key, item]) => `${inner}${JSON.stringify(key)}: ${renderValue(item, inner, style)}`).join(`,${style.eol}`);
+  return `{${style.eol}${body}${style.eol}${indent}}`;
+}
+function splice(raw, start, end, text) {
+  return raw.slice(0, start) + text + raw.slice(end);
+}
+function nest(keys, value) {
+  return keys.reduceRight((inner, key) => ({ [key]: inner }), value);
+}
+function insertProperty(raw, object, key, value, style) {
+  const properties = object.children ?? [];
+  const objectIndent = lineIndentAt(raw, object.offset);
+  if (properties.length === 0) {
+    const inner = `${objectIndent}${style.unit}`;
+    const text = `{${style.eol}${inner}${JSON.stringify(String(key))}: ${renderValue(value, inner, style)}${style.eol}${objectIndent}}`;
+    return splice(raw, object.offset, object.offset + object.length, text);
+  }
+  const last = properties[properties.length - 1];
+  const end = last.offset + last.length;
+  if (!isMultiline(raw, object)) {
+    return splice(raw, end, end, `, ${JSON.stringify(String(key))}: ${renderValue(value, "", style)}`);
+  }
+  const indent = lineIndentAt(raw, last.offset);
+  return splice(raw, end, end, `,${style.eol}${indent}${JSON.stringify(String(key))}: ${renderValue(value, indent, style)}`);
+}
+function setJsonValue(raw, path, value) {
+  const style = styleOf(raw);
+  const root = parseTree(raw);
+  if (root === void 0) throw new Error("setJsonValue: not a JSON document");
+  const existing = findNodeAtLocation(root, path);
+  if (existing !== void 0) {
+    return splice(raw, existing.offset, existing.offset + existing.length, renderValue(value, lineIndentAt(raw, existing.offset), style));
+  }
+  for (let depth = path.length - 1; depth >= 0; depth--) {
+    const parent = depth === 0 ? root : findNodeAtLocation(root, path.slice(0, depth));
+    if (parent === void 0) continue;
+    if (parent.type !== "object") throw new Error(`setJsonValue: ${path.slice(0, depth).join(".") || "the root"} is not an object`);
+    return insertProperty(raw, parent, path[depth], nest(path.slice(depth + 1), value), style);
+  }
+  throw new Error("setJsonValue: unreachable");
+}
+function appendJsonArrayItem(raw, path, item) {
+  const style = styleOf(raw);
+  const root = parseTree(raw);
+  const array = root === void 0 ? void 0 : findNodeAtLocation(root, path);
+  if (array === void 0) return setJsonValue(raw, path, [item]);
+  if (array.type !== "array") throw new Error(`appendJsonArrayItem: ${path.join(".")} is not an array`);
+  const items = array.children ?? [];
+  if (items.length === 0) return splice(raw, array.offset, array.offset + array.length, renderValue([item], "", style));
+  const last = items[items.length - 1];
+  const end = last.offset + last.length;
+  if (!isMultiline(raw, array)) {
+    const separator = items.length >= 2 ? raw.slice(items[0].offset + items[0].length, items[1].offset) : ", ";
+    return splice(raw, end, end, `${separator}${renderValue(item, "", style)}`);
+  }
+  const indent = lineIndentAt(raw, last.offset);
+  return splice(raw, end, end, `,${style.eol}${indent}${renderValue(item, indent, style)}`);
+}
+function applyJsonEdits(raw, edits) {
+  if (raw === null) {
+    let text = "{}\n";
+    for (const [path, value] of edits) text = setJsonValue(text, path, value);
+    return text;
+  }
+  return edits.reduce((text, [path, value]) => setJsonValue(text, path, value), raw);
+}
+
+// src/generators/shared/toolkit-config-file.ts
+var TOOLKIT_CONFIG_PATH = "toolkit.config.json";
+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", "expo", "generic", "none"];
+var RECORDED_BACKENDS = ["express", "nest", "none"];
+var RECORDED_PRESETS = ["quick-start", "solo", "team"];
+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|expo|generic (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|expo|generic if you added one.`
+    );
+  }
+  return frontend;
+}
+function resolveInitFrontend(option, config) {
+  const frontend = option ?? recordedChoice(config, "frontend", RECORDED_FRONTENDS);
+  if (frontend === void 0) {
+    throw new Error("init: pass --frontend=react-vite|next|expo|generic|none (toolkit.config.json records none \u2014 init writes it).");
+  }
+  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);
+}
+function resolveAiHostsOption(option, config) {
+  if (option !== void 0 && option.length > 0) return [...new Set(option)];
+  const recorded = config?.["aiHosts"];
+  const fromConfig = Array.isArray(recorded) ? [...new Set(recorded.filter(isAiHost))] : [];
+  return fromConfig.length > 0 ? fromConfig : [...DEFAULT_AI_HOSTS];
+}
+function recordAiHosts(tree, hosts, write) {
+  const { raw, parsed } = readToolkitConfigFile(tree);
+  if (raw !== null && parsed === null) return "unrecognized";
+  const existing = parsed ?? {};
+  const recorded = existing["aiHosts"];
+  if (Array.isArray(recorded) && recorded.length === hosts.length && recorded.every((id, index) => id === hosts[index])) {
+    return "unchanged";
+  }
+  if (write) tree.write(TOOLKIT_CONFIG_PATH, applyJsonEdits(raw, [[["aiHosts"], [...hosts]]]));
+  return raw === null ? "created" : "updated";
+}
+function recordedFrontends(config) {
+  const frontends = config?.["frontends"];
+  if (!Array.isArray(frontends)) return [];
+  return frontends.flatMap(
+    (entry) => typeof entry === "object" && entry !== null && typeof entry["project"] === "string" ? [entry.project] : []
+  );
+}
+
+export {
+  DEFAULT_AI_HOSTS,
+  rulesFilesFor,
+  reviewProviderFor,
+  setJsonValue,
+  appendJsonArrayItem,
+  applyJsonEdits,
+  TOOLKIT_CONFIG_PATH,
+  readToolkitConfigFile,
+  readToolkitConfig,
+  resolveLocaleOption,
+  recordedChoice,
+  RECORDED_FRONTENDS,
+  RECORDED_BACKENDS,
+  RECORDED_PRESETS,
+  resolveFrontendOption,
+  resolveInitFrontend,
+  workspacePackageManager,
+  treePackageManager,
+  resolveAiHostsOption,
+  recordAiHosts,
+  recordedFrontends
+};

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

@@ -0,0 +1,50 @@
+// ../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" };
+  }
+}
+
+export {
+  detectWorkspacePackageManager,
+  detectYarnFlavor,
+  packageManagerCommands
+};