@clearlydev/nx-archweave 0.3.2 → 0.4.0

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

@@ -0,0 +1,8 @@
+// src/generators/shared/dry-run.ts
+function resolveDryRun(options) {
+  return process.env["NX_DRY_RUN"] === "true" || (options.dryRun ?? false);
+}
+
+export {
+  resolveDryRun
+};

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

@@ -0,0 +1,20 @@
+// 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";
+}
+
+export {
+  resolveProjectType
+};

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

@@ -0,0 +1,49 @@
+// ../integrations/dist/manifest/manifest.js
+import { existsSync, lstatSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+var MANIFEST_FILENAME = "archweave-integrations.json";
+function createEmptyManifest() {
+  return { integrations: {} };
+}
+function loadManifest(root) {
+  const manifestPath = join(root, MANIFEST_FILENAME);
+  if (!existsSync(manifestPath)) {
+    return createEmptyManifest();
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    if (parsed && typeof parsed === "object" && typeof parsed.integrations === "object") {
+      return { integrations: parsed.integrations ?? {} };
+    }
+    return createEmptyManifest();
+  } catch {
+    return createEmptyManifest();
+  }
+}
+function serializeManifest(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+function writeManifestAtomic(root, manifest) {
+  const finalPath = join(root, MANIFEST_FILENAME);
+  if (existsSync(finalPath) && lstatSync(finalPath).isSymbolicLink()) {
+    throw new Error(`Refusing to write ${MANIFEST_FILENAME}: the path is a symlink. Remove or replace it with a regular file first.`);
+  }
+  const suffix = randomBytes(6).toString("hex");
+  const tempPath = join(root, `.${MANIFEST_FILENAME}.tmp-${suffix}`);
+  try {
+    writeFileSync(tempPath, serializeManifest(manifest));
+    renameSync(tempPath, finalPath);
+  } catch (error) {
+    if (existsSync(tempPath)) {
+      unlinkSync(tempPath);
+    }
+    throw error;
+  }
+}
+
+export {
+  loadManifest,
+  writeManifestAtomic
+};

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

@@ -0,0 +1,73 @@
+import {
+  loadManifest,
+  writeManifestAtomic
+} from "./chunk-U6LAFHSF.js";
+import {
+  getCatalogEntry,
+  recordMetadataFor,
+  verifyClaudeMarketplacePlugin
+} from "./chunk-AQHV7DJS.js";
+
+// ../integrations/dist/manifest/record-plan.js
+function entriesEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function buildRecordPlan(input) {
+  const isRecordable = input.verification.verified && input.verificationSource === "claude-cli";
+  const proposedEntry = isRecordable ? {
+    source: input.metadata.source,
+    repository: input.metadata.repository,
+    version: input.verification.resolvedVersion,
+    method: input.metadata.method,
+    managedBy: "nx-archweave",
+    verification: "passed",
+    target: input.target,
+    evidenceKind: "claude-cli"
+  } : void 0;
+  const hasConflict = input.existingEntry !== void 0 && proposedEntry !== void 0 && !entriesEqual(input.existingEntry, proposedEntry);
+  return {
+    id: input.id,
+    target: input.target,
+    verificationSource: input.verificationSource,
+    currentVerification: input.verification,
+    existingEntry: input.existingEntry,
+    proposedEntry,
+    hasConflict
+  };
+}
+
+// src/generators/shared/record-pipeline.ts
+async function runRecordPipeline(input) {
+  const entry = getCatalogEntry(input.id);
+  const metadata = entry === void 0 ? void 0 : recordMetadataFor(entry);
+  if (!entry || !metadata) {
+    throw new Error(`No manifest metadata is defined for "${input.id}".`);
+  }
+  const { result: verification, source: verificationSource } = await verifyClaudeMarketplacePlugin(
+    entry,
+    { runner: input.runner },
+    { workspaceRoot: input.workspaceRoot, targetEnvironment: input.target }
+  );
+  const manifest = loadManifest(input.workspaceRoot);
+  const existingEntry = manifest.integrations[input.id];
+  const plan = buildRecordPlan({ id: input.id, target: input.target, verificationSource, verification, existingEntry, metadata });
+  let wasWritten = false;
+  if (input.write && plan.proposedEntry) {
+    writeManifestAtomic(input.workspaceRoot, {
+      integrations: { ...manifest.integrations, [input.id]: plan.proposedEntry }
+    });
+    wasWritten = true;
+  }
+  return {
+    verificationSource,
+    verification,
+    existingEntry,
+    proposedEntry: plan.proposedEntry,
+    hasConflict: plan.hasConflict,
+    wasWritten
+  };
+}
+
+export {
+  runRecordPipeline
+};

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

@@ -0,0 +1,25 @@
+// src/generators/shared/template-files.ts
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { generateFiles } from "@nx/devkit";
+import { createTree } from "@nx/devkit/testing";
+function generatorFilesDir(generator, fromUrl) {
+  for (const relative of [`../${generator}/files`, `./generators/${generator}/files`]) {
+    const dir = fileURLToPath(new URL(relative, fromUrl));
+    if (existsSync(dir)) return dir;
+  }
+  throw new Error(`The "${generator}" generator's template files are missing next to ${fileURLToPath(fromUrl)}`);
+}
+function renderTemplateFiles(srcFolder, target, substitutions) {
+  const scratch = createTree();
+  const seeded = new Set(scratch.listChanges().map((change) => change.path));
+  generateFiles(scratch, srcFolder, target, substitutions);
+  return scratch.listChanges().flatMap(
+    (change) => change.type === "CREATE" && change.content !== null && !seeded.has(change.path) ? [{ filePath: change.path, content: change.content.toString("utf-8") }] : []
+  ).sort((a, b) => a.filePath.localeCompare(b.filePath));
+}
+
+export {
+  generatorFilesDir,
+  renderTemplateFiles
+};

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

@@ -0,0 +1,282 @@
+import {
+  applyFsdEslintConfig,
+  buildFsdEslintPasteSnippet,
+  composeFsdLayerGuide
+} from "./chunk-L2RZ2LBO.js";
+import {
+  profileById,
+  resolveFrontendApp
+} from "./chunk-2WSX5YNB.js";
+import {
+  ESLINT_CONFIG_CANDIDATES
+} from "./chunk-6ZTIUBB2.js";
+import {
+  resolveDryRun
+} from "./chunk-TUN34LAQ.js";
+import {
+  applyJsonEdits,
+  readToolkitConfig,
+  resolveFrontendOption,
+  resolveLocaleOption,
+  setJsonValue,
+  treePackageManager
+} from "./chunk-EXYZLL7A.js";
+import {
+  detectYarnFlavor,
+  packageManagerCommands
+} from "./chunk-FQHFT5IH.js";
+
+// src/generators/add-fsd-lite/generator.ts
+import { posix } from "node:path";
+
+// ../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;
+}
+var DEFAULT_CONFLICT_POLICY = "merge-proposal";
+
+// ../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({ renamedLayerDirs, 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',",
+    ...renamedLayerDirs.length > 0 ? [
+      ko ? `      // ${renamedLayerDirs.join(", ")}: \uD504\uB808\uC784\uC6CC\uD06C \uB77C\uC6B0\uD130\uC640 \uACB9\uCE58\uC9C0 \uC54A\uAC8C \uC774\uB984\uC744 \uBC14\uAFBC \uB808\uC774\uC5B4 (FSD \uACF5\uC2DD \uBA85\uBA85) \u2014 steiger 0.7\uC740 \uC544\uC9C1 \uC624\uD0C0\uB85C \uBD05\uB2C8\uB2E4.` : `      // ${renamedLayerDirs.join(", ")}: layers renamed out of the framework router's way (FSD's own naming) \u2014 steiger 0.7 still reads them as typos`,
+      "      'fsd/typo-in-layer-name': 'off',"
+    ] : [],
+    "    },",
+    "  },",
+    "]);",
+    ""
+  ];
+  return lines.join("\n");
+}
+
+// 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 if (refusal.otherProjects.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 refusal.otherProjects) lines.push(`      - ${name}`);
+      } else {
+        lines.push("    the workspace has no projects \u2014 create one (e.g. nx g @nx/react:app or nx g @nx/next:app), then rerun.");
+      }
+    }
+    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 && report.frontend === "generic") {
+    lines.push("Frontend: framework not recognised \u2014 the common FSD rules apply, with no framework-specific layer names.");
+  }
+  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 app = resolveFrontendApp(tree, options.project);
+  if (app.kind !== "found") {
+    const snippet2 = buildFsdEslintPasteSnippet(enforcement, locale);
+    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", otherProjects: app.otherProjects };
+    return { dryRun, aborted: true, appRefusal, project: null, sourceRoot: null, enforcement, frontend, eslint: "not-applied", eslintPath: null, snippet: snippet2, layerGuide: null, steiger: null };
+  }
+  const appDir = app.root === "" || app.root === "." ? "" : `${app.root}/`;
+  const eslintRoot = posix.relative(app.root === "" ? "." : app.root, app.sourceRoot) || ".";
+  const profile = app.framework === frontend ? app.profile : profileById(frontend);
+  const { platformSuffixes, routerDirs } = profile;
+  const framework = { platformSuffixes, routerDirs };
+  const snippet = buildFsdEslintPasteSnippet(enforcement, locale, eslintRoot, framework);
+  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, eslintRoot, framework).status === "already-applied" ? "already-applied" : "snippet-only";
+  } else if (configText === null) {
+    eslint = "degraded-unrecognized";
+  } else {
+    const result = applyFsdEslintConfig(configText, enforcement, eslintRoot, framework);
+    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, profile, locale, write: !dryRun, config }) : null;
+  return {
+    dryRun,
+    aborted: false,
+    appRefusal: null,
+    project: app.project,
+    sourceRoot: app.sourceRoot,
+    steiger,
+    enforcement,
+    frontend,
+    eslint,
+    eslintPath,
+    snippet: eslint === "applied" || eslint === "already-applied" ? null : snippet,
+    layerGuide: composeFsdLayerGuide({ profile, 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({ renamedLayerDirs: Object.values(input.profile.layerDirs), 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";
+      const path = candidate.endsWith("project.json") ? ["targets", FSD_CHECK_TARGET] : ["nx", "targets", FSD_CHECK_TARGET];
+      if (input.write) tree.write(candidate, setJsonValue(file.raw, path, target));
+    }
+    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";
+      const edited = applyJsonEdits(rootPackage.raw, missing.map(([name, range]) => [["devDependencies", name], range]));
+      if (input.write) tree.write("package.json", edited);
+    }
+  }
+  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 {
+  DEFAULT_CONFLICT_POLICY,
+  renderAddFsdLiteReport,
+  runAddFsdLite,
+  addFsdLiteGenerator,
+  generator_default
+};