@unbrained/pm-cli 2026.5.29 → 2026.5.31

package/dist/cli-bundle/chunks/chunk-BUPWJ3IJ.js

@@ -0,0 +1,950 @@
+import {
+  acquireLock
+} from "./chunk-4AEZR5EJ.js";
+import {
+  normalizeItemId,
+  normalizeRawItemId
+} from "./chunk-CEFIVZPG.js";
+import {
+  canonicalDocument,
+  parseItemDocument,
+  serializeItemDocument
+} from "./chunk-MD7K4JYF.js";
+import {
+  resolveItemTypeRegistry
+} from "./chunk-WDPXDQFG.js";
+import {
+  nowIso
+} from "./chunk-PVNQLCIS.js";
+import {
+  EMPTY_CANONICAL_DOCUMENT,
+  EXIT_CODE,
+  FRONT_MATTER_KEY_ORDER,
+  ITEM_FILE_EXTENSIONS,
+  PmCliError,
+  TYPE_TO_FOLDER,
+  appendLineAtomic,
+  ensureDir,
+  getActiveExtensionRegistrations,
+  getHistoryPath,
+  getItemFormatFromPath,
+  getItemPath,
+  hasActiveOnReadHooks,
+  orderObject,
+  pathExists,
+  resolveGovernanceKnobs,
+  runActiveOnReadHooks,
+  runActiveOnWriteHooks,
+  runActiveServiceOverride,
+  sha256Hex,
+  stableStringify,
+  writeFileAtomic
+} from "./chunk-LSXGH6NE.js";
+
+// dist/core/item/item-record.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "104fe68e-6cf6-52c7-86ab-063e6535ac0e");
+  } catch (e2) {
+  }
+})();
+function toItemRecord(item) {
+  return item;
+}
+
+// dist/core/history/history.js
+import jsonPatch from "fast-json-patch";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "9a356560-3dec-5529-a2b5-1b4224116c14");
+  } catch (e2) {
+  }
+})();
+var EMPTY_LEGACY_HASH_DOCUMENT = {
+  front_matter: {},
+  body: ""
+};
+function decodeJsonPointer(path4) {
+  if (!path4 || path4 === "/") {
+    return [];
+  }
+  if (!path4.startsWith("/")) {
+    return [];
+  }
+  return path4.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+function isDefinedPointerPath(document, path4) {
+  const segments = decodeJsonPointer(path4);
+  if (segments.length === 0) {
+    return true;
+  }
+  let cursor = document;
+  for (const segment of segments) {
+    if (Array.isArray(cursor)) {
+      if (segment === "-" || !/^(0|[1-9]\d*)$/.test(segment)) {
+        return false;
+      }
+      const index = Number(segment);
+      if (!Number.isInteger(index) || index < 0 || index >= cursor.length) {
+        return false;
+      }
+      const next2 = cursor[index];
+      if (next2 === void 0) {
+        return false;
+      }
+      cursor = next2;
+      continue;
+    }
+    if (typeof cursor !== "object" || cursor === null) {
+      return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(cursor, segment)) {
+      return false;
+    }
+    const next = cursor[segment];
+    if (next === void 0) {
+      return false;
+    }
+    cursor = next;
+  }
+  return true;
+}
+function normalizeHistoryPatchOps(beforeDocument, patch) {
+  const normalized = [];
+  let replayCursor = structuredClone(beforeDocument);
+  for (const operation of patch) {
+    const normalizedOperation = operation.op === "replace" && !isDefinedPointerPath(replayCursor, operation.path) ? { ...operation, op: "add" } : operation;
+    normalized.push(normalizedOperation);
+    replayCursor = jsonPatch.applyPatch(replayCursor, [normalizedOperation], true, true).newDocument;
+  }
+  return normalized;
+}
+function canonicalHashDocument(document) {
+  const hasMetadata = document.metadata && Object.keys(document.metadata).length > 0;
+  if (!hasMetadata) {
+    return {
+      front_matter: {},
+      body: document.body ?? ""
+    };
+  }
+  const canonical = canonicalDocument(document);
+  const orderedFrontMatter = orderObject(toItemRecord(canonical.metadata), FRONT_MATTER_KEY_ORDER);
+  return {
+    front_matter: orderedFrontMatter,
+    body: canonical.body
+  };
+}
+function canonicalPatchDocument(document) {
+  const hasMetadata = document.metadata && Object.keys(document.metadata).length > 0;
+  if (!hasMetadata) {
+    return {
+      metadata: {},
+      body: document.body ?? ""
+    };
+  }
+  const canonical = canonicalDocument(document);
+  const orderedMetadata = orderObject(toItemRecord(canonical.metadata), FRONT_MATTER_KEY_ORDER);
+  return {
+    metadata: orderedMetadata,
+    body: canonical.body
+  };
+}
+function hashDocument(document) {
+  return sha256Hex(stableStringify(canonicalHashDocument(document)));
+}
+function hashEmptyDocument() {
+  return sha256Hex(stableStringify(EMPTY_LEGACY_HASH_DOCUMENT));
+}
+function createHistoryEntry(params) {
+  const beforeHashCanonical = canonicalHashDocument(params.before);
+  const afterHashCanonical = canonicalHashDocument(params.after);
+  const beforePatchCanonical = canonicalPatchDocument(params.before);
+  const afterPatchCanonical = canonicalPatchDocument(params.after);
+  const rawPatch = jsonPatch.compare(beforePatchCanonical, afterPatchCanonical);
+  const patch = normalizeHistoryPatchOps(beforePatchCanonical, rawPatch);
+  return {
+    ts: params.nowIso,
+    author: params.author,
+    op: params.op,
+    patch,
+    before_hash: sha256Hex(stableStringify(beforeHashCanonical)),
+    after_hash: sha256Hex(stableStringify(afterHashCanonical)),
+    message: params.message === void 0 ? void 0 : params.message
+  };
+}
+async function appendHistoryEntry(historyPath, entry) {
+  const override = await runActiveServiceOverride("history_append", {
+    history_path: historyPath,
+    entry
+  });
+  if (override.handled) {
+    if (override.result === false) {
+      return;
+    }
+    if (typeof override.result === "string") {
+      await appendLineAtomic(historyPath, override.result);
+      return;
+    }
+    if (typeof override.result === "object" && override.result !== null) {
+      const record = override.result;
+      if (record.skip === true) {
+        return;
+      }
+      const nextHistoryPath = typeof record.history_path === "string" ? record.history_path : historyPath;
+      if (typeof record.line === "string") {
+        await appendLineAtomic(nextHistoryPath, record.line);
+        return;
+      }
+      const nextEntry = record.entry ?? entry;
+      await appendLineAtomic(nextHistoryPath, JSON.stringify(nextEntry));
+      return;
+    }
+  }
+  await appendLineAtomic(historyPath, JSON.stringify(entry));
+}
+
+// dist/core/history/history-stream-policy.js
+import fs from "node:fs/promises";
+import path from "node:path";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "6aa88fb8-fe40-5d0f-bee8-b348eda9309e");
+  } catch (e2) {
+  }
+})();
+function toSortedUniqueItemIds(itemIds) {
+  return [...new Set(itemIds.filter((value) => value.trim().length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function strictMissingStreamError(itemId, commandLabel) {
+  return new PmCliError(`Missing history stream for ${itemId}. ${commandLabel} requires history streams when settings.history.missing_stream is strict_error.`, EXIT_CODE.NOT_FOUND);
+}
+async function createStream(historyPath, commandLabel) {
+  await ensureDir(path.dirname(historyPath));
+  const handle = await fs.open(historyPath, "a");
+  await handle.close();
+  return runActiveOnWriteHooks({
+    path: historyPath,
+    scope: "project",
+    op: `${commandLabel}:history:auto_create`
+  });
+}
+async function enforceHistoryStreamPolicyForItem(params) {
+  return enforceHistoryStreamPolicyForItems({
+    pmRoot: params.pmRoot,
+    settings: params.settings,
+    itemIds: [params.itemId],
+    commandLabel: params.commandLabel
+  });
+}
+async function enforceHistoryStreamPolicyForItems(params) {
+  const ids = toSortedUniqueItemIds(params.itemIds);
+  const autoCreated = [];
+  const warnings = [];
+  for (const itemId of ids) {
+    const historyPath = getHistoryPath(params.pmRoot, itemId);
+    if (await pathExists(historyPath)) {
+      continue;
+    }
+    if (params.settings.history.missing_stream === "strict_error") {
+      throw strictMissingStreamError(itemId, params.commandLabel);
+    }
+    warnings.push(...await createStream(historyPath, params.commandLabel));
+    warnings.push(`history_stream_auto_created:${itemId}`);
+    autoCreated.push(itemId);
+  }
+  return {
+    auto_created_ids: autoCreated,
+    warnings
+  };
+}
+
+// dist/core/store/front-matter-cache.js
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+import { createHash } from "node:crypto";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "a14ed5c7-eb26-57d5-8b28-58d736a3c11c");
+  } catch (e2) {
+  }
+})();
+var CACHE_VERSION = 6;
+var CACHE_FILENAME = "metadata-cache.json";
+var BODY_CACHE_FILENAME = "metadata-cache-bodies.json";
+var COLLECTIONS_CACHE_FILENAME = "metadata-cache-collections.json";
+var HEAVY_METADATA_KEYS = [
+  "comments",
+  "notes",
+  "learnings",
+  "files",
+  "tests",
+  "test_runs",
+  "docs"
+];
+function splitHeavyMetadata(metadata) {
+  const light = { ...metadata };
+  const heavy = {};
+  for (const key of HEAVY_METADATA_KEYS) {
+    if (key in light) {
+      heavy[key] = light[key];
+      delete light[key];
+    }
+  }
+  return { light, heavy };
+}
+function mergeHeavyMetadata(light, heavy) {
+  if (!heavy || Object.keys(heavy).length === 0) {
+    return light;
+  }
+  return { ...light, ...heavy };
+}
+function computeContextFingerprint(preferredFormat, typeToFolder, schema) {
+  const hash = createHash("sha256");
+  hash.update(`format:${preferredFormat ?? "default"}`);
+  const sortedTypes = Object.entries(typeToFolder).sort(([a], [b]) => a.localeCompare(b)).map(([type, folder]) => `${type}=${folder}`).join(",");
+  hash.update(`|types:${sortedTypes}`);
+  if (schema) {
+    hash.update(`|schema:${JSON.stringify(schema)}`);
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function getCachePath(pmRoot) {
+  return path2.join(pmRoot, "runtime", CACHE_FILENAME);
+}
+function getBodyCachePath(pmRoot) {
+  return path2.join(pmRoot, "runtime", BODY_CACHE_FILENAME);
+}
+function getCollectionsCachePath(pmRoot) {
+  return path2.join(pmRoot, "runtime", COLLECTIONS_CACHE_FILENAME);
+}
+async function loadCache(pmRoot) {
+  try {
+    const raw = await fs2.readFile(getCachePath(pmRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION || typeof parsed.entries !== "object" || parsed.entries === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function loadBodyCache(pmRoot) {
+  try {
+    const raw = await fs2.readFile(getBodyCachePath(pmRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION || typeof parsed.bodies !== "object" || parsed.bodies === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function loadCollectionsCache(pmRoot) {
+  try {
+    const raw = await fs2.readFile(getCollectionsCachePath(pmRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION || typeof parsed.collections !== "object" || parsed.collections === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function persistCache(cachePath, envelope) {
+  await fs2.mkdir(path2.dirname(cachePath), { recursive: true });
+  await writeFileAtomic(cachePath, JSON.stringify(envelope));
+}
+function appendWarning(warnings, warning) {
+  if (warnings && !warnings.includes(warning)) {
+    warnings.push(warning);
+  }
+}
+function statMatches(signature, mtimeMs, ctimeMs, size) {
+  return signature.mtime_ms === mtimeMs && signature.ctime_ms === ctimeMs && signature.size === size;
+}
+async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, options = {}) {
+  const includeBody = options.includeBody !== false;
+  const includeCollections = options.includeCollections !== false;
+  const contextFingerprint = computeContextFingerprint(preferredFormat, typeToFolder, schema);
+  const existingCache = await loadCache(pmRoot);
+  const previousEntries = existingCache && existingCache.context_fingerprint === contextFingerprint ? existingCache.entries : {};
+  const existingBodyCache = includeBody ? await loadBodyCache(pmRoot) : null;
+  const previousBodies = existingBodyCache && existingBodyCache.context_fingerprint === contextFingerprint ? existingBodyCache.bodies : {};
+  const existingCollectionsCache = includeCollections ? await loadCollectionsCache(pmRoot) : null;
+  const previousCollections = existingCollectionsCache && existingCollectionsCache.context_fingerprint === contextFingerprint ? existingCollectionsCache.collections : {};
+  const entries = Object.entries(typeToFolder);
+  const dirResults = await Promise.all(entries.map(async ([, folder]) => {
+    const dirPath = path2.join(pmRoot, folder);
+    try {
+      const files = await fs2.readdir(dirPath);
+      return { folder, dirPath, files };
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "code" in error && error.code !== "ENOENT") {
+        appendWarning(warnings, `item_list_directory_read_failed:${folder}`);
+      }
+      return { folder, dirPath, files: [] };
+    }
+  }));
+  const dispatchReadHooks = hasActiveOnReadHooks();
+  const newEntries = {};
+  const newBodies = {};
+  const newCollections = {};
+  const documentsById = /* @__PURE__ */ new Map();
+  let metadataMiss = false;
+  let bodyMiss = false;
+  let collectionsMiss = false;
+  const parseTasks = [];
+  for (const { folder, dirPath, files } of dirResults) {
+    for (const file of files) {
+      if (!ITEM_FILE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext))) {
+        continue;
+      }
+      const filePath = path2.join(dirPath, file);
+      const relativePath = path2.relative(pmRoot, filePath);
+      parseTasks.push((async () => {
+        try {
+          const stat = await fs2.stat(filePath);
+          const mtimeMs = stat.mtimeMs;
+          const ctimeMs = stat.ctimeMs;
+          const { size } = stat;
+          const itemFormat = getItemFormatFromPath(filePath);
+          if (dispatchReadHooks) {
+            for (const warning of await runActiveOnReadHooks({ path: filePath, scope: "project" })) {
+              appendWarning(warnings, warning);
+            }
+          }
+          const cachedEntry = previousEntries[relativePath];
+          const metadataCached = cachedEntry !== void 0 && statMatches(cachedEntry, mtimeMs, ctimeMs, size);
+          const cachedBody = previousBodies[relativePath];
+          const bodyCached = cachedBody !== void 0 && statMatches(cachedBody, mtimeMs, ctimeMs, size);
+          const cachedCollections = previousCollections[relativePath];
+          const collectionsCached = cachedCollections !== void 0 && statMatches(cachedCollections, mtimeMs, ctimeMs, size);
+          const needRead = !metadataCached || includeBody && !bodyCached || includeCollections && !collectionsCached;
+          let lightMetadata;
+          let heavyMetadata;
+          let bodyLength;
+          let body;
+          if (needRead) {
+            const raw = await fs2.readFile(filePath, "utf8");
+            const parsed = parseItemDocument(raw, {
+              format: itemFormat,
+              schema,
+              onWarning: (w) => appendWarning(warnings, w)
+            });
+            const split = splitHeavyMetadata(parsed.metadata);
+            lightMetadata = metadataCached ? cachedEntry.metadata : split.light;
+            bodyLength = metadataCached ? cachedEntry.body_length : parsed.body.length;
+            body = includeBody ? parsed.body : void 0;
+            if (includeCollections) {
+              heavyMetadata = collectionsCached ? cachedCollections.collections : split.heavy;
+            }
+            if (!metadataCached) {
+              metadataMiss = true;
+            }
+            if (includeBody && !bodyCached) {
+              bodyMiss = true;
+            }
+            if (includeCollections && !collectionsCached) {
+              collectionsMiss = true;
+            }
+          } else {
+            lightMetadata = cachedEntry.metadata;
+            bodyLength = cachedEntry.body_length;
+            body = includeBody ? cachedBody.body : void 0;
+            heavyMetadata = includeCollections && cachedCollections ? cachedCollections.collections : void 0;
+          }
+          newEntries[relativePath] = {
+            mtime_ms: mtimeMs,
+            ctime_ms: ctimeMs,
+            size,
+            metadata: lightMetadata,
+            body_length: bodyLength
+          };
+          if (includeBody && body !== void 0) {
+            newBodies[relativePath] = { mtime_ms: mtimeMs, ctime_ms: ctimeMs, size, body };
+          }
+          if (includeCollections && heavyMetadata !== void 0) {
+            newCollections[relativePath] = { mtime_ms: mtimeMs, ctime_ms: ctimeMs, size, collections: heavyMetadata };
+          }
+          const metadata = includeCollections ? mergeHeavyMetadata(lightMetadata, heavyMetadata) : lightMetadata;
+          const existing = documentsById.get(metadata.id);
+          const candidate = {
+            metadata,
+            body,
+            item_format: itemFormat,
+            item_path: filePath
+          };
+          if (!existing) {
+            documentsById.set(metadata.id, { candidate, itemFormat });
+          } else {
+            const shouldReplace = preferredFormat ? itemFormat === preferredFormat && existing.itemFormat !== preferredFormat : itemFormat === "toon" && existing.itemFormat !== "toon";
+            if (shouldReplace) {
+              documentsById.set(metadata.id, { candidate, itemFormat });
+            }
+          }
+        } catch {
+          appendWarning(warnings, `item_list_item_read_failed:${folder}/${file}`);
+        }
+      })());
+    }
+  }
+  await Promise.all(parseTasks);
+  const metadataDirty = metadataMiss || Object.keys(previousEntries).length !== Object.keys(newEntries).length;
+  if (metadataDirty || existingCache === null || existingCache.context_fingerprint !== contextFingerprint) {
+    await persistCache(getCachePath(pmRoot), {
+      version: CACHE_VERSION,
+      context_fingerprint: contextFingerprint,
+      entries: newEntries
+    }).catch(() => {
+    });
+  }
+  if (includeBody) {
+    const bodyDirty = bodyMiss || Object.keys(previousBodies).length !== Object.keys(newBodies).length;
+    if (bodyDirty || existingBodyCache === null || existingBodyCache.context_fingerprint !== contextFingerprint) {
+      await persistCache(getBodyCachePath(pmRoot), {
+        version: CACHE_VERSION,
+        context_fingerprint: contextFingerprint,
+        bodies: newBodies
+      }).catch(() => {
+      });
+    }
+  }
+  if (includeCollections) {
+    const collectionsDirty = collectionsMiss || Object.keys(previousCollections).length !== Object.keys(newCollections).length;
+    if (collectionsDirty || existingCollectionsCache === null || existingCollectionsCache.context_fingerprint !== contextFingerprint) {
+      await persistCache(getCollectionsCachePath(pmRoot), {
+        version: CACHE_VERSION,
+        context_fingerprint: contextFingerprint,
+        collections: newCollections
+      }).catch(() => {
+      });
+    }
+  }
+  return [...documentsById.values()].sort((left, right) => left.candidate.metadata.id.localeCompare(right.candidate.metadata.id)).map((entry) => entry.candidate);
+}
+async function listAllDocumentsCached(pmRoot, preferredFormat, typeToFolder, warnings, schema) {
+  const candidates = await listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, {
+    includeBody: false
+  });
+  return candidates.map((candidate) => ({
+    metadata: candidate.metadata,
+    body: candidate.body ?? ""
+  }));
+}
+async function listAllDocumentsCachedLight(pmRoot, preferredFormat, typeToFolder, warnings, schema) {
+  const candidates = await listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, {
+    includeBody: false,
+    includeCollections: false
+  });
+  return candidates.map((candidate) => ({
+    metadata: candidate.metadata,
+    body: candidate.body ?? ""
+  }));
+}
+
+// dist/core/store/item-store.js
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "e156425f-15da-5c83-b5e6-6c1c1271bf05");
+  } catch (e2) {
+  }
+})();
+async function fileExists(targetPath) {
+  try {
+    await fs3.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function appendWarning2(warnings, warning) {
+  if (!warnings) {
+    return;
+  }
+  if (!warnings.includes(warning)) {
+    warnings.push(warning);
+  }
+}
+function resolveItemFormatSearchOrder(preferredFormat) {
+  if (preferredFormat === "toon") {
+    return ["toon", "json_markdown"];
+  }
+  if (preferredFormat === "json_markdown") {
+    return ["json_markdown", "toon"];
+  }
+  return ["toon", "json_markdown"];
+}
+async function locateItem(pmRoot, rawId, idPrefix, preferredFormat, typeToFolder = TYPE_TO_FOLDER) {
+  const normalizedId = normalizeItemId(rawId, idPrefix);
+  const rawNormalizedId = normalizeRawItemId(rawId);
+  const candidateIds = normalizedId === rawNormalizedId ? [normalizedId] : [normalizedId, rawNormalizedId];
+  const entries = Object.entries(typeToFolder);
+  const searchOrder = resolveItemFormatSearchOrder(preferredFormat);
+  for (const candidateId of candidateIds) {
+    for (const [type] of entries) {
+      for (const itemFormat of searchOrder) {
+        const itemPath = getItemPath(pmRoot, type, candidateId, itemFormat, typeToFolder);
+        if (await fileExists(itemPath)) {
+          return {
+            id: candidateId,
+            type,
+            itemPath,
+            item_format: itemFormat
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+async function readLocatedItem(item, options = {}) {
+  const raw = await fs3.readFile(item.itemPath, "utf8");
+  await runActiveOnReadHooks({
+    path: item.itemPath,
+    scope: "project"
+  });
+  const document = parseItemDocument(raw, {
+    format: item.item_format,
+    schema: options.schema,
+    onWarning: (warning) => appendWarning2(options.warnings, warning)
+  });
+  return { raw, document };
+}
+async function listAllFrontMatter(pmRoot, preferredFormat, typeToFolder = TYPE_TO_FOLDER, warnings, schema) {
+  const documents = await listAllDocumentsCached(pmRoot, preferredFormat, typeToFolder, warnings, schema);
+  return documents.map((document) => document.metadata);
+}
+async function listAllFrontMatterLight(pmRoot, preferredFormat, typeToFolder = TYPE_TO_FOLDER, warnings, schema) {
+  const documents = await listAllDocumentsCachedLight(pmRoot, preferredFormat, typeToFolder, warnings, schema);
+  return documents.map((document) => document.metadata);
+}
+async function listAllFrontMatterWithBody(pmRoot, preferredFormat, typeToFolder = TYPE_TO_FOLDER, warnings, schema) {
+  const candidates = await listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, { includeBody: true });
+  return candidates.map((candidate) => ({
+    ...candidate.metadata,
+    body: candidate.body ?? ""
+  }));
+}
+async function listKnownItemIds(pmRoot, typeToFolder) {
+  const folders = new Set(Object.values(typeToFolder));
+  const allIds = [];
+  await Promise.all([...folders].map(async (folder) => {
+    try {
+      const entries = await fs3.readdir(path3.join(pmRoot, folder));
+      for (const entry of entries) {
+        for (const ext of ITEM_FILE_EXTENSIONS) {
+          if (entry.toLowerCase().endsWith(ext)) {
+            allIds.push(entry.slice(0, -ext.length));
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+  }));
+  return allIds;
+}
+function levenshtein(a, b) {
+  if (a === b)
+    return 0;
+  if (a.length === 0)
+    return b.length;
+  if (b.length === 0)
+    return a.length;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const curr = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr.push(Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost));
+    }
+    prev = curr;
+  }
+  return prev[b.length];
+}
+async function buildDidYouMeanSuggestions(pmRoot, badId, idPrefix, typeToFolder) {
+  const normalized = normalizeItemId(badId, idPrefix);
+  const ids = await listKnownItemIds(pmRoot, typeToFolder);
+  if (ids.length === 0)
+    return [];
+  const scored = ids.map((id) => ({ id, distance: levenshtein(id, normalized) })).filter((entry) => entry.distance <= Math.max(3, Math.floor(normalized.length / 2))).sort((left, right) => left.distance - right.distance).slice(0, 3).map((entry) => entry.id);
+  return scored;
+}
+async function buildItemNotFoundError(pmRoot, badId, idPrefix, typeToFolder) {
+  const suggestions = await buildDidYouMeanSuggestions(pmRoot, badId, idPrefix, typeToFolder);
+  const nextSteps = ["Confirm the active --path/PM_PATH scope, then retry with a valid id."];
+  if (suggestions.length > 0) {
+    nextSteps.unshift(`Did you mean one of: ${suggestions.join(", ")}?`);
+  }
+  return new PmCliError(`Item ${badId} not found`, EXIT_CODE.NOT_FOUND, { nextSteps });
+}
+function bypassesAssigneeConflict(op, bypassAssigneeConflict) {
+  return op === "claim" || bypassAssigneeConflict === true && (op === "comment_add" || op === "note_add" || op === "learning_add" || op === "release" || op === "update" || op === "update_audit");
+}
+async function prepareLockedItem(params) {
+  const typeToFolder = params.typeToFolder ?? resolveItemTypeRegistry(params.settings, getActiveExtensionRegistrations()).type_to_folder;
+  const located = await locateItem(params.pmRoot, params.id, params.settings.id_prefix, params.settings.item_format, typeToFolder);
+  if (!located) {
+    throw await buildItemNotFoundError(params.pmRoot, params.id, params.settings.id_prefix, typeToFolder);
+  }
+  const releaseLock = await acquireLock(params.pmRoot, located.id, params.settings.locks.ttl_seconds, params.author, Boolean(params.force), params.settings.governance.force_required_for_stale_lock);
+  try {
+    const warnings = [];
+    const { raw: originalRaw, document } = await readLocatedItem(located, {
+      schema: params.settings.schema,
+      warnings
+    });
+    const assigned = document.metadata.assignee?.trim();
+    const governance = resolveGovernanceKnobs(params.settings);
+    const hasOwnershipConflict = assigned && assigned !== params.author && !params.force && !bypassesAssigneeConflict(params.op, params.bypassAssigneeConflict);
+    if (hasOwnershipConflict) {
+      if (governance.ownership_enforcement === "strict") {
+        throw new PmCliError(`Item ${located.id} is assigned to ${assigned}. Use --force to override.`, EXIT_CODE.CONFLICT);
+      }
+      if (governance.ownership_enforcement === "warn") {
+        warnings.push(`ownership_warning:assignee_conflict:${located.id}:${assigned}`);
+      }
+    }
+    return {
+      typeToFolder,
+      located,
+      originalRaw,
+      document,
+      warnings,
+      releaseLock
+    };
+  } catch (error) {
+    await releaseLock();
+    throw error;
+  }
+}
+async function mutateItem(params) {
+  const prepared = await prepareLockedItem({
+    pmRoot: params.pmRoot,
+    settings: params.settings,
+    id: params.id,
+    op: params.op,
+    author: params.author,
+    force: params.force,
+    bypassAssigneeConflict: params.bypassAssigneeConflict,
+    typeToFolder: params.typeToFolder
+  });
+  const { typeToFolder, located, originalRaw, document, warnings: parseWarnings, releaseLock } = prepared;
+  try {
+    const historyPolicy = await enforceHistoryStreamPolicyForItem({
+      pmRoot: params.pmRoot,
+      settings: params.settings,
+      itemId: located.id,
+      commandLabel: params.op
+    });
+    const beforeDocument = canonicalDocument(document, { schema: params.settings.schema });
+    const mutableDocument = canonicalDocument(structuredClone(document), { schema: params.settings.schema });
+    const mutation = params.mutate(mutableDocument);
+    mutableDocument.metadata.updated_at = nowIso();
+    const afterDocument = canonicalDocument(mutableDocument, { schema: params.settings.schema });
+    const targetItemFormat = "toon";
+    const serializedAfter = serializeItemDocument(afterDocument, {
+      format: targetItemFormat,
+      schema: params.settings.schema
+    });
+    const targetItemPath = getItemPath(params.pmRoot, afterDocument.metadata.type, located.id, targetItemFormat, typeToFolder);
+    const historyPath = getHistoryPath(params.pmRoot, located.id);
+    const serviceWriteOverride = await runActiveServiceOverride("item_store_write", {
+      op: params.op,
+      pm_root: params.pmRoot,
+      item_id: located.id,
+      source_item_path: located.itemPath,
+      target_item_path: targetItemPath,
+      history_path: historyPath,
+      item_format: targetItemFormat,
+      before: beforeDocument,
+      after: afterDocument,
+      contents: serializedAfter
+    });
+    let effectiveTargetItemPath = targetItemPath;
+    let effectiveSerializedAfter = serializedAfter;
+    let skipItemWrite = false;
+    if (serviceWriteOverride.handled && typeof serviceWriteOverride.result === "object" && serviceWriteOverride.result !== null) {
+      const overrideRecord = serviceWriteOverride.result;
+      if (typeof overrideRecord.target_item_path === "string" && overrideRecord.target_item_path.trim().length > 0) {
+        effectiveTargetItemPath = overrideRecord.target_item_path;
+      }
+      if (typeof overrideRecord.contents === "string") {
+        effectiveSerializedAfter = overrideRecord.contents;
+      }
+      if (overrideRecord.skip_write === true) {
+        skipItemWrite = true;
+      }
+    }
+    if (!skipItemWrite) {
+      await writeFileAtomic(effectiveTargetItemPath, effectiveSerializedAfter);
+    }
+    if (!skipItemWrite && effectiveTargetItemPath !== located.itemPath) {
+      await fs3.rm(located.itemPath);
+    }
+    const entry = createHistoryEntry({
+      nowIso: afterDocument.metadata.updated_at,
+      author: params.author,
+      op: params.op,
+      before: beforeDocument,
+      after: afterDocument,
+      message: params.message
+    });
+    try {
+      await appendHistoryEntry(historyPath, entry);
+    } catch (error) {
+      if (!skipItemWrite && effectiveTargetItemPath !== located.itemPath) {
+        await writeFileAtomic(located.itemPath, originalRaw);
+        await fs3.rm(effectiveTargetItemPath, { force: true });
+      } else if (!skipItemWrite) {
+        await writeFileAtomic(located.itemPath, originalRaw);
+      }
+      throw error;
+    }
+    const hookWarnings = [
+      ...await runActiveOnWriteHooks({
+        path: effectiveTargetItemPath,
+        scope: "project",
+        op: params.op
+      }),
+      ...await runActiveOnWriteHooks({
+        path: historyPath,
+        scope: "project",
+        op: `${params.op}:history`
+      })
+    ];
+    return {
+      item: afterDocument.metadata,
+      body: afterDocument.body,
+      changedFields: mutation.changedFields,
+      warnings: [
+        ...parseWarnings,
+        ...mutation.warnings ?? [],
+        ...historyPolicy.warnings,
+        ...serviceWriteOverride.warnings,
+        ...hookWarnings
+      ]
+    };
+  } finally {
+    await releaseLock();
+  }
+}
+async function deleteItem(params) {
+  const prepared = await prepareLockedItem({
+    pmRoot: params.pmRoot,
+    settings: params.settings,
+    id: params.id,
+    op: "delete",
+    author: params.author,
+    force: params.force
+  });
+  const { located, originalRaw, document, warnings: parseWarnings, releaseLock } = prepared;
+  try {
+    const historyPolicy = await enforceHistoryStreamPolicyForItem({
+      pmRoot: params.pmRoot,
+      settings: params.settings,
+      itemId: located.id,
+      commandLabel: "delete"
+    });
+    const beforeDocument = canonicalDocument(document, { schema: params.settings.schema });
+    const deletionTimestamp = nowIso();
+    const tombstoneDocument = EMPTY_CANONICAL_DOCUMENT;
+    const historyEntry = createHistoryEntry({
+      nowIso: deletionTimestamp,
+      author: params.author,
+      op: "delete",
+      before: beforeDocument,
+      after: tombstoneDocument,
+      message: params.message
+    });
+    const historyPath = getHistoryPath(params.pmRoot, located.id);
+    const serviceDeleteOverride = await runActiveServiceOverride("item_store_delete", {
+      op: "delete",
+      pm_root: params.pmRoot,
+      item_id: located.id,
+      item_path: located.itemPath,
+      history_path: historyPath,
+      before: beforeDocument
+    });
+    let effectiveItemPath = located.itemPath;
+    let skipDelete = false;
+    if (serviceDeleteOverride.handled && typeof serviceDeleteOverride.result === "object" && serviceDeleteOverride.result !== null) {
+      const overrideRecord = serviceDeleteOverride.result;
+      if (typeof overrideRecord.item_path === "string" && overrideRecord.item_path.trim().length > 0) {
+        effectiveItemPath = overrideRecord.item_path;
+      }
+      if (overrideRecord.skip_delete === true) {
+        skipDelete = true;
+      }
+    }
+    if (params.dryRun === true) {
+      return {
+        item: beforeDocument.metadata,
+        changedFields: ["deleted"],
+        targetPath: effectiveItemPath,
+        warnings: [...parseWarnings, ...historyPolicy.warnings, ...serviceDeleteOverride.warnings]
+      };
+    }
+    if (!skipDelete) {
+      await fs3.rm(effectiveItemPath);
+    }
+    try {
+      await appendHistoryEntry(historyPath, historyEntry);
+    } catch (error) {
+      if (!skipDelete) {
+        await writeFileAtomic(effectiveItemPath, originalRaw);
+      }
+      throw error;
+    }
+    const hookWarnings = [
+      ...await runActiveOnWriteHooks({
+        path: effectiveItemPath,
+        scope: "project",
+        op: "delete"
+      }),
+      ...await runActiveOnWriteHooks({
+        path: historyPath,
+        scope: "project",
+        op: "delete:history"
+      })
+    ];
+    return {
+      item: beforeDocument.metadata,
+      changedFields: ["deleted"],
+      warnings: [...parseWarnings, ...historyPolicy.warnings, ...serviceDeleteOverride.warnings, ...hookWarnings]
+    };
+  } finally {
+    await releaseLock();
+  }
+}
+
+export {
+  toItemRecord,
+  hashDocument,
+  hashEmptyDocument,
+  createHistoryEntry,
+  appendHistoryEntry,
+  enforceHistoryStreamPolicyForItem,
+  enforceHistoryStreamPolicyForItems,
+  HEAVY_METADATA_KEYS,
+  listAllDocumentCandidatesCached,
+  locateItem,
+  readLocatedItem,
+  listAllFrontMatter,
+  listAllFrontMatterLight,
+  listAllFrontMatterWithBody,
+  buildItemNotFoundError,
+  mutateItem,
+  deleteItem
+};
+//# sourceMappingURL=chunk-BUPWJ3IJ.js.map