@clearlydev/nx-archweave 0.3.2 → 0.3.3

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

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

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

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

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
+};