@oevery/rsp 4.0.0 → 4.1.0

package/dist/chunk-JO6NDJM4.mjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+import {
+  readCurrentDocument
+} from "./chunk-LGDCIQYL.mjs";
+import {
+  PKG_ROOT,
+  RSP_DIR,
+  getVersion,
+  inspectManagedDirectory,
+  inspectManagedFile,
+  inspectRspConfig,
+  markdownText,
+  parseMarkdown,
+  walkMarkdown
+} from "./chunk-P3KO3GZW.mjs";
+
+// src/architecture/model.ts
+import { createHash } from "crypto";
+import { realpath } from "fs/promises";
+import { isAbsolute, relative, resolve } from "path";
+
+// src/architecture/selection.ts
+function selectArchitecture(model, selection) {
+  const selected = new Set(model.nodes.map((node) => node.id));
+  if (selection.kind === "focus") {
+    if (!selected.has(selection.id))
+      throw new Error(`Unknown architecture node: ${selection.id}`);
+    selected.clear();
+    selected.add(selection.id);
+  }
+  if (selection.kind === "node") {
+    if (!selected.has(selection.id))
+      throw new Error(`Unknown architecture node: ${selection.id}`);
+    selected.clear();
+    selected.add(selection.id);
+    let added = true;
+    while (added) {
+      added = false;
+      for (const node of model.nodes) {
+        if (node.parent && selected.has(node.parent) && !selected.has(node.id)) {
+          selected.add(node.id);
+          added = true;
+        }
+      }
+    }
+  }
+  if (selection.kind === "view") {
+    const view = model.views.find((view2) => view2.id === selection.id);
+    if (!view)
+      throw new Error(`Unknown architecture view: ${selection.id}`);
+    selected.clear();
+    view.include.forEach((id) => selected.add(id));
+  }
+  const relations = model.relations.filter((edge) => selected.has(edge.source) || selected.has(edge.target));
+  const visible = /* @__PURE__ */ new Set([...selected, ...relations.flatMap((edge) => [edge.source, edge.target])]);
+  return { selected, visible, relations };
+}
+
+// src/architecture/model.ts
+var ARCHITECTURE_FILE = ".rsp/architecture.json";
+var MAX_CONTENT_BYTES = 16 * 1024 * 1024;
+var digest = (value) => createHash("sha256").update(value).digest("hex");
+function projectPath(file) {
+  if (!file || isAbsolute(file) || file.includes("\\") || file.split("/").some((part) => !part || part === "." || part === "..") || file.includes("\0"))
+    throw new Error(`Unsafe project-relative path: ${file}`);
+  if (file.split("/").some((part) => part === ".git" || part === "node_modules"))
+    throw new Error(`Private/runtime path is not readable: ${file}`);
+  return file;
+}
+async function readProjectFile(root, file) {
+  projectPath(file);
+  return (await readCurrentDocument(resolve(root, file), root, file, MAX_CONTENT_BYTES)).content;
+}
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Architecture entries must be objects");
+  return value;
+}
+function text(value, field) {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`Architecture ${field} must be a non-empty string`);
+  return value;
+}
+function strings(value, field) {
+  if (!Array.isArray(value))
+    throw new Error(`Architecture ${field} must be an array`);
+  return value.map((item) => text(item, field));
+}
+function collection(value, field) {
+  if (!Array.isArray(value))
+    throw new Error(`Architecture ${field} must be an array`);
+  return value.map(object);
+}
+function unique(items, field) {
+  if (new Set(items.map((item) => item.id)).size !== items.length)
+    throw new Error(`Duplicate architecture ${field} identity`);
+}
+function parseArchitecture(content) {
+  const value = object(JSON.parse(content));
+  if (value.schemaVersion !== 1)
+    throw new Error(`Unsupported architecture schemaVersion: ${String(value.schemaVersion)}`);
+  const nodes = collection(value.nodes, "nodes").map((node) => ({ id: text(node.id, "node.id"), title: text(node.title, "node.title"), description: text(node.description, "node.description"), ...node.parent === void 0 ? {} : { parent: text(node.parent, "node.parent") } }));
+  const relations = collection(value.relations, "relations").map((edge) => ({ id: text(edge.id, "relation.id"), source: text(edge.source, "relation.source"), target: text(edge.target, "relation.target"), type: text(edge.type, "relation.type"), description: text(edge.description, "relation.description") }));
+  const views = collection(value.views, "views").map((view) => ({ id: text(view.id, "view.id"), title: text(view.title, "view.title"), node: text(view.node, "view.node"), include: strings(view.include, "view.include") }));
+  const bindings = collection(value.bindings, "bindings").map((binding) => {
+    const file = projectPath(text(binding.file, "binding.file"));
+    if (!/\.md$/i.test(file))
+      throw new Error("Architecture bindings must reference Markdown files");
+    const scope = binding.scope ?? "node";
+    if (scope !== "node" && scope !== "subtree")
+      throw new Error("Architecture binding.scope must be node or subtree");
+    const headings = binding.headings === void 0 ? void 0 : strings(binding.headings, "binding.headings");
+    if (headings?.length === 0)
+      throw new Error("Omit headings for a whole-file binding");
+    return { node: text(binding.node, "binding.node"), file, ...headings ? { headings } : {}, scope };
+  });
+  unique(nodes, "node");
+  unique(relations, "relation");
+  unique(views, "view");
+  const ids = new Set(nodes.map((node) => node.id));
+  const requireNode = (id) => {
+    if (!ids.has(id))
+      throw new Error(`Missing architecture node: ${id}`);
+  };
+  for (const node of nodes) {
+    const visited = /* @__PURE__ */ new Set([node.id]);
+    let parent = node.parent;
+    while (parent !== void 0) {
+      requireNode(parent);
+      if (visited.has(parent))
+        throw new Error(`Architecture hierarchy cycle: ${parent}`);
+      visited.add(parent);
+      parent = nodes.find((node2) => node2.id === parent).parent;
+    }
+  }
+  relations.forEach((edge) => {
+    requireNode(edge.source);
+    requireNode(edge.target);
+  });
+  views.forEach((view) => {
+    requireNode(view.node);
+    view.include.forEach(requireNode);
+  });
+  bindings.forEach((binding) => requireNode(binding.node));
+  return { schemaVersion: 1, nodes, relations, views, bindings };
+}
+function documentHeadings(content) {
+  const result = [];
+  const stack = [];
+  const counts = /* @__PURE__ */ new Map();
+  const anchors = /* @__PURE__ */ new Set();
+  walkMarkdown(parseMarkdown(content).root, (node) => {
+    if (node.type !== "heading")
+      return;
+    const title = markdownText(node);
+    while (stack.length && stack.at(-1).depth >= node.depth) stack.pop();
+    stack.push({ title, depth: node.depth });
+    const base = title.toLowerCase().replace(/[^\p{L}\p{N}\s_-]/gu, "").replace(/\s/g, "-") || "section";
+    let count = counts.get(base) ?? 0;
+    let anchor = count ? `${base}-${count}` : base;
+    while (anchors.has(anchor)) anchor = `${base}-${++count}`;
+    counts.set(base, count + 1);
+    anchors.add(anchor);
+    result.push({ title, depth: node.depth, anchor, hierarchy: stack.map((item) => item.title) });
+  });
+  return result;
+}
+function resolveHeading(headings, hierarchy) {
+  const matches = headings.filter((heading) => hierarchy.length <= heading.hierarchy.length && hierarchy.every((title, i) => title === heading.hierarchy[heading.hierarchy.length - hierarchy.length + i]));
+  if (matches.length !== 1)
+    throw new Error(`${matches.length ? "Ambiguous" : "Missing"} chapter: ${hierarchy.join(" > ")}`);
+  return matches[0];
+}
+async function queryArchitecture(options = {}) {
+  if (options.node !== void 0 && !options.node.trim())
+    throw new Error("--node requires a non-empty ID");
+  if (options.view !== void 0 && !options.view.trim())
+    throw new Error("--view requires a non-empty ID");
+  if (options.node && options.view)
+    throw new Error("--node and --view are mutually exclusive");
+  const root = await realpath(resolve(options.root ?? process.cwd()));
+  const config = await inspectRspConfig(root);
+  if (config.issues.length)
+    throw new Error(config.issues.join("; "));
+  let content;
+  try {
+    content = await readProjectFile(root, ARCHITECTURE_FILE);
+  } catch (error) {
+    const { lstat } = await import("fs/promises");
+    try {
+      await lstat(resolve(root, ARCHITECTURE_FILE));
+    } catch (missing) {
+      if (missing.code === "ENOENT")
+        return { configured: false, source: { root, file: ARCHITECTURE_FILE, revision: "" }, selection: { kind: "full" }, nodes: [], relations: [], views: [], documents: [], diagnostics: [{ code: "not_configured", message: `Architecture is not configured: ${ARCHITECTURE_FILE}` }] };
+    }
+    throw error;
+  }
+  const model = parseArchitecture(content);
+  const selection = options.node ? { kind: "node", id: options.node } : options.view ? { kind: "view", id: options.view } : { kind: "full" };
+  const { selected, visible, relations } = selectArchitecture(model, selection);
+  const diagnostics = [];
+  const chapterMaps = /* @__PURE__ */ new Map();
+  const sourceInputs = [content, JSON.stringify(config.config)];
+  for (const file of new Set(model.bindings.map((binding) => binding.file))) {
+    try {
+      const body = await readProjectFile(root, file);
+      chapterMaps.set(file, documentHeadings(body));
+      sourceInputs.push(file, body);
+    } catch (error) {
+      diagnostics.push({ code: "document_unavailable", file, message: error.message });
+    }
+  }
+  const nodes = model.nodes.filter((node) => visible.has(node.id)).map((node) => {
+    const ancestors = /* @__PURE__ */ new Set();
+    let parent = node.parent;
+    while (parent) {
+      ancestors.add(parent);
+      parent = model.nodes.find((node2) => node2.id === parent)?.parent;
+    }
+    const bindings = model.bindings.filter((binding) => binding.node === node.id || binding.scope === "subtree" && ancestors.has(binding.node)).map((binding) => {
+      const reference = { ...binding, origin: binding.node, inherited: binding.node !== node.id };
+      if (!binding.headings || !chapterMaps.has(binding.file))
+        return reference;
+      try {
+        return { ...reference, anchor: resolveHeading(chapterMaps.get(binding.file), binding.headings).anchor };
+      } catch (error) {
+        diagnostics.push({ code: "chapter_unresolved", file: binding.file, message: error.message });
+        return reference;
+      }
+    });
+    return { ...node, boundary: !selected.has(node.id), bindings };
+  });
+  return { configured: true, source: { root, file: ARCHITECTURE_FILE, revision: digest(sourceInputs.join("\0")) }, selection, nodes, relations, views: model.views.filter((view) => selection.kind === "full" || view.id === options.view || selected.has(view.node)), documents: [...new Set(nodes.flatMap((node) => node.bindings.map((binding) => binding.file)))], diagnostics };
+}
+function isWithin(root, target) {
+  const path = relative(root, target);
+  return path !== ".." && !path.startsWith("../") && !isAbsolute(path);
+}
+
+// src/core/project-version.ts
+import { readFile, realpath as realpath2 } from "fs/promises";
+import { join } from "path";
+var PROJECT_VERSION_PATH = ".rsp/version";
+var PROJECT_SOURCE_PATH = ".rsp/source";
+var SOURCE_INVOCATION = "mise exec -- node dist/cli.mjs";
+function isExactVersion(value) {
+  return /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[a-z-][\da-z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-z-][\da-z-]*))*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?$/i.test(value);
+}
+function exactInvocation(version) {
+  if (!isExactVersion(version))
+    throw new Error(`Invalid exact RSP version: ${version}`);
+  return `npx -y @oevery/rsp@${version}`;
+}
+async function readProjectVersion(projectRoot = ".") {
+  const directory = inspectManagedDirectory(join(projectRoot, RSP_DIR), "RSP root", { allowMissing: true });
+  if (directory.issue)
+    throw directory.issue;
+  if (!directory.exists)
+    return null;
+  const path = join(projectRoot, PROJECT_VERSION_PATH);
+  const inspection = inspectManagedFile(path, "project CLI version", { allowMissing: true });
+  if (inspection.issue)
+    throw inspection.issue;
+  if (!inspection.exists)
+    return null;
+  const version = (await readFile(path, "utf8")).trim();
+  if (!isExactVersion(version))
+    throw new Error(`${PROJECT_VERSION_PATH} must contain one exact package version, not a tag or range`);
+  return version;
+}
+async function readProjectRuntime(projectRoot = ".") {
+  const version = await readProjectVersion(projectRoot);
+  const source = inspectManagedFile(join(projectRoot, PROJECT_SOURCE_PATH), "project source selection", { allowMissing: true });
+  if (source.issue)
+    throw source.issue;
+  if (!source.exists)
+    return { mode: "package", version };
+  if (version !== null)
+    throw new Error(`${PROJECT_SOURCE_PATH} and ${PROJECT_VERSION_PATH} are mutually exclusive; explicitly select one runtime.`);
+  if ((await readFile(join(projectRoot, PROJECT_SOURCE_PATH), "utf8")).trim() !== ".")
+    throw new Error(`${PROJECT_SOURCE_PATH} must contain . to select this RSP source checkout.`);
+  if (await realpath2(projectRoot) !== await realpath2(PKG_ROOT))
+    throw new Error(`Source mode requires this checkout's local CLI. Build here, then use ${SOURCE_INVOCATION} <command>; a registry package or another checkout cannot substitute.`);
+  const sourceDirectory = inspectManagedDirectory(join(projectRoot, "src"), "RSP source directory");
+  const sourceEntry = inspectManagedFile(join(projectRoot, "src/cli.ts"), "RSP source entry");
+  if (sourceDirectory.issue || sourceEntry.issue)
+    throw sourceDirectory.issue ?? sourceEntry.issue;
+  return { mode: "source" };
+}
+async function selectProjectRuntime(operation = "ordinary") {
+  const version = await getVersion();
+  exactInvocation(version);
+  const selected = await readProjectRuntime();
+  if (selected.mode === "source")
+    return { mode: "source", version };
+  if (selected.version && selected.version !== version && operation !== "update") {
+    throw new Error(`Project pins RSP ${selected.version}; running CLI is ${version}. Use ${exactInvocation(selected.version)} <command>. To migrate deliberately, inspect the target version and run ${exactInvocation(version)} update.`);
+  }
+  if (selected.version && operation === "update" && compareVersions(version, selected.version) < 0)
+    throw new Error(`Downgrading RSP from ${selected.version} to ${version} is unsupported. Use ${exactInvocation(selected.version)} <command>.`);
+  return { mode: "package", version };
+}
+function compareVersions(left, right) {
+  const parts = (value) => {
+    const [core, ...pre] = value.split("+", 1)[0].split("-");
+    return { core: core.split(".").map(BigInt), pre: pre.length ? pre.join("-").split(".") : [] };
+  };
+  const a = parts(left);
+  const b = parts(right);
+  for (let i = 0; i < 3; i++) {
+    if (a.core[i] !== b.core[i])
+      return a.core[i] > b.core[i] ? 1 : -1;
+  }
+  if (!a.pre.length || !b.pre.length)
+    return Number(!a.pre.length) - Number(!b.pre.length);
+  for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i++) {
+    const x = a.pre[i];
+    const y = b.pre[i];
+    if (x === y)
+      continue;
+    if (x === void 0 || y === void 0)
+      return x === void 0 ? -1 : 1;
+    const nx = /^\d+$/.test(x);
+    const ny = /^\d+$/.test(y);
+    if (nx && ny)
+      return BigInt(x) > BigInt(y) ? 1 : -1;
+    if (nx !== ny)
+      return nx ? -1 : 1;
+    return x > y ? 1 : -1;
+  }
+  return 0;
+}
+async function guardProjectVersion(rawArgs) {
+  if (rawArgs.some((arg) => ["--help", "-h"].includes(arg)) || rawArgs.length === 1 && ["--version", "-v"].includes(rawArgs[0]))
+    return;
+  if (["doctor", "config", "update"].includes(rawArgs[0] ?? ""))
+    return;
+  await selectProjectRuntime();
+}
+
+export {
+  selectArchitecture,
+  ARCHITECTURE_FILE,
+  MAX_CONTENT_BYTES,
+  digest,
+  projectPath,
+  readProjectFile,
+  documentHeadings,
+  queryArchitecture,
+  isWithin,
+  PROJECT_VERSION_PATH,
+  SOURCE_INVOCATION,
+  isExactVersion,
+  exactInvocation,
+  readProjectVersion,
+  readProjectRuntime,
+  selectProjectRuntime,
+  compareVersions,
+  guardProjectVersion
+};