safeword 0.55.0 → 0.57.0

package/dist/architecture-3QIZFW3W.js

@@ -0,0 +1,758 @@
+import {
+  GENERATED_ARCHITECTURE_FILENAME,
+  isArchitectureDocumentEnforcementEnabled,
+  resolveGeneratedArchitecturePath
+} from "./chunk-P2IC575P.js";
+import {
+  detectWorkspaces
+} from "./chunk-TTFKJM7Q.js";
+import {
+  error,
+  success
+} from "./chunk-NWCBLTIE.js";
+import {
+  exists,
+  isDirectory,
+  readFileSafe,
+  readJson
+} from "./chunk-KIZYVSME.js";
+
+// src/commands/architecture.ts
+import { execFileSync } from "child_process";
+import nodePath5 from "path";
+import process from "process";
+
+// src/utils/architecture-document.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import nodePath4 from "path";
+
+// src/utils/architecture-fingerprint.ts
+import { createHash } from "crypto";
+import { readdirSync as readdirSync2, readFileSync } from "fs";
+import nodePath2 from "path";
+
+// src/utils/architecture-skeleton.ts
+import { readdirSync } from "fs";
+import nodePath from "path";
+var PURPOSE_PLACEHOLDER = "No description yet \u2014 awaiting prose.";
+var GO_LAYOUT_DIRECTORIES = ["cmd", "internal", "pkg"];
+var RUST_ROOT_FILES = /* @__PURE__ */ new Set(["lib.rs", "main.rs"]);
+function extractSkeleton(projectDirectory) {
+  if (exists(nodePath.join(projectDirectory, "Cargo.toml"))) {
+    return { nodes: rustModuleNodes(projectDirectory) };
+  }
+  const sourceNodes = enumerateModuleDirectories(
+    nodePath.join(projectDirectory, "src"),
+    (name) => `src/${name}`
+  );
+  if (sourceNodes.length > 0) return { nodes: sourceNodes };
+  if (exists(nodePath.join(projectDirectory, "go.mod"))) {
+    return { nodes: goLayoutNodes(projectDirectory) };
+  }
+  return { nodes: sourceNodes };
+}
+function enumerateModuleDirectories(directory, pathFor) {
+  let entries;
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => ({ name: entry.name, path: pathFor(entry.name), purpose: PURPOSE_PLACEHOLDER })).toSorted((a, b) => a.name.localeCompare(b.name));
+}
+function goLayoutNodes(projectDirectory) {
+  return GO_LAYOUT_DIRECTORIES.filter((name) => isDirectory(nodePath.join(projectDirectory, name))).map((name) => ({ name, path: name, purpose: PURPOSE_PLACEHOLDER })).toSorted((a, b) => a.name.localeCompare(b.name));
+}
+function rustModuleNodes(projectDirectory) {
+  let entries;
+  try {
+    entries = readdirSync(nodePath.join(projectDirectory, "src"), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      byName.set(entry.name, {
+        name: entry.name,
+        path: `src/${entry.name}`,
+        purpose: PURPOSE_PLACEHOLDER
+      });
+    }
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory() || !entry.name.endsWith(".rs") || RUST_ROOT_FILES.has(entry.name)) {
+      continue;
+    }
+    const name = entry.name.slice(0, -".rs".length);
+    if (!byName.has(name)) {
+      byName.set(name, { name, path: `src/${entry.name}`, purpose: PURPOSE_PLACEHOLDER });
+    }
+  }
+  return byName.values().toArray().toSorted((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/utils/cargo-manifest.ts
+var DEPENDENCY_TABLES = ["dependencies", "dev-dependencies", "build-dependencies"];
+function readCargoWorkspaceMembers(content) {
+  const body = workspaceMembersArrayBody(content.split(/\r?\n/));
+  if (body === void 0) return void 0;
+  const globs = body.matchAll(/"([^"]*)"|'([^']*)'/g).map((match) => match[1] ?? match[2] ?? "").filter((glob) => glob.length > 0).toArray();
+  return globs.length > 0 ? globs : void 0;
+}
+function workspaceMembersArrayBody(lines) {
+  let inWorkspace = false;
+  let body;
+  for (const rawLine of lines) {
+    const line = stripComment(rawLine);
+    const trimmed = line.trim();
+    if (body === void 0) {
+      const header = /^\[\[?([^[\]]+)\]\]?\s*$/.exec(trimmed);
+      if (header?.[1] !== void 0) {
+        inWorkspace = header[1].trim() === "workspace";
+        continue;
+      }
+      const opening = inWorkspace ? /members\s*=\s*\[(.*)$/.exec(trimmed) : void 0;
+      if (opening?.[1] === void 0) continue;
+      body = opening[1];
+    } else {
+      body += `
+${line}`;
+    }
+    const close = body.indexOf("]");
+    if (close !== -1) return body.slice(0, close);
+  }
+  return body;
+}
+function readCargoPackageName(content) {
+  return scanTables(content).packageName;
+}
+function readCargoDependencyNames(content) {
+  return [...scanTables(content).dependencyNames];
+}
+function scanTables(content) {
+  const scan = { packageName: void 0, dependencyNames: /* @__PURE__ */ new Set() };
+  let currentTable = "";
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = stripComment(rawLine).trim();
+    if (line === "") continue;
+    const header = /^\[\[?([^\]]+)\]\]?$/.exec(line);
+    if (header?.[1] !== void 0) {
+      currentTable = header[1].trim();
+      const subTableDependency = dependencySubTableName(currentTable);
+      if (subTableDependency !== void 0) scan.dependencyNames.add(subTableDependency);
+      continue;
+    }
+    collectKey(line, currentTable, scan);
+  }
+  return scan;
+}
+function collectKey(line, currentTable, scan) {
+  const key = leadingKey(line);
+  if (key === void 0) return;
+  if (currentTable === "package" && key === "name") {
+    scan.packageName ??= stringValue(line);
+  } else if (DEPENDENCY_TABLES.includes(currentTable)) {
+    scan.dependencyNames.add(key);
+  }
+}
+function dependencySubTableName(table) {
+  for (const dependencyTable of DEPENDENCY_TABLES) {
+    if (!table.startsWith(`${dependencyTable}.`)) continue;
+    const name = unquote(table.slice(dependencyTable.length + 1).trim());
+    return name.length > 0 ? name : void 0;
+  }
+  return void 0;
+}
+function leadingKey(line) {
+  const match = /^("[^"]+"|'[^']+'|[\w-]+)\s*=/.exec(line);
+  return match?.[1] === void 0 ? void 0 : unquote(match[1]);
+}
+function stringValue(line) {
+  return /=\s*"([^"]*)"/.exec(line)?.[1];
+}
+function stripComment(line) {
+  const hash = line.indexOf("#");
+  return hash === -1 ? line : line.slice(0, hash);
+}
+function unquote(value) {
+  return value.replaceAll(/^["']|["']$/g, "");
+}
+
+// src/utils/manifest-block.ts
+function readDelimitedBlock(lines, opener) {
+  const entries = [];
+  let inBlock = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!inBlock) {
+      if (opener.test(trimmed)) inBlock = true;
+      continue;
+    }
+    if (trimmed.startsWith(")")) inBlock = false;
+    else if (trimmed !== "" && !trimmed.startsWith("//")) entries.push(trimmed);
+  }
+  return entries;
+}
+
+// src/utils/manifest-dependencies.ts
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function dependencySectionNames(manifest) {
+  const names = /* @__PURE__ */ new Set();
+  for (const section of DEPENDENCY_SECTIONS) {
+    const entry = manifest[section];
+    if (entry !== null && typeof entry === "object") {
+      for (const name of Object.keys(entry)) names.add(name);
+    }
+  }
+  return [...names];
+}
+
+// src/utils/architecture-fingerprint.ts
+var DEPENDENCY_CRUISER_CONFIG_NAMES = [
+  ".dependency-cruiser.cjs",
+  ".dependency-cruiser.js",
+  ".dependency-cruiser.mjs",
+  ".dependency-cruiser.json"
+];
+var SCHEMA_EXTENSIONS = /* @__PURE__ */ new Set([".sql", ".prisma"]);
+var SHAPE_SCAN_EXCLUDED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".project",
+  ".safeword",
+  "dist",
+  "node_modules"
+]);
+var byString = (a, b) => a.localeCompare(b);
+function collectShapeInputs(projectDirectory) {
+  const moduleNames = extractSkeleton(projectDirectory).nodes.map((node) => node.name).toSorted(byString);
+  return {
+    moduleNames,
+    dependencyNames: readDependencyNames(projectDirectory),
+    boundaryConfig: readBoundaryConfig(projectDirectory),
+    schemaFiles: collectSchemaFiles(projectDirectory)
+  };
+}
+function shapeFingerprint(projectDirectory) {
+  const inputs = collectShapeInputs(projectDirectory);
+  return createHash("sha256").update(JSON.stringify(inputs)).digest("hex");
+}
+function readDependencyNames(projectDirectory) {
+  const names = new Set(readPackageJsonDependencyNames(projectDirectory));
+  for (const goModule of readGoModuleRequires(projectDirectory)) names.add(goModule);
+  for (const crate of readCargoDependencies(projectDirectory)) names.add(crate);
+  return [...names].toSorted(byString);
+}
+function readPackageJsonDependencyNames(projectDirectory) {
+  const manifest = readJson2(nodePath2.join(projectDirectory, "package.json"));
+  return manifest === void 0 ? [] : dependencySectionNames(manifest);
+}
+function readCargoDependencies(projectDirectory) {
+  try {
+    return readCargoDependencyNames(
+      readFileSync(nodePath2.join(projectDirectory, "Cargo.toml"), "utf8")
+    );
+  } catch {
+    return [];
+  }
+}
+function readGoModuleRequires(projectDirectory) {
+  let content;
+  try {
+    content = readFileSync(nodePath2.join(projectDirectory, "go.mod"), "utf8");
+  } catch {
+    return [];
+  }
+  const lines = content.split(/\r?\n/);
+  const modules = /* @__PURE__ */ new Set();
+  collectGoRequireBlock(lines, modules);
+  collectGoRequireLines(lines, modules);
+  return [...modules].toSorted(byString);
+}
+function collectGoRequireBlock(lines, modules) {
+  for (const entry of readDelimitedBlock(lines, /^require\s*\(\s*$/)) {
+    const [modulePath] = entry.split(/\s+/);
+    if (modulePath !== void 0 && modulePath.length > 0) modules.add(modulePath);
+  }
+}
+function collectGoRequireLines(lines, modules) {
+  for (const line of lines) {
+    const match = /^require\s+(\S+)\s+\S/.exec(line.trim());
+    if (match?.[1] !== void 0) modules.add(match[1]);
+  }
+}
+function readBoundaryConfig(projectDirectory) {
+  for (const name of DEPENDENCY_CRUISER_CONFIG_NAMES) {
+    try {
+      return readFileSync(nodePath2.join(projectDirectory, name), "utf8");
+    } catch {
+    }
+  }
+  return "";
+}
+function collectSchemaFiles(projectDirectory) {
+  const schemaFiles = [];
+  const pending = [projectDirectory];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    if (directory !== void 0) {
+      scanDirectoryForSchema(projectDirectory, directory, schemaFiles, pending);
+    }
+  }
+  return schemaFiles.toSorted(byString);
+}
+function scanDirectoryForSchema(projectDirectory, directory, schemaFiles, pending) {
+  let entries;
+  try {
+    entries = readdirSync2(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (!SHAPE_SCAN_EXCLUDED_DIRECTORIES.has(entry.name)) {
+        pending.push(nodePath2.join(directory, entry.name));
+      }
+    } else if (SCHEMA_EXTENSIONS.has(nodePath2.extname(entry.name))) {
+      const absolutePath = nodePath2.join(directory, entry.name);
+      schemaFiles.push(nodePath2.relative(projectDirectory, absolutePath).replaceAll("\\", "/"));
+    }
+  }
+}
+function readJson2(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// src/utils/architecture-monorepo.ts
+import { createHash as createHash2 } from "crypto";
+import { globSync } from "fs";
+import nodePath3 from "path";
+var PURPOSE_PLACEHOLDER2 = "No description yet \u2014 awaiting prose.";
+var DEPENDENCY_CRUISER_CONFIG_NAMES2 = [
+  ".dependency-cruiser.cjs",
+  ".dependency-cruiser.js",
+  ".dependency-cruiser.mjs",
+  ".dependency-cruiser.json"
+];
+var byString2 = (a, b) => a.localeCompare(b);
+function discoverLeafDirectories(projectDirectory) {
+  const patterns = detectWorkspaces(projectDirectory) ?? detectPnpmWorkspaces(projectDirectory) ?? detectGoWork(projectDirectory) ?? detectCargoWorkspace(projectDirectory);
+  if (patterns === void 0) return [];
+  const matches = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const globMatches = globSync(pattern, { cwd: projectDirectory });
+    for (const match of globMatches) {
+      const absolute = nodePath3.join(projectDirectory, match);
+      if (isDirectory(absolute) && hasRecognizedManifest(absolute)) {
+        matches.add(absolute);
+      }
+    }
+  }
+  return [...matches].toSorted(byString2);
+}
+function hasRecognizedManifest(directory) {
+  return readJson(nodePath3.join(directory, "package.json")) !== void 0 || readFileSafe(nodePath3.join(directory, "go.mod")) !== void 0 || readFileSafe(nodePath3.join(directory, "Cargo.toml")) !== void 0;
+}
+function extractMonorepoModel(projectDirectory) {
+  const packages = discoverLeafDirectories(projectDirectory).map((dir) => ({
+    name: packageName(dir),
+    dir,
+    purpose: PURPOSE_PLACEHOLDER2,
+    introspected: extractSkeleton(dir).nodes.length > 0
+  })).toSorted((a, b) => byString2(a.name, b.name));
+  const names = new Set(packages.map((node) => node.name));
+  const edges = [];
+  for (const node of packages) {
+    for (const dependencyName of manifestDependencyNames(node.dir)) {
+      if (names.has(dependencyName) && dependencyName !== node.name) {
+        edges.push({ from: node.name, to: dependencyName });
+      }
+    }
+  }
+  edges.sort((a, b) => byString2(a.from, b.from) || byString2(a.to, b.to));
+  return { packages, edges };
+}
+function monorepoFingerprint(projectDirectory) {
+  const model = extractMonorepoModel(projectDirectory);
+  const inputs = {
+    // Introspection status is part of the root shape: a package gaining or losing
+    // a `src/` tree flips its root-index line (marker ↔ described), so the root
+    // index must re-render — otherwise the "not introspected" marker goes stale.
+    packages: model.packages.map((node) => `${node.name}:${node.introspected}`),
+    edges: model.edges.map((edge) => `${edge.from}->${edge.to}`),
+    boundaryConfig: readBoundaryConfig2(projectDirectory)
+  };
+  return createHash2("sha256").update(JSON.stringify(inputs)).digest("hex");
+}
+function readManifest(packageDirectory) {
+  const manifest = readJson(nodePath3.join(packageDirectory, "package.json"));
+  return manifest !== null && typeof manifest === "object" ? manifest : void 0;
+}
+function packageName(packageDirectory) {
+  const name = readManifest(packageDirectory)?.name;
+  if (typeof name === "string" && name.length > 0) return name;
+  return readGoModuleName(packageDirectory) ?? readCargoCrateName(packageDirectory) ?? nodePath3.basename(packageDirectory);
+}
+function readGoModuleName(packageDirectory) {
+  const content = readFileSafe(nodePath3.join(packageDirectory, "go.mod"));
+  if (content === void 0) return void 0;
+  return /^module\s+(\S+)/m.exec(content)?.[1];
+}
+function readCargoCrateName(packageDirectory) {
+  const content = readFileSafe(nodePath3.join(packageDirectory, "Cargo.toml"));
+  return content === void 0 ? void 0 : readCargoPackageName(content);
+}
+function manifestDependencyNames(packageDirectory) {
+  const manifest = readManifest(packageDirectory);
+  return manifest === void 0 ? [] : dependencySectionNames(manifest);
+}
+function readBoundaryConfig2(projectDirectory) {
+  for (const name of DEPENDENCY_CRUISER_CONFIG_NAMES2) {
+    const content = readFileSafe(nodePath3.join(projectDirectory, name));
+    if (content !== void 0) return content;
+  }
+  return "";
+}
+function detectPnpmWorkspaces(projectDirectory) {
+  const content = readFileSafe(nodePath3.join(projectDirectory, "pnpm-workspace.yaml"));
+  if (content === void 0) return void 0;
+  const lines = content.split(/\r?\n/);
+  const start = lines.findIndex((line) => /^packages:\s*$/.test(line));
+  if (start === -1) return void 0;
+  const globs = collectPnpmGlobs(lines.slice(start + 1));
+  return globs.length > 0 ? globs : void 0;
+}
+function collectPnpmGlobs(blockLines) {
+  const globs = [];
+  for (const line of blockLines) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const item = /^\s+-\s+(\S.*)$/.exec(line);
+    if (item?.[1] === void 0) break;
+    const glob = item[1].trim().replaceAll(/^["']|["']$/g, "");
+    if (glob.length > 0 && !glob.startsWith("!")) globs.push(glob);
+  }
+  return globs;
+}
+function detectGoWork(projectDirectory) {
+  const content = readFileSafe(nodePath3.join(projectDirectory, "go.work"));
+  if (content === void 0) return void 0;
+  const lines = content.split(/\r?\n/);
+  const directories = [];
+  collectGoWorkBlock(lines, directories);
+  collectGoWorkSingleLines(lines, directories);
+  return directories.length > 0 ? directories : void 0;
+}
+function collectGoWorkBlock(lines, directories) {
+  for (const entry of readDelimitedBlock(lines, /^use\s*\(\s*$/)) {
+    const target = normalizeUseTarget(entry);
+    if (target !== void 0) directories.push(target);
+  }
+}
+function collectGoWorkSingleLines(lines, directories) {
+  for (const line of lines) {
+    const match = /^use\s+(\S.*)$/.exec(line.trim());
+    if (match?.[1] === void 0 || match[1].startsWith("(")) continue;
+    const target = normalizeUseTarget(match[1]);
+    if (target !== void 0) directories.push(target);
+  }
+}
+function normalizeUseTarget(raw) {
+  const commentAt = raw.indexOf("//");
+  const noComment = (commentAt === -1 ? raw : raw.slice(0, commentAt)).trim();
+  const unquoted = noComment.replaceAll(/^["']|["']$/g, "");
+  if (unquoted === "" || /\s/.test(unquoted)) return void 0;
+  return unquoted.replace(/^\.\//, "");
+}
+function detectCargoWorkspace(projectDirectory) {
+  const content = readFileSafe(nodePath3.join(projectDirectory, "Cargo.toml"));
+  return content === void 0 ? void 0 : readCargoWorkspaceMembers(content);
+}
+
+// src/utils/architecture-reconcile.ts
+function reconcileSections(input) {
+  const verdicts = input.nodeNames.map((node) => ({
+    node,
+    status: liveNodeStatus(input.priorStamps[node], input.fingerprint)
+  }));
+  const present = new Set(input.nodeNames);
+  for (const node of Object.keys(input.priorStamps)) {
+    if (!present.has(node)) verdicts.push({ node, status: "orphaned" });
+  }
+  return verdicts;
+}
+function liveNodeStatus(stamp, fingerprint) {
+  if (stamp === void 0) return "placeholder";
+  if (stamp !== fingerprint) return "stale";
+  return "current";
+}
+
+// src/utils/architecture-document.ts
+var WOULD_CHANGE_ACTIONS = /* @__PURE__ */ new Set(["created", "healed", "regenerated"]);
+function isWouldChangeAction(action) {
+  return WOULD_CHANGE_ACTIONS.has(action);
+}
+var FINGERPRINT_KEY = "fingerprint";
+var GENERATOR_KEY = "generator";
+var GENERATOR_VALUE = "safeword-architecture";
+function frontmatterBody(content) {
+  return /^---\r?\n([\s\S]*?)\r?\n---/.exec(content)?.[1];
+}
+function isSafewordOwned(content) {
+  return frontmatterBody(content)?.split(/\r?\n/).includes(`${GENERATOR_KEY}: ${GENERATOR_VALUE}`) ?? false;
+}
+function readDocumentFingerprint(content) {
+  const line = frontmatterBody(content)?.split(/\r?\n/).find((candidate) => candidate.startsWith(`${FINGERPRINT_KEY}:`));
+  if (line === void 0) return void 0;
+  const value = line.slice(FINGERPRINT_KEY.length + 1).trim();
+  return value.length > 0 ? value : void 0;
+}
+var RECONCILED_PREFIX = "<!-- reconciled:";
+function healTarget(target) {
+  const existing = readExisting(target.path);
+  const action = decideAction(existing, target.fingerprint, target.hasContent);
+  if (isWouldChangeAction(action)) {
+    mkdirSync(nodePath4.dirname(target.path), { recursive: true });
+    const priorStamps = existing === void 0 ? /* @__PURE__ */ new Map() : parseSectionStamps(existing);
+    const priorProse = existing === void 0 ? /* @__PURE__ */ new Map() : parseSectionProse(existing);
+    writeFileSync(target.path, target.render(priorStamps, priorProse));
+  }
+  return { action, path: target.path };
+}
+function planTarget(target) {
+  return decideAction(readExisting(target.path), target.fingerprint, target.hasContent);
+}
+function singleRepoTarget(projectDirectory) {
+  const fingerprint = shapeFingerprint(projectDirectory);
+  const nodes = extractSkeleton(projectDirectory).nodes;
+  return {
+    path: resolveGeneratedArchitecturePath(projectDirectory),
+    fingerprint,
+    hasContent: nodes.length > 0,
+    render: (priorStamps, priorProse) => renderDocument(nodes, fingerprint, priorStamps, priorProse)
+  };
+}
+function leafTarget(packageDirectory) {
+  const fingerprint = shapeFingerprint(packageDirectory);
+  const nodes = extractSkeleton(packageDirectory).nodes;
+  return {
+    path: nodePath4.join(packageDirectory, GENERATED_ARCHITECTURE_FILENAME),
+    fingerprint,
+    hasContent: nodes.length > 0,
+    render: (priorStamps, priorProse) => renderDocument(nodes, fingerprint, priorStamps, priorProse)
+  };
+}
+function rootIndexTarget(projectDirectory) {
+  const fingerprint = monorepoFingerprint(projectDirectory);
+  const model = extractMonorepoModel(projectDirectory);
+  return {
+    path: resolveGeneratedArchitecturePath(projectDirectory),
+    fingerprint,
+    hasContent: model.packages.length > 0,
+    render: () => renderRootIndex(model, fingerprint)
+  };
+}
+function projectTargets(projectDirectory) {
+  const leaves = discoverLeafDirectories(projectDirectory);
+  if (leaves.length === 0) return [singleRepoTarget(projectDirectory)];
+  return [rootIndexTarget(projectDirectory), ...leaves.map((leaf) => leafTarget(leaf))];
+}
+function selfHealProject(projectDirectory) {
+  return projectTargets(projectDirectory).map((target) => healTarget(target));
+}
+function planSelfHealProject(projectDirectory) {
+  return projectTargets(projectDirectory).map((target) => planTarget(target));
+}
+function readExisting(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function decideAction(existing, fingerprint, hasModules) {
+  if (existing === void 0) return hasModules ? "created" : "noop";
+  if (!isSafewordOwned(existing)) return "skipped";
+  const recorded = readDocumentFingerprint(existing);
+  if (recorded === void 0) return "regenerated";
+  if (recorded !== fingerprint) return "healed";
+  return "unchanged";
+}
+function parseSectionStamps(content) {
+  const stamps = /* @__PURE__ */ new Map();
+  const pattern = /^### (.+)\n+<!-- reconciled: (\S+) -->/gm;
+  for (const match of content.matchAll(pattern)) {
+    const name = match[1];
+    const stamp = match[2];
+    if (name !== void 0 && stamp !== void 0) stamps.set(name.trim(), stamp);
+  }
+  return stamps;
+}
+function parseSectionProse(content) {
+  const prose = /* @__PURE__ */ new Map();
+  let name;
+  let inProse = false;
+  let buffer = [];
+  const flush = (next) => {
+    if (name !== void 0) {
+      const text = buffer.join("\n").trim();
+      if (text.length > 0) prose.set(name, text);
+    }
+    name = next;
+    buffer = [];
+    inProse = false;
+  };
+  for (const line of content.split(/\r?\n/)) {
+    const heading = /^### (.+)$/.exec(line)?.[1];
+    if (heading !== void 0) {
+      flush(heading.trim());
+    } else if (line.startsWith("## ")) {
+      flush(void 0);
+    } else if (name !== void 0) {
+      inProse = accumulateProseLine(line, inProse, buffer);
+    }
+  }
+  flush(void 0);
+  return prose;
+}
+function accumulateProseLine(line, inProse, buffer) {
+  if (line.startsWith(RECONCILED_PREFIX) || line.startsWith("> \u26A0")) return inProse;
+  if (!inProse) return /^`[^`]*`\s*$/.test(line);
+  buffer.push(line);
+  return true;
+}
+function renderDocument(nodes, fingerprint, priorStamps, priorProse) {
+  const verdicts = reconcileSections({
+    priorStamps: Object.fromEntries(priorStamps),
+    nodeNames: nodes.map((node) => node.name),
+    fingerprint
+  });
+  const nodeByName = new Map(nodes.map((node) => [node.name, node]));
+  const sections = verdicts.map((verdict) => {
+    const node = nodeByName.get(verdict.node);
+    const stamp = priorStamps.get(verdict.node) ?? fingerprint;
+    const prose = priorProse.get(verdict.node) ?? node?.purpose ?? "";
+    return node === void 0 ? renderOrphanSection(verdict.node) : renderSection(node, stamp, verdict.status, prose);
+  }).join("\n");
+  return `---
+${GENERATOR_KEY}: ${GENERATOR_VALUE}
+${FINGERPRINT_KEY}: ${fingerprint}
+---
+
+# Architecture
+
+## Modules
+
+${sections}`;
+}
+function renderSection(node, stamp, status, prose) {
+  const marker = status === "stale" ? "\n> \u26A0 stale: structure changed since this section was reconciled.\n" : "";
+  return `### ${node.name}
+
+${RECONCILED_PREFIX} ${stamp} -->
+
+\`${node.path}\`
+
+${prose}
+${marker}`;
+}
+function renderOrphanSection(name) {
+  return `### ${name}
+
+> \u26A0 orphaned: this section describes a module that no longer exists.
+`;
+}
+function renderRootIndex(model, fingerprint) {
+  const sections = model.packages.map((node) => renderPackageSection(node, fingerprint)).join("\n");
+  const edgeLines = model.edges.map((edge) => `- \`${edge.from}\` \u2192 \`${edge.to}\``).join("\n");
+  const dependencies = model.edges.length === 0 ? "_No inter-package dependencies._\n" : `${edgeLines}
+`;
+  return `---
+${GENERATOR_KEY}: ${GENERATOR_VALUE}
+${FINGERPRINT_KEY}: ${fingerprint}
+---
+
+# Architecture
+
+## Packages
+
+${sections}
+## Dependencies
+
+${dependencies}`;
+}
+function renderPackageSection(node, stamp) {
+  const body = node.introspected ? node.purpose : "> \u26A0 not introspected \u2014 no recognized source layout";
+  return `### ${node.name}
+
+${RECONCILED_PREFIX} ${stamp} -->
+
+${body}
+`;
+}
+
+// src/commands/architecture.ts
+function architecture(cwd = process.cwd(), options = {}) {
+  if (options.check) {
+    return architectureCheck(cwd);
+  }
+  if (options.stage) {
+    return architectureStage(cwd);
+  }
+  const results = selfHealProject(cwd);
+  for (const result of results) {
+    success(`Architecture state document ${result.action}: ${result.path}`);
+  }
+  return Promise.resolve();
+}
+function architectureStage(cwd) {
+  if (!isArchitectureDocumentEnforcementEnabled(cwd)) {
+    success("Architecture doc enforcement is opted out (architectureDocEnforcement: false).");
+    return Promise.resolve();
+  }
+  const changed = selfHealProject(cwd).filter((result) => isWouldChangeAction(result.action));
+  if (changed.length === 0) {
+    success("Architecture docs need no change.");
+    return Promise.resolve();
+  }
+  for (const result of changed) {
+    stageDocument(cwd, result);
+    success(`Architecture doc ${result.action} and staged: ${result.path}`);
+  }
+  return Promise.resolve();
+}
+function stageDocument(cwd, result) {
+  try {
+    const relativePath = nodePath5.relative(cwd, result.path);
+    execFileSync("git", ["add", "--", relativePath], { cwd, stdio: "ignore" });
+  } catch {
+  }
+}
+function architectureCheck(cwd) {
+  if (!isArchitectureDocumentEnforcementEnabled(cwd)) {
+    success("Architecture doc enforcement is opted out (architectureDocEnforcement: false).");
+    return Promise.resolve();
+  }
+  const stale = planSelfHealProject(cwd).filter((action) => isWouldChangeAction(action));
+  if (stale.length > 0) {
+    error(
+      `Architecture docs are stale (${stale.join(", ")}). Run \`safeword architecture\` to regenerate, then commit the result.`
+    );
+    process.exit(1);
+  }
+  success("Architecture docs are current.");
+  return Promise.resolve();
+}
+export {
+  architecture
+};
+//# sourceMappingURL=architecture-3QIZFW3W.js.map