@clearlydev/nx-archweave 0.1.1 → 0.2.1

package/dist/generators/widget/generator.js

@@ -1,6 +1,113 @@
 // src/generators/slice/core.ts
 import { join } from "node:path";
 
+// ../template-engine/dist/backend/eslint-boundaries.js
+var DEFAULT_BOUNDARY_TAGS = { frontend: "scope:frontend", backend: "scope:backend", shared: "scope:shared" };
+function readBoundaryTags(config) {
+  const boundaries = config?.["boundaries"];
+  const tags = typeof boundaries === "object" && boundaries !== null ? boundaries["tags"] : void 0;
+  const pick = (role) => {
+    const value = typeof tags === "object" && tags !== null ? tags[role] : void 0;
+    return typeof value === "string" && value.trim() !== "" ? value : DEFAULT_BOUNDARY_TAGS[role];
+  };
+  return { frontend: pick("frontend"), backend: pick("backend"), shared: pick("shared") };
+}
+function scopeConstraints(tags = DEFAULT_BOUNDARY_TAGS) {
+  return [
+    { sourceTag: tags.frontend, notDependOnLibsWithTags: [tags.backend] },
+    { sourceTag: tags.backend, notDependOnLibsWithTags: [tags.frontend] },
+    { sourceTag: tags.shared, notDependOnLibsWithTags: [tags.frontend, tags.backend] }
+  ];
+}
+var SCOPE_CONSTRAINTS = scopeConstraints();
+
+// ../template-engine/dist/frameworks/profiles.js
+var ALL_LAYERS = ["app", "pages", "features", "entities", "shared"];
+var NEXT = {
+  id: "next",
+  recognised: true,
+  // Next.js's own app/ (App Router) directory is the composition root; FSD's Next.js guide
+  // names the FSD app and pages layers _app and _pages, since Next.js reads src/app and
+  // src/pages as its routers.
+  layers: ["pages", "features", "entities", "shared"],
+  layerDirs: { app: "_app", pages: "_pages" },
+  buildOutputDirs: [".next", "out"],
+  platformSuffixes: [],
+  routerDirs: ["pages"]
+};
+var REACT_VITE = {
+  id: "react-vite",
+  recognised: true,
+  layers: ALL_LAYERS,
+  layerDirs: {},
+  buildOutputDirs: ["dist"],
+  platformSuffixes: [],
+  routerDirs: []
+};
+var EXPO_ROUTER = {
+  id: "expo",
+  recognised: true,
+  layers: ALL_LAYERS,
+  layerDirs: { app: "_app" },
+  buildOutputDirs: [".expo", "dist"],
+  platformSuffixes: ["ios", "android", "native", "web"],
+  routerDirs: []
+};
+var EXPO = { ...EXPO_ROUTER, layerDirs: {} };
+var GENERIC = {
+  id: "generic",
+  recognised: false,
+  layers: ALL_LAYERS,
+  layerDirs: {},
+  buildOutputDirs: ["dist", "build"],
+  platformSuffixes: [],
+  routerDirs: []
+};
+var PROFILES = { next: NEXT, "react-vite": REACT_VITE, expo: EXPO_ROUTER, generic: GENERIC };
+function profileById(id) {
+  return PROFILES[id];
+}
+var NEXT_CONFIGS = ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs"];
+var VITE_CONFIGS = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"];
+var EXPO_CONFIGS = ["app.config.ts", "app.config.js", "app.config.mjs"];
+function hasExpoKey(input, file) {
+  const text = input.read(file);
+  if (typeof text !== "string")
+    return false;
+  try {
+    return typeof JSON.parse(text)["expo"] === "object";
+  } catch {
+    return false;
+  }
+}
+function dependsOn(input, manifest, name) {
+  const text = input.read(manifest);
+  if (typeof text !== "string")
+    return false;
+  try {
+    const parsed = JSON.parse(text);
+    return ["dependencies", "devDependencies", "peerDependencies"].some((field) => parsed[field]?.[name] !== void 0);
+  } catch {
+    return false;
+  }
+}
+function detectFramework(input) {
+  const prefix = input.projectRoot === "" || input.projectRoot === "." ? "" : `${input.projectRoot}/`;
+  const executors = input.executors ?? [];
+  if (NEXT_CONFIGS.some((file) => input.exists(`${prefix}${file}`)) || executors.some((executor) => executor.startsWith("@nx/next:"))) {
+    return NEXT;
+  }
+  const dependsAnywhere = (name) => dependsOn(input, `${prefix}package.json`, name) || dependsOn(input, "package.json", name);
+  const usesExpo = executors.some((executor) => executor.startsWith("@nx/expo:")) || hasExpoKey(input, `${prefix}app.json`) || EXPO_CONFIGS.some((file) => input.exists(`${prefix}${file}`)) || dependsOn(input, `${prefix}package.json`, "expo");
+  if (usesExpo)
+    return dependsAnywhere("expo-router") ? EXPO_ROUTER : EXPO;
+  const usesReact = dependsAnywhere("react");
+  const usesVite = VITE_CONFIGS.some((file) => input.exists(`${prefix}${file}`)) || executors.some((executor) => executor.startsWith("@nx/vite:"));
+  if (usesVite && usesReact)
+    return REACT_VITE;
+  return GENERIC;
+}
+
 // ../template-engine/dist/fsd/slice-rules.js
 function toCamelCase(kebabName) {
   return kebabName.split("-").filter((part) => part.length > 0).map((part, index) => index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)).join("");
@@ -102,7 +209,14 @@ function resolveLocaleOption(option, config) {
   const locale = config?.["locale"];
   return locale === "ko" || locale === "en" ? locale : "en";
 }
-var RECORDED_FRONTENDS = ["react-vite", "next", "none"];
+var RECORDED_FRONTENDS = ["react-vite", "next", "expo", "generic", "none"];
+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] : []
+  );
+}
 
 // src/generators/shared/frontend-app.ts
 import { getProjects } from "@nx/devkit";
@@ -130,12 +244,27 @@ 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 isBackend(root, config, backendTag) {
+  return baseNameOf(root) === "api" || (config.tags ?? []).includes(backendTag);
 }
-function sourceRootOf(config) {
-  if (config.sourceRoot) return config.sourceRoot;
-  return config.root === "" || config.root === "." ? "src" : `${config.root}/src`;
+function prefixOf(root) {
+  return root === "" || root === "." ? "" : `${root}/`;
+}
+function sourceRootOf(tree, config) {
+  const prefix = prefixOf(config.root);
+  const declared = config.sourceRoot?.replace(/\/$/, "");
+  const atRoot = declared !== void 0 && (declared === config.root || prefix === "" && (declared === "." || declared === ""));
+  if (declared && !atRoot) return declared;
+  if (atRoot && !tree.exists(`${prefix}src`)) return prefix === "" ? "." : config.root;
+  return `${prefix}src`;
+}
+function frameworkOf(tree, config) {
+  return detectFramework({
+    exists: (path) => tree.exists(path),
+    read: (path) => tree.read(path, "utf-8"),
+    projectRoot: config.root,
+    executors: Object.values(config.targets ?? {}).flatMap((target) => target.executor ? [target.executor] : [])
+  });
 }
 function resolveFrontendApp(tree, explicitProject) {
   let projects;
@@ -146,27 +275,51 @@ function resolveFrontendApp(tree, explicitProject) {
     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)
-  });
+  const found = (project2, config2) => {
+    const profile = frameworkOf(tree, config2);
+    return { kind: "found", project: project2, root: config2.root, sourceRoot: sourceRootOf(tree, config2), framework: profile.id, profile };
+  };
   if (explicitProject !== void 0) {
     const config2 = projects.get(explicitProject);
-    return config2 ? found(explicitProject, config2) : { kind: "not-found", project: explicitProject };
+    if (config2) return found(explicitProject, config2);
+    const rootApp = inferredRootApp(tree, projects);
+    return rootApp?.kind === "found" && rootApp.project === explicitProject ? rootApp : { kind: "not-found", project: explicitProject };
   }
-  const eligible = [...projects.entries()].filter(([, config2]) => !isEndToEnd(config2.root) && !isBackend(config2.root, config2));
+  const backendTag = readBoundaryTags(readToolkitConfig(tree)).backend;
+  const eligible = [...projects.entries()].filter(([, config2]) => !isEndToEnd(config2.root) && !isBackend(config2.root, config2, backendTag));
   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 inferred = eligible.filter(([, config2]) => {
+    if (config2.projectType !== void 0) return false;
+    if (config2.root === "" || config2.root === ".") return frameworkOf(tree, config2).recognised;
+    return 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 === 0) {
+    const rootApp = inferredRootApp(tree, projects);
+    if (rootApp !== null) return rootApp;
+    const otherProjects = [...projects.keys()].filter((name) => !isEndToEnd(projects.get(name)?.root ?? "")).sort();
+    return { kind: "none", otherProjects };
+  }
   if (candidates.length > 1) return { kind: "ambiguous", candidates: candidates.map(([name]) => name) };
   const [project, config] = candidates[0];
   return found(project, config);
 }
+function inferredRootApp(tree, projects) {
+  if ([...projects.values()].some((config2) => config2.root === "" || config2.root === ".")) return null;
+  const raw = tree.read("package.json", "utf-8");
+  if (raw === null) return null;
+  let name;
+  try {
+    name = JSON.parse(raw).name;
+  } catch {
+    return null;
+  }
+  if (typeof name !== "string" || name === "") return null;
+  const config = { name, root: "." };
+  const framework = frameworkOf(tree, config);
+  if (!framework.recognised) return null;
+  return { kind: "found", project: name, root: ".", sourceRoot: sourceRootOf(tree, config), framework: framework.id, profile: framework, inferredRoot: true };
+}
 
 // src/generators/shared/template-files.ts
 import { existsSync } from "node:fs";
@@ -192,7 +345,7 @@ function renderTemplateFiles(srcFolder, target, substitutions) {
 // src/generators/slice/core.ts
 function composeSlice(input) {
   const files = generatorFilesDir("slice", import.meta.url);
-  const directory = `${input.sourceRoot}/${input.layerDirName}/${input.name}`;
+  const directory = `${input.sourceRoot}/${input.layerDirName}/${input.group === void 0 ? "" : `${input.group}/`}${input.name}`;
   const shared = input.layer === "shared";
   const values = {
     name: input.name,
@@ -201,7 +354,7 @@ function composeSlice(input) {
     locale: input.locale,
     modulePath: shared ? `./${input.name}` : `./model/${input.name}`
   };
-  const module = renderTemplateFiles(join(files, "module"), shared ? directory : `${directory}/model`, values).sort((a, b) => Number(a.filePath.endsWith(".spec.ts")) - Number(b.filePath.endsWith(".spec.ts")));
+  const module = renderTemplateFiles(join(files, "module"), shared ? directory : `${directory}/model`, values).filter((file) => input.withSpec !== false || !file.filePath.endsWith(".spec.ts")).sort((a, b) => Number(a.filePath.endsWith(".spec.ts")) - Number(b.filePath.endsWith(".spec.ts")));
   const segments = shared ? [] : Array.from(new Set(input.segments)).filter((segment) => segment !== "model").flatMap((segment) => renderTemplateFiles(join(files, "segment"), `${directory}/${segment}`, { ...values, segment }));
   return {
     directory,
@@ -211,20 +364,18 @@ function composeSlice(input) {
 }
 var KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function layerDirNameFor(layer, frontend) {
-  return layer === "pages" && frontend === "next" ? "_pages" : layer;
+  return profileById(frontend).layerDirs[layer] ?? layer;
 }
 function layerDirFor(layer, sourceRoot, frontend = "react-vite") {
   return `${sourceRoot}/${layerDirNameFor(layer, frontend)}`;
 }
-var NEXT_CONFIG_FILES = ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs"];
-function resolveFrontendForApp(option, config, appRoot, tree) {
-  if (option === "react-vite" || option === "next") return option;
+function resolveFrontendForApp(option, config, detected) {
+  if (option !== void 0) return option;
   const recorded = config?.["frontend"];
   if (typeof recorded === "string" && RECORDED_FRONTENDS.includes(recorded) && recorded !== "none") {
     return recorded;
   }
-  const prefix = appRoot === "" || appRoot === "." ? "" : `${appRoot}/`;
-  return NEXT_CONFIG_FILES.some((file) => tree.exists(`${prefix}${file}`)) ? "next" : "react-vite";
+  return detected;
 }
 function listFilesUnder(tree, dir, prefix = "") {
   return tree.children(dir).flatMap((child) => {
@@ -279,15 +430,23 @@ function runFsdSlice(tree, layer, options) {
   if (badSegment !== void 0) return refusal("invalid-segment", dryRun, layer, options.name, unresolved, { detail: badSegment });
   const essenceSegment = segments.find((segment) => isEssenceSegmentName(segment));
   if (essenceSegment !== void 0) return refusal("segment-by-essence", dryRun, layer, options.name, unresolved, { detail: essenceSegment });
+  if (options.group !== void 0 && layer === "shared") return refusal("group-on-shared", dryRun, layer, options.name, unresolved);
+  if (options.group !== void 0 && (!KEBAB_CASE.test(options.group) || SEGMENT_FOLDERS.includes(options.group) || isEssenceSegmentName(options.group))) {
+    return refusal("invalid-group", dryRun, layer, options.name, unresolved, { detail: options.group });
+  }
   const app = resolveFrontendApp(tree, options.project);
   if (app.kind === "not-found") return refusal("project-not-found", dryRun, layer, options.name, { project: app.project, sourceRoot: unresolved.sourceRoot });
-  if (app.kind === "ambiguous") return refusal("ambiguous-frontend", dryRun, layer, options.name, unresolved, { candidates: app.candidates });
+  if (app.kind === "ambiguous") {
+    return refusal("ambiguous-frontend", dryRun, layer, options.name, unresolved, { candidates: app.candidates, recordedFrontends: recordedFrontends(readToolkitConfig(tree)) });
+  }
   if (app.kind === "invalid-project-json") return refusal("invalid-project-json", dryRun, layer, options.name, unresolved, { detail: app.detail });
-  if (app.kind === "none") return refusal("no-frontend-app", dryRun, layer, options.name, unresolved);
+  if (app.kind === "none") return refusal("no-frontend-app", dryRun, layer, options.name, unresolved, { candidates: app.otherProjects });
   const config = readToolkitConfig(tree);
-  const frontend = resolveFrontendForApp(options.frontend, config, app.root, tree);
+  const frontend = resolveFrontendForApp(options.frontend, config, app.framework);
   const layerDir = layerDirFor(layer, app.sourceRoot, frontend);
   const locale = resolveLocaleOption(options.locale, config);
+  const requested = options.unitTestRunner !== void 0 && options.unitTestRunner !== "auto" ? options.unitTestRunner : recordedUnitTestRunner(config);
+  const runner = requested ?? detectUnitTestRunner(tree, app.root);
   const plan = composeSlice({
     layer,
     name: options.name,
@@ -295,7 +454,9 @@ function runFsdSlice(tree, layer, options) {
     locale,
     sourceRoot: app.sourceRoot,
     layerDirName: layerDirNameFor(layer, frontend),
-    segments
+    segments,
+    group: options.group,
+    withSpec: runner !== "none"
   });
   const action = computeSliceAction(tree, plan);
   if (action === "created" && !dryRun) {
@@ -312,9 +473,53 @@ function runFsdSlice(tree, layer, options) {
     refused: false,
     refusalReason: null,
     action,
-    files: plan.files
+    files: plan.files,
+    ...runner === "none" ? { specSkipped: requested === "none" ? "none-requested" : "no-test-runner" } : {}
   };
 }
+var SEGMENT_FOLDERS = ["ui", "model", "api", "lib", "config"];
+function recordedUnitTestRunner(config) {
+  const fsd = config?.["fsd"];
+  const value = typeof fsd === "object" && fsd !== null ? fsd["unitTestRunner"] : void 0;
+  return value === "jest" || value === "vitest" || value === "none" ? value : void 0;
+}
+function hasDependency(tree, manifest, name) {
+  const raw = tree.read(manifest, "utf-8");
+  if (raw === null) return false;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed["dependencies"]?.[name] !== void 0 || parsed["devDependencies"]?.[name] !== void 0;
+  } catch {
+    return false;
+  }
+}
+function detectUnitTestRunner(tree, projectRoot) {
+  const prefix = projectRoot === "" || projectRoot === "." ? "" : `${projectRoot}/`;
+  const project = tree.read(`${prefix}project.json`, "utf-8");
+  if (project !== null) {
+    try {
+      const targets = JSON.parse(project).targets ?? {};
+      for (const target of Object.values(targets)) {
+        if (target?.executor?.startsWith("@nx/jest:")) return "jest";
+        if (target?.executor?.startsWith("@nx/vite:test") || target?.executor?.startsWith("@nx/vitest:")) return "vitest";
+      }
+    } catch {
+    }
+  }
+  for (const dir of prefix === "" ? [""] : [prefix, ""]) {
+    if (["ts", "mts", "cts", "js", "mjs", "cjs"].some((ext) => tree.exists(`${dir}jest.config.${ext}`))) return "jest";
+    if (["ts", "mts", "js", "mjs"].some((ext) => tree.exists(`${dir}vitest.config.${ext}`) || tree.exists(`${dir}vitest.workspace.${ext}`))) return "vitest";
+    for (const ext of ["ts", "mts", "js", "mjs"]) {
+      const vite = tree.read(`${dir}vite.config.${ext}`, "utf-8");
+      if (vite !== null && /\btest\s*:/.test(vite)) return "vitest";
+    }
+  }
+  for (const manifest of prefix === "" ? ["package.json"] : [`${prefix}package.json`, "package.json"]) {
+    if (hasDependency(tree, manifest, "vitest")) return "vitest";
+    if (hasDependency(tree, manifest, "jest")) return "jest";
+  }
+  return "none";
+}
 
 // src/generators/slice/render.ts
 var ACTION_LINES = {
@@ -340,13 +545,22 @@ function renderSliceReport(report) {
     } else if (report.refusalReason === "ambiguous-frontend") {
       lines.push("  More than one frontend app was found \u2014 rerun with --project=<one of them>:");
       for (const name of report.candidates ?? []) lines.push(`    - ${name}`);
+      if ((report.recordedFrontends ?? []).length > 0) lines.push(`  (toolkit.config.json records: ${(report.recordedFrontends ?? []).join(", ")})`);
     } else if (report.refusalReason === "invalid-project-json") {
       lines.push(`  A project.json could not be parsed (${report.detail ?? "unknown"}) \u2014 fix it, then rerun.`);
+    } else if (report.refusalReason === "no-frontend-app" && (report.candidates ?? []).length > 0) {
+      lines.push("  No project was recognised as a frontend app. If one of these is it, rerun with --project=<name>:");
+      for (const name of report.candidates ?? []) lines.push(`    - ${name}`);
     } else if (report.refusalReason === "no-frontend-app") {
-      lines.push("  The workspace has no frontend application to hold FSD layers \u2014 create one, or pass --project.");
+      lines.push("  The workspace has no projects to hold FSD layers \u2014 create a frontend app first.");
     } else if (report.refusalReason === "invalid-segment") {
       lines.push(`  --segments: "${report.detail ?? ""}" is not a valid segment name.`);
       lines.push("  Use lowercase letters, digits, and single hyphens, starting with a letter (e.g. ui, api, lib).");
+    } else if (report.refusalReason === "group-on-shared") {
+      lines.push("  --group does not apply to shared: shared holds segments, not slices.");
+    } else if (report.refusalReason === "invalid-group") {
+      lines.push(`  --group: "${report.detail ?? ""}" is not a usable group name.`);
+      lines.push('  Use kebab-case (e.g. "mypage"), and not a segment name (ui, model, api, lib, config).');
     } else if (report.refusalReason === "segments-on-shared") {
       lines.push("  --segments does not apply to shared: a shared segment holds no segments of its own.");
       lines.push("  Run the generator once per segment instead (e.g. --name=ui, then --name=api).");
@@ -369,6 +583,11 @@ function renderSliceReport(report) {
     lines.push("  \u2014 or remove the existing directory manually first if you intended to replace it.");
     return lines.join("\n");
   }
+  if (report.specSkipped === "no-test-runner") {
+    lines.push("  no test runner found (jest or vitest) \u2014 no .spec.ts was written; pass --unitTestRunner=jest|vitest to add one.");
+  } else if (report.specSkipped === "none-requested") {
+    lines.push("  no .spec.ts was written (unitTestRunner: none).");
+  }
   if (report.dryRun) {
     for (const file of report.files) {
       lines.push("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clearlydev/nx-archweave",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Nx generators that make a workspace ready to work on in one preset: FSD Lite structure with enforced module boundaries, AI agent rules, GitHub templates, and optional AI PR review (Claude, Gemini, GPT, Cursor)",
   "license": "MIT",
   "author": "clearlydev (https://github.com/clearlydev)",
@@ -93,5 +93,8 @@
   },
   "dependencies": {
     "@nx/devkit": "^23.1.0"
+  },
+  "devDependencies": {
+    "jsonc-parser": "3.3.1"
   }
 }

package/src/generators/add-agent-rules/schema.json

@@ -33,6 +33,11 @@
       "type": "boolean",
       "description": "Include the Team Rules section (collaboration rules for a shared repository). Defaults to toolkit.config.json's agentRules.teamRules, else false"
     },
+    "overwriteBlock": {
+      "type": "boolean",
+      "default": false,
+      "description": "Replace the nx-archweave block even when it was edited by hand (otherwise an edited block is kept and the report shows the difference)"
+    },
     "dryRun": {
       "type": "boolean",
       "default": false,

package/src/generators/add-fsd-lite/schema.json

@@ -7,8 +7,8 @@
   "properties": {
     "frontend": {
       "type": "string",
-      "enum": ["react-vite", "next"],
-      "description": "Target frontend — decides the layer set the guide prints. Next.js has no FSD 'app' layer (its App Router directory is it) and its pages layer is the _pages/ directory (FSD's Next.js guide: Next.js reads src/pages as its Pages Router). Omitted: toolkit.config.json's frontend (init records it); required when none is recorded"
+      "enum": ["react-vite", "next", "expo", "generic"],
+      "description": "Target frontend — decides the layer set the guide prints. Next.js has no FSD 'app' layer (its App Router directory is it) and its pages layer is the _pages/ directory (FSD's Next.js guide: Next.js reads src/pages as its Pages Router). 'generic' is any other framework: the common FSD rules, no renamed layers. Omitted: toolkit.config.json's frontend (init records it); required when none is recorded"
     },
     "project": {
       "type": "string",

package/src/generators/entity/schema.json

@@ -7,7 +7,8 @@
   "properties": {
     "name": {
       "type": "string",
-      "description": "Slice name in kebab-case (e.g. \"user\") — becomes <app>/src/entities/<name>. Invalid values are refused with a report, not thrown"
+      "description": "Slice name in kebab-case (e.g. \"user\") — becomes <app>/src/entities/<name>. Invalid values are refused with a report, not thrown",
+      "$default": { "$source": "argv", "index": 0 }
     },
     "publicApiName": {
       "type": "string",
@@ -18,6 +19,15 @@
       "items": { "type": "string" },
       "description": "Extra segments to start the slice with, each as <segment>/index.ts (e.g. ui,api). model always exists — it holds the stub. Names are by purpose: ui, api, lib, config … (components/hooks/utils/types are refused)"
     },
+    "group": {
+      "type": "string",
+      "description": "A slice group folder to put the slice in: <layer>/<group>/<name>/ (e.g. --group=mypage). The group folder itself gets no files — FSD keeps each slice in it separate"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["auto", "jest", "vitest", "none"],
+      "description": "Whether the stub gets a .spec.ts. auto (default): when the app or workspace has jest or vitest (a test target, a runner config, or the dependency); toolkit.config.json's fsd.unitTestRunner comes before detection"
+    },
     "project": {
       "type": "string",
       "description": "The frontend app whose source root holds the FSD layers (run add-fsd-lite first). Omitted: the workspace's one frontend application; with more than one, the run is refused with the candidates listed"

package/src/generators/feature/schema.json

@@ -7,7 +7,8 @@
   "properties": {
     "name": {
       "type": "string",
-      "description": "Slice name in kebab-case (e.g. \"add-to-cart\") — becomes <app>/src/features/<name>. Invalid values are refused with a report, not thrown"
+      "description": "Slice name in kebab-case (e.g. \"add-to-cart\") — becomes <app>/src/features/<name>. Invalid values are refused with a report, not thrown",
+      "$default": { "$source": "argv", "index": 0 }
     },
     "publicApiName": {
       "type": "string",
@@ -18,6 +19,15 @@
       "items": { "type": "string" },
       "description": "Extra segments to start the slice with, each as <segment>/index.ts (e.g. ui,api). model always exists — it holds the stub. Names are by purpose: ui, api, lib, config … (components/hooks/utils/types are refused)"
     },
+    "group": {
+      "type": "string",
+      "description": "A slice group folder to put the slice in: <layer>/<group>/<name>/ (e.g. --group=mypage). The group folder itself gets no files — FSD keeps each slice in it separate"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["auto", "jest", "vitest", "none"],
+      "description": "Whether the stub gets a .spec.ts. auto (default): when the app or workspace has jest or vitest (a test target, a runner config, or the dependency); toolkit.config.json's fsd.unitTestRunner comes before detection"
+    },
     "project": {
       "type": "string",
       "description": "The frontend app whose source root holds the FSD layers (run add-fsd-lite first). Omitted: the workspace's one frontend application; with more than one, the run is refused with the candidates listed"

package/src/generators/init/schema.json

@@ -19,9 +19,11 @@
       "enum": [
         "react-vite",
         "next",
+        "expo",
+        "generic",
         "none"
       ],
-      "description": "Target frontend; 'none' is a backend-only workspace (needs --backend; FSD is skipped). Recorded in toolkit.config.json; omitted: the recorded one (required when none is recorded)"
+      "description": "Target frontend; 'generic' is a framework nx-archweave does not recognise (common FSD rules, no renamed layers); 'none' is a backend-only workspace (needs --backend; FSD is skipped). Recorded in toolkit.config.json; omitted: the recorded one (required when none is recorded)"
     },
     "backend": {
       "type": "string",
@@ -74,10 +76,19 @@
       "default": false,
       "description": "Preview the full pipeline: zero writes, and the post-run validation callback never runs"
     },
+    "project": {
+      "oneOf": [{ "type": "string" }, { "type": "array", "items": { "type": "string" } }],
+      "description": "The frontend app(s) the FSD section sets up, comma-separated (web,admin). Needed when the workspace has more than one frontend; each gets the rule and is recorded in toolkit.config.json's frontends"
+    },
+    "strict": {
+      "type": "boolean",
+      "default": false,
+      "description": "Fail the run (non-zero exit) when a section aborts or is refused. Files the other sections wrote stay; the report lists them. Without it init always succeeds and reports"
+    },
     "allowDirty": {
       "type": "boolean",
       "default": false,
-      "description": "Run even when the working tree has uncommitted changes. The report then warns that `git restore .` also reverts those pre-existing changes. Used by create-nx-archweave, whose own plugin-install step dirties the fresh workspace right before init runs"
+      "description": "Run even when the working tree has uncommitted changes. The report then warns that restoring the files init modified also reverts those pre-existing changes. Used by create-nx-archweave, whose own plugin-install step dirties the fresh workspace right before init runs"
     },
     "applyEslint": {
       "type": "boolean",

package/src/generators/page/schema.json

@@ -7,7 +7,8 @@
   "properties": {
     "name": {
       "type": "string",
-      "description": "Slice name in kebab-case (e.g. \"home\") — becomes <app>/src/pages/<name> (a screen composed from the layers below). Invalid values are refused with a report, not thrown"
+      "description": "Slice name in kebab-case (e.g. \"home\") — becomes <app>/src/pages/<name> (a screen composed from the layers below). Invalid values are refused with a report, not thrown",
+      "$default": { "$source": "argv", "index": 0 }
     },
     "publicApiName": {
       "type": "string",
@@ -20,6 +21,15 @@
       },
       "description": "Extra segments to start the slice with, each as <segment>/index.ts (e.g. ui,api). model always exists — it holds the stub. Names are by purpose: ui, api, lib, config … (components/hooks/utils/types are refused)"
     },
+    "group": {
+      "type": "string",
+      "description": "A slice group folder to put the slice in: <layer>/<group>/<name>/ (e.g. --group=mypage). The group folder itself gets no files — FSD keeps each slice in it separate"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["auto", "jest", "vitest", "none"],
+      "description": "Whether the stub gets a .spec.ts. auto (default): when the app or workspace has jest or vitest (a test target, a runner config, or the dependency); toolkit.config.json's fsd.unitTestRunner comes before detection"
+    },
     "project": {
       "type": "string",
       "description": "The frontend app whose source root holds the FSD layers. Omitted: the workspace's one frontend application; with more than one, the run is refused with the candidates listed"
@@ -28,9 +38,11 @@
       "type": "string",
       "enum": [
         "react-vite",
-        "next"
+        "next",
+        "expo",
+        "generic"
       ],
-      "description": "Decides the layer directory: pages/ on react-vite, _pages/ on next (Next.js reads src/pages as its Pages Router). Omitted: toolkit.config.json's frontend (init records it), else detected from a next.config file in the app, else react-vite"
+      "description": "Decides the layer directory: pages/ on react-vite, _pages/ on next (Next.js reads src/pages as its Pages Router); 'generic' keeps every layer name. Omitted: toolkit.config.json's frontend (init records it), else detected from the app (its next.config / vite config, executors and dependencies), else generic"
     },
     "locale": {
       "type": "string",

package/src/generators/shared/schema.json

@@ -7,12 +7,18 @@
   "properties": {
     "name": {
       "type": "string",
-      "description": "Slice name in kebab-case (e.g. \"date-format\") — becomes <app>/src/shared/<name>. Invalid values are refused with a report, not thrown"
+      "description": "Slice name in kebab-case (e.g. \"date-format\") — becomes <app>/src/shared/<name>. Invalid values are refused with a report, not thrown",
+      "$default": { "$source": "argv", "index": 0 }
     },
     "publicApiName": {
       "type": "string",
       "description": "Exported stub function name. Defaults to the camelCase form of name"
     },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["auto", "jest", "vitest", "none"],
+      "description": "Whether the stub gets a .spec.ts. auto (default): when the app or workspace has jest or vitest (a test target, a runner config, or the dependency); toolkit.config.json's fsd.unitTestRunner comes before detection"
+    },
     "project": {
       "type": "string",
       "description": "The frontend app whose source root holds the FSD layers (run add-fsd-lite first). Omitted: the workspace's one frontend application; with more than one, the run is refused with the candidates listed"

package/src/generators/widget/schema.json

@@ -7,7 +7,8 @@
   "properties": {
     "name": {
       "type": "string",
-      "description": "Slice name in kebab-case (e.g. \"header\") — becomes <app>/src/widgets/<name> (a self-contained block of UI composed from features and entities). Invalid values are refused with a report, not thrown"
+      "description": "Slice name in kebab-case (e.g. \"header\") — becomes <app>/src/widgets/<name> (a self-contained block of UI composed from features and entities). Invalid values are refused with a report, not thrown",
+      "$default": { "$source": "argv", "index": 0 }
     },
     "publicApiName": {
       "type": "string",
@@ -20,6 +21,15 @@
       },
       "description": "Extra segments to start the slice with, each as <segment>/index.ts (e.g. ui,api). model always exists — it holds the stub. Names are by purpose: ui, api, lib, config … (components/hooks/utils/types are refused)"
     },
+    "group": {
+      "type": "string",
+      "description": "A slice group folder to put the slice in: <layer>/<group>/<name>/ (e.g. --group=mypage). The group folder itself gets no files — FSD keeps each slice in it separate"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["auto", "jest", "vitest", "none"],
+      "description": "Whether the stub gets a .spec.ts. auto (default): when the app or workspace has jest or vitest (a test target, a runner config, or the dependency); toolkit.config.json's fsd.unitTestRunner comes before detection"
+    },
     "project": {
       "type": "string",
       "description": "The frontend app whose source root holds the FSD layers. Omitted: the workspace's one frontend application; with more than one, the run is refused with the candidates listed"