codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/conformity-gate.js

@@ -0,0 +1,132 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var conformity_gate_exports = {};
+__export(conformity_gate_exports, {
+  checkChanges: () => checkChanges,
+  cleanChanged: () => cleanChanged
+});
+module.exports = __toCommonJS(conformity_gate_exports);
+var import_node_child_process = require("node:child_process");
+var import_breakpoint_service = require("./breakpoint-service");
+var import_grounding = require("./tests/grounding");
+var import_plan_service = require("./plan-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_criteria_service = require("./criteria-service");
+var import_system_docs_service = require("./system-docs-service");
+var import_rule_changes = require("./rule-changes");
+var import_check_words = require("../../shared/lib/check-words");
+const MAX_FILES = 500;
+function cleanChanged(paths) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of paths) {
+    const p = raw.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
+    if (!p || p.startsWith("/") || p.split("/").includes("..")) continue;
+    out.add(p);
+  }
+  return [...out].slice(0, MAX_FILES);
+}
+function changedSince(root, commit) {
+  try {
+    const out = (0, import_node_child_process.execFileSync)("git", ["-C", root, "diff", "--name-only", commit, "--"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return new Set(out.split("\n").map((s) => s.trim()).filter(Boolean));
+  } catch {
+    return null;
+  }
+}
+async function checkChanges(root, changed, checkCriterion, checkRules, rulebook = [], notes = [], strict = false, scoped = false, ratchet = []) {
+  const files = cleanChanged(changed);
+  const says = [];
+  const said = [...notes];
+  for (const c of rulebook) (c.effect === "loosens" && !c.approval?.ok ? says : said).push((0, import_rule_changes.changeWords)(c));
+  const breakpoints = [];
+  const code = scoped ? [] : (0, import_breakpoint_service.listBreakpoints)().filter((b) => b.kind === "code" && b.projectRoot === root);
+  for (const f of files) {
+    for (const b of code) {
+      if (!(0, import_breakpoint_service.codeCovers)(b.target, f)) continue;
+      breakpoints.push({ path: f, breakpoint: b.id, note: b.note, by: b.createdBy });
+      says.push(`\u25A0 ${f}: ${b.createdBy} set a breakpoint on ${b.target === f ? "it" : b.target}${b.note ? ` (\u201C${b.note}\u201D)` : ""}; ask them before changing it`);
+    }
+  }
+  const found = files.length && checkRules ? await checkRules(files) : [];
+  const rules = found ?? [];
+  for (const r of rules) {
+    const line = (0, import_check_words.findingLine)(r);
+    if (r.strength === "block" || strict) says.push(`\u2717 ${line}`);
+    else said.push(`\u26A0 ${line} (the rule warns; it does not fail the check)`);
+  }
+  const said1 = new Set(rules.map((r) => `${r.path}>${r.imports}`));
+  for (const f of ratchet) {
+    if (f.kind === "breach" && said1.has(`${f.from}>${f.to}`)) continue;
+    if (f.kind === "fell" || f.kind === "breach" && f.strength === "warn" && !strict) said.push(f.words);
+    else says.push(f.words);
+  }
+  const tests = [];
+  for (const f of scoped ? [] : files) {
+    let g;
+    try {
+      g = (0, import_grounding.groundingOf)(root, f);
+    } catch {
+      continue;
+    }
+    if (g.state === "failing" || g.state === "stale") {
+      tests.push({ path: f, state: g.state, says: g.words });
+      says.push(`${f}: ${g.words}`);
+    }
+  }
+  const criteria = [];
+  for (const plan of scoped ? [] : (0, import_plan_service.listPlans)(root)) {
+    if (plan.status === "archived") continue;
+    for (const item of (0, import_plan_item_service.listItemSummaries)(plan.uid)) {
+      if (item.status !== "done") continue;
+      for (const c of (0, import_criteria_service.listCriteria)(item.uid)) {
+        const r = await checkCriterion(c.uid).catch(() => null);
+        if (!r || r.ok) continue;
+        const findings = r.findings.filter((x) => x.status === "fail").map((x) => x.message);
+        criteria.push({ itemUid: item.uid, task: item.title, criterion: c.text, findings });
+        says.push(`\u2717 "${item.title}" is marked done, but its criterion "${c.text}" fails${findings.length ? `: ${findings.join("; ")}` : ""}`);
+      }
+    }
+  }
+  const docs = [];
+  const seen = /* @__PURE__ */ new Map();
+  const diffs = /* @__PURE__ */ new Map();
+  for (const f of scoped ? [] : files) {
+    for (const ref of (0, import_system_docs_service.findDocsByReferencedFile)(root, f)) {
+      const doc = (0, import_system_docs_service.getSystemDoc)(ref.uid);
+      if (!doc?.capturedAgainstCommit || !(doc.references.files ?? []).some((x) => x.replace(/^\.\/+/, "") === f)) continue;
+      const stamp = doc.capturedAgainstCommit;
+      if (!diffs.has(stamp)) diffs.set(stamp, changedSince(root, stamp));
+      if (!diffs.get(stamp)?.has(f)) continue;
+      const at = seen.get(doc.uid);
+      if (at) {
+        at.files.push(f);
+        continue;
+      }
+      const entry = { uid: doc.uid, title: doc.title, slug: doc.slug, verifiedAt: stamp.slice(0, 7), files: [f] };
+      seen.set(doc.uid, entry);
+      docs.push(entry);
+    }
+  }
+  for (const d of docs) says.push(`\u26A0 The system doc "${d.title}" describes ${d.files.join(", ")}, which changed after it was verified at ${d.verifiedAt}`);
+  return { ok: says.length === 0, says, files, breakpoints, tests, criteria, docs, rules, rulesChecked: found !== null, rulebook: [...rulebook], notes: said, ratchet: ratchet.map(({ strength: _s, ...f }) => f) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkChanges,
+  cleanChanged
+});

package/src/backend/services/contribution-service.js

@@ -0,0 +1,409 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var contribution_service_exports = {};
+__export(contribution_service_exports, {
+  acceptContributions: () => acceptContributions,
+  listContributions: () => listContributions,
+  listContributionsForBranch: () => listContributionsForBranch,
+  prepareContributorBranch: () => prepareContributorBranch,
+  promoteAttachmentToContribution: () => promoteAttachmentToContribution,
+  promoteItemToContribution: () => promoteItemToContribution
+});
+module.exports = __toCommonJS(contribution_service_exports);
+var import_node_child_process = require("node:child_process");
+var import_confined_fs = require("./confined-fs");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_yaml = require("yaml");
+var import_plans_home = require("./plans-home");
+function assertSafeBranchSegment(branch) {
+  if (typeof branch !== "string" || branch.length === 0 || branch.length > 255) {
+    throw new import_confined_fs.ConfinementError("Invalid branch name for a contributions directory");
+  }
+  if (branch.split(/[\\/]/).some((seg) => seg === ".." || seg === "." || seg === "")) {
+    throw new import_confined_fs.ConfinementError(
+      `Branch name "${branch}" contains a path segment that cannot be used as a directory`
+    );
+  }
+  if (import_node_path.default.isAbsolute(branch)) {
+    throw new import_confined_fs.ConfinementError(`Branch name "${branch}" looks like an absolute path`);
+  }
+  return branch;
+}
+function promoteItemToContribution(projectRoot, itemData) {
+  const branch = getCurrentBranch(projectRoot);
+  const contribDir = import_node_path.default.join(projectRoot, ".codetrellis", "contributions", assertSafeBranchSegment(branch), "items");
+  import_node_fs.default.mkdirSync(contribDir, { recursive: true });
+  removeOldPromotionFile(contribDir, itemData.uid);
+  const slug = slugify(itemData.title);
+  const fileName = `${slug}.yaml`;
+  const filePath = import_node_path.default.join(contribDir, fileName);
+  const relPath = import_node_path.default.relative(projectRoot, filePath);
+  const yamlContent = (0, import_yaml.stringify)({
+    uid: itemData.uid,
+    title: itemData.title,
+    kind: itemData.kind,
+    status: itemData.status ?? "pending",
+    body: itemData.body ?? null,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...itemData.attachments?.length ? { attachments: itemData.attachments } : {}
+  });
+  import_node_fs.default.writeFileSync(filePath, yamlContent, "utf-8");
+  updateContributionIndex(projectRoot, branch, {
+    uid: itemData.uid,
+    branch,
+    kind: "item",
+    title: itemData.title,
+    description: itemData.description,
+    filePath: relPath,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    uid: itemData.uid,
+    branch,
+    kind: "item",
+    title: itemData.title,
+    description: itemData.description,
+    filePath: relPath,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function promoteAttachmentToContribution(projectRoot, attachmentData) {
+  const branch = getCurrentBranch(projectRoot);
+  const contribDir = import_node_path.default.join(projectRoot, ".codetrellis", "contributions", assertSafeBranchSegment(branch), "attachments");
+  import_node_fs.default.mkdirSync(contribDir, { recursive: true });
+  const ext = import_node_path.default.extname(attachmentData.sourcePath) || ".bin";
+  const destName = `${attachmentData.uid}${ext}`;
+  const destPath = import_node_path.default.join(contribDir, destName);
+  const relPath = import_node_path.default.relative(projectRoot, destPath);
+  if (import_node_fs.default.existsSync(attachmentData.sourcePath)) {
+    import_node_fs.default.copyFileSync(attachmentData.sourcePath, destPath);
+  }
+  const metaPath = import_node_path.default.join(contribDir, `${attachmentData.uid}.meta.yaml`);
+  import_node_fs.default.writeFileSync(metaPath, (0, import_yaml.stringify)({
+    uid: attachmentData.uid,
+    label: attachmentData.label,
+    contentType: attachmentData.contentType ?? "application/octet-stream",
+    fileName: destName,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }), "utf-8");
+  updateContributionIndex(projectRoot, branch, {
+    uid: attachmentData.uid,
+    branch,
+    kind: "attachment",
+    title: attachmentData.label,
+    description: attachmentData.description,
+    filePath: relPath,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    uid: attachmentData.uid,
+    branch,
+    kind: "attachment",
+    title: attachmentData.label,
+    description: attachmentData.description,
+    filePath: relPath,
+    promotedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function listContributions(projectRoot) {
+  const branch = getCurrentBranch(projectRoot);
+  return listContributionsForBranch(projectRoot, branch);
+}
+function listContributionsForBranch(projectRoot, branch) {
+  const indexPath = import_node_path.default.join(projectRoot, ".codetrellis", "contributions", branch, "index.json");
+  if (!import_node_fs.default.existsSync(indexPath)) {
+    return { branch, total: 0, items: [] };
+  }
+  try {
+    const raw = import_node_fs.default.readFileSync(indexPath, "utf-8");
+    const items = JSON.parse(raw);
+    return { branch, total: items.length, items };
+  } catch {
+    return { branch, total: 0, items: [] };
+  }
+}
+function acceptContributions(projectRoot, branch, planSlug) {
+  projectRoot = (0, import_plans_home.plansHome)(projectRoot) ?? projectRoot;
+  const contribDir = import_node_path.default.join(
+    projectRoot,
+    ".codetrellis",
+    "contributions",
+    assertSafeBranchSegment(branch)
+  );
+  const planItemsDir = import_node_path.default.join(projectRoot, ".codetrellis", "plans", planSlug, "items");
+  const errors = [];
+  let accepted = 0;
+  if (!import_node_fs.default.existsSync(contribDir)) {
+    return { accepted: 0, planSlug, errors: ["No contributions found for this branch"] };
+  }
+  import_node_fs.default.mkdirSync(planItemsDir, { recursive: true });
+  const itemsDir = import_node_path.default.join(contribDir, "items");
+  if (import_node_fs.default.existsSync(itemsDir)) {
+    const files = import_node_fs.default.readdirSync(itemsDir).filter((f) => f.endsWith(".yaml"));
+    const existingCount = import_node_fs.default.readdirSync(planItemsDir).filter((f) => f.endsWith(".yaml")).length;
+    for (let i = 0; i < files.length; i++) {
+      try {
+        const src = import_node_path.default.join(itemsDir, files[i]);
+        const content = import_node_fs.default.readFileSync(src, "utf-8");
+        const parsed = (0, import_yaml.parse)(content);
+        delete parsed.promotedAt;
+        const sortNum = String(existingCount + i + 1).padStart(3, "0");
+        const slug = slugify(parsed.title ?? files[i].replace(".yaml", ""));
+        const destName = `${sortNum}-${slug}.yaml`;
+        const destPath = import_node_path.default.join(planItemsDir, destName);
+        import_node_fs.default.writeFileSync(destPath, (0, import_yaml.stringify)(parsed), "utf-8");
+        accepted++;
+      } catch (err) {
+        errors.push(`Failed to accept ${files[i]}: ${err}`);
+      }
+    }
+  }
+  const attDir = import_node_path.default.join(contribDir, "attachments");
+  if (import_node_fs.default.existsSync(attDir)) {
+    const planAttDir = import_node_path.default.join(projectRoot, ".codetrellis", "attachments");
+    import_node_fs.default.mkdirSync(planAttDir, { recursive: true });
+    const files = import_node_fs.default.readdirSync(attDir).filter((f) => !f.endsWith(".meta.yaml"));
+    for (const file of files) {
+      try {
+        const src = import_node_path.default.join(attDir, file);
+        const dest = import_node_path.default.join(planAttDir, file);
+        import_node_fs.default.copyFileSync(src, dest);
+        accepted++;
+      } catch (err) {
+        errors.push(`Failed to accept attachment ${file}: ${err}`);
+      }
+    }
+  }
+  try {
+    (0, import_confined_fs.removeWithin)(
+      import_node_path.default.join(projectRoot, ".codetrellis", "contributions"),
+      contribDir,
+      { recursive: true },
+      "contributions cleanup"
+    );
+  } catch (err) {
+    if (!(err instanceof import_confined_fs.ConfinementError)) {
+      const e = err;
+      if (e.code !== "ENOENT") throw err;
+    } else {
+      throw err;
+    }
+  }
+  return { accepted, planSlug, errors };
+}
+function prepareContributorBranch(projectRoot, planSlug, branchName, options) {
+  projectRoot = (0, import_plans_home.plansHome)(projectRoot) ?? projectRoot;
+  const planDir = import_node_path.default.join(projectRoot, ".codetrellis", "plans", planSlug);
+  if (!import_node_fs.default.existsSync(planDir)) {
+    throw new Error(`Plan directory not found: ${planDir}`);
+  }
+  const planYamlPath = import_node_path.default.join(planDir, "plan.yaml");
+  if (!import_node_fs.default.existsSync(planYamlPath)) {
+    throw new Error(`plan.yaml not found for ${planSlug}`);
+  }
+  const dirty = runGitArgs(
+    ["status", "--porcelain", "--", ".codetrellis/"],
+    projectRoot
+  ).trim();
+  if (dirty) {
+    const files = dirty.split("\n").slice(0, 5).map((l) => l.slice(3)).join(", ");
+    throw new Error(
+      `Uncommitted changes under .codetrellis/ would be committed onto the contributor branch and disappear from this one. Commit or stash them first: ${files}` + (dirty.split("\n").length > 5 ? " \u2026" : "")
+    );
+  }
+  const planYaml = import_node_fs.default.readFileSync(planYamlPath, "utf-8");
+  const planMeta = (0, import_yaml.parse)(planYaml);
+  const itemsDir = import_node_path.default.join(planDir, "items");
+  const items = readItemsRecursive(itemsDir);
+  const filteredItems = items.filter((item) => {
+    if (options?.includeItems?.length) {
+      return options.includeItems.includes(item.uid);
+    }
+    return (item.visibility ?? "shared") === "shared";
+  });
+  const cleanedItems = filteredItems.map((item) => stripPrivateContent(item));
+  runGitArgs(["checkout", "-b", branchName], projectRoot);
+  try {
+    const branchPlanDir = import_node_path.default.join(projectRoot, ".codetrellis", "plans", planSlug);
+    const branchItemsDir = import_node_path.default.join(branchPlanDir, "items");
+    if (import_node_fs.default.existsSync(branchItemsDir)) {
+      import_node_fs.default.rmSync(branchItemsDir, { recursive: true, force: true });
+    }
+    import_node_fs.default.mkdirSync(branchItemsDir, { recursive: true });
+    const cleanPlan = { ...planMeta };
+    delete cleanPlan.internalNotes;
+    import_node_fs.default.writeFileSync(planYamlPath, (0, import_yaml.stringify)(cleanPlan), "utf-8");
+    for (let i = 0; i < cleanedItems.length; i++) {
+      const item = cleanedItems[i];
+      const sortNum = String(i + 1).padStart(3, "0");
+      const slug = slugify(item.title ?? "item");
+      const fileName = `${sortNum}-${slug}.yaml`;
+      import_node_fs.default.writeFileSync(
+        import_node_path.default.join(branchItemsDir, fileName),
+        (0, import_yaml.stringify)(item),
+        "utf-8"
+      );
+    }
+    const contribDir = import_node_path.default.join(projectRoot, ".codetrellis", "contributions");
+    if (import_node_fs.default.existsSync(contribDir)) {
+      import_node_fs.default.rmSync(contribDir, { recursive: true, force: true });
+    }
+    runGitArgs(["add", ".codetrellis/"], projectRoot);
+    const message = `[cdev] prepare contributor branch: ${planSlug}
+
+Filtered to ${cleanedItems.length} shared items for external collaboration.`;
+    runGitArgs(["commit", "-m", message, "--allow-empty", "--", ".codetrellis/"], projectRoot);
+    const sha = runGitArgs(["rev-parse", "HEAD"], projectRoot).trim();
+    runGitArgs(["checkout", "-"], projectRoot);
+    return {
+      branch: branchName,
+      planSlug,
+      itemCount: cleanedItems.length,
+      commitHash: sha
+    };
+  } catch (err) {
+    try {
+      runGitArgs(["checkout", "-"], projectRoot);
+      runGitArgs(["branch", "-D", branchName], projectRoot);
+    } catch {
+    }
+    throw err;
+  }
+}
+function getCurrentBranch(projectRoot) {
+  try {
+    return runGitArgs(["rev-parse", "--abbrev-ref", "HEAD"], projectRoot).trim();
+  } catch {
+    return "detached";
+  }
+}
+function runGitArgs(args, cwd) {
+  return (0, import_node_child_process.execFileSync)("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 15e3
+  });
+}
+function removeOldPromotionFile(contribDir, uid) {
+  if (!import_node_fs.default.existsSync(contribDir)) return;
+  const files = import_node_fs.default.readdirSync(contribDir).filter((f) => f.endsWith(".yaml"));
+  for (const file of files) {
+    try {
+      const content = import_node_fs.default.readFileSync(import_node_path.default.join(contribDir, file), "utf-8");
+      if (content.includes(`uid: ${uid}`) || content.includes(`uid: "${uid}"`)) {
+        import_node_fs.default.unlinkSync(import_node_path.default.join(contribDir, file));
+        return;
+      }
+    } catch {
+    }
+  }
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function updateContributionIndex(projectRoot, branch, contribution) {
+  const indexPath = import_node_path.default.join(projectRoot, ".codetrellis", "contributions", branch, "index.json");
+  let items = [];
+  if (import_node_fs.default.existsSync(indexPath)) {
+    try {
+      items = JSON.parse(import_node_fs.default.readFileSync(indexPath, "utf-8"));
+    } catch {
+    }
+  }
+  const idx = items.findIndex((i) => i.uid === contribution.uid);
+  if (idx >= 0) {
+    items[idx] = contribution;
+  } else {
+    items.push(contribution);
+  }
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(indexPath), { recursive: true });
+  import_node_fs.default.writeFileSync(indexPath, JSON.stringify(items, null, 2), "utf-8");
+}
+function readItemsRecursive(dir) {
+  const items = [];
+  if (!import_node_fs.default.existsSync(dir)) return items;
+  const entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = import_node_path.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const selfPath = import_node_path.default.join(fullPath, "_self.yaml");
+      if (import_node_fs.default.existsSync(selfPath)) {
+        try {
+          const parsed = (0, import_yaml.parse)(import_node_fs.default.readFileSync(selfPath, "utf-8"));
+          if (parsed) items.push(parsed);
+        } catch {
+        }
+      }
+      items.push(...readItemsRecursive(fullPath));
+    } else if (entry.name.endsWith(".yaml") && entry.name !== "_self.yaml") {
+      try {
+        const parsed = (0, import_yaml.parse)(import_node_fs.default.readFileSync(fullPath, "utf-8"));
+        if (parsed) items.push(parsed);
+      } catch {
+      }
+    }
+  }
+  return items;
+}
+function stripPrivateContent(item) {
+  const cleaned = { ...item };
+  delete cleaned.visibility;
+  delete cleaned.visibility_override;
+  delete cleaned.overrideParentVisibility;
+  if (Array.isArray(cleaned.attachments)) {
+    cleaned.attachments = cleaned.attachments.filter(
+      (att) => {
+        const value = att.value;
+        return !value?.startsWith("userdata://");
+      }
+    );
+    if (cleaned.attachments.length === 0) {
+      delete cleaned.attachments;
+    }
+  }
+  if (Array.isArray(cleaned.comments)) {
+    cleaned.comments = cleaned.comments.filter(
+      (c) => (c.visibility ?? "shared") === "shared"
+    );
+    if (cleaned.comments.length === 0) {
+      delete cleaned.comments;
+    }
+  }
+  return cleaned;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  acceptContributions,
+  listContributions,
+  listContributionsForBranch,
+  prepareContributorBranch,
+  promoteAttachmentToContribution,
+  promoteItemToContribution
+});