@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,160 @@
+import {
+  collectUsedExtensionCapabilities,
+  normalizeExtensionName
+} from "./chunk-LK6XLOGP.js";
+
+// dist/core/extensions/activation-summary.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] = "1c4b6114-ebdc-5cd5-8d51-5992b820af47");
+  } catch (e2) {
+  }
+})();
+var HOOK_REGISTRY_FIELD_TO_KIND = [
+  ["beforeCommand", "before_command"],
+  ["afterCommand", "after_command"],
+  ["onWrite", "on_write"],
+  ["onRead", "on_read"],
+  ["onIndex", "on_index"]
+];
+function describeExtensionActivation(activation, options = {}) {
+  const filters = /* @__PURE__ */ new Set();
+  if (options.extensionName !== void 0) {
+    filters.add(normalizeExtensionName(options.extensionName));
+  }
+  for (const name of options.extensionNames ?? []) {
+    filters.add(normalizeExtensionName(name));
+  }
+  const matches = (name) => filters.size === 0 || filters.has(normalizeExtensionName(name));
+  const collect = (entries, identify) => sortUnique(entries.filter((entry) => matches(entry.name)).map(identify));
+  const collectFlat = (entries, expand) => sortUnique(entries.filter((entry) => matches(entry.name)).flatMap(expand));
+  const { registrations, commands, parsers, preflight, services, renderers, hooks } = activation;
+  return {
+    capabilities: collectUsedExtensionCapabilities(activation, options),
+    commands: collect(registrations.commands, (entry) => entry.command),
+    command_overrides: collect(commands.overrides, (entry) => entry.command),
+    command_handlers: collect(commands.handlers, (entry) => entry.command),
+    hooks: HOOK_REGISTRY_FIELD_TO_KIND.filter(([field]) => hooks[field].some((entry) => matches(entry.name))).map(([, kind]) => kind),
+    flag_commands: collect(registrations.flags, (entry) => entry.target_command),
+    item_types: collectFlat(registrations.item_types, (entry) => entry.types.map((type) => type.name)),
+    item_fields: collectFlat(registrations.item_fields, (entry) => entry.fields.map((field) => field.name)),
+    migrations: collectFlat(registrations.migrations, (entry) => typeof entry.definition.id === "string" ? [entry.definition.id] : []),
+    profiles: collect(registrations.profiles, (entry) => entry.profile.name),
+    importers: collect(registrations.importers, (entry) => entry.importer),
+    exporters: collect(registrations.exporters, (entry) => entry.exporter),
+    search_providers: collect(registrations.search_providers, (entry) => entry.definition.name),
+    vector_store_adapters: collect(registrations.vector_store_adapters, (entry) => entry.definition.name),
+    parser_overrides: collect(parsers.overrides, (entry) => entry.command),
+    service_overrides: collect(services.overrides, (entry) => entry.service),
+    renderer_overrides: collect(renderers.overrides, (entry) => entry.format),
+    preflight_overrides: preflight.overrides.filter((entry) => matches(entry.name)).length
+  };
+}
+function sortUnique(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+
+// dist/core/extensions/activation-summary-markdown.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] = "b179b4ec-bec8-5761-b7d2-db8f7c8ed54a");
+  } catch (e2) {
+  }
+})();
+var MIN_HEADING_LEVEL = 1;
+var MAX_HEADING_LEVEL = 6;
+var SURFACE_SECTIONS = [
+  ["commands", "Commands"],
+  ["command_overrides", "Command overrides"],
+  ["flag_commands", "Flag commands"],
+  ["item_types", "Item types"],
+  ["item_fields", "Item fields"],
+  ["migrations", "Migrations"],
+  ["profiles", "Profiles"],
+  ["importers", "Importers"],
+  ["exporters", "Exporters"],
+  ["search_providers", "Search providers"],
+  ["vector_store_adapters", "Vector store adapters"],
+  ["hooks", "Lifecycle hooks"],
+  ["parser_overrides", "Parser overrides"],
+  ["service_overrides", "Service overrides"],
+  ["renderer_overrides", "Renderer overrides"]
+];
+function headingPrefix(level) {
+  return "#".repeat(level);
+}
+function code(value) {
+  if (!value.includes("`")) {
+    return `\`${value}\``;
+  }
+  let longestRun = 0;
+  let currentRun = 0;
+  for (const char of value) {
+    currentRun = char === "`" ? currentRun + 1 : 0;
+    longestRun = Math.max(longestRun, currentRun);
+  }
+  const fence = "`".repeat(longestRun + 1);
+  const pad = value.startsWith("`") || value.endsWith("`") ? " " : "";
+  return `${fence}${pad}${value}${pad}${fence}`;
+}
+function renderCapabilitiesLine(capabilities) {
+  if (capabilities.length === 0) {
+    return "Capabilities: _none registered_";
+  }
+  return `Capabilities: ${capabilities.map(code).join(", ")}`;
+}
+function renderSection(heading, level, entries) {
+  const lines = [`${headingPrefix(level)} ${heading}`, ""];
+  if (entries.length === 0) {
+    lines.push("_None._", "");
+    return lines;
+  }
+  lines.push(...entries.map((entry) => `- ${code(entry)}`), "");
+  return lines;
+}
+function renderPreflightSection(count, level, includeEmpty) {
+  if (count === 0 && !includeEmpty) {
+    return [];
+  }
+  return [
+    `${headingPrefix(level)} Preflight overrides`,
+    "",
+    count > 0 ? `- ${count} registered (this surface carries no per-entry identifier)` : "_None._",
+    ""
+  ];
+}
+function renderExtensionSurfaceMarkdown(summary, options = {}) {
+  const titleLevel = options.headingLevel ?? 2;
+  if (!Number.isInteger(titleLevel) || titleLevel < MIN_HEADING_LEVEL || titleLevel > MAX_HEADING_LEVEL) {
+    throw new RangeError(`headingLevel must be an integer in [${MIN_HEADING_LEVEL}, ${MAX_HEADING_LEVEL}], received ${String(options.headingLevel)}`);
+  }
+  const sectionLevel = Math.min(titleLevel + 1, MAX_HEADING_LEVEL);
+  const includeEmpty = options.includeEmpty === true;
+  const title = options.title ?? "Extension surfaces";
+  const lines = [`${headingPrefix(titleLevel)} ${title}`, ""];
+  if (includeEmpty || summary.capabilities.length > 0) {
+    lines.push(renderCapabilitiesLine(summary.capabilities), "");
+  }
+  for (const [field, heading] of SURFACE_SECTIONS) {
+    const entries = summary[field];
+    if (entries.length === 0 && !includeEmpty) {
+      continue;
+    }
+    lines.push(...renderSection(heading, sectionLevel, entries));
+  }
+  lines.push(...renderPreflightSection(summary.preflight_overrides, sectionLevel, includeEmpty));
+  const hasAnySurface = summary.preflight_overrides > 0 || SURFACE_SECTIONS.some(([field]) => summary[field].length > 0);
+  if (!hasAnySurface && !includeEmpty) {
+    lines.push("_This extension registers no surfaces._", "");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+
+export {
+  describeExtensionActivation,
+  renderExtensionSurfaceMarkdown
+};
+//# sourceMappingURL=chunk-EGY6JBQ3.js.map

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

@@ -0,0 +1,222 @@
+
+!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]="1775008a-959d-5fa2-a867-2a4d24c3a190")}catch(e){}}();
+import {
+  parseCsvKv
+} from "./chunk-IWVU4C2F.js";
+import {
+  resolveAuthor
+} from "./chunk-T5RRNDA7.js";
+import {
+  parseLimit
+} from "./chunk-22KBU3MW.js";
+import {
+  locateItem,
+  mutateItem,
+  readLocatedItem
+} from "./chunk-ENGQOEUY.js";
+import {
+  nowIso
+} from "./chunk-3GCS5SKL.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings
+} from "./chunk-E3SZTQ4K.js";
+import {
+  EXIT_CODE,
+  getSettingsPath,
+  pathExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot
+} from "./chunk-57NWPFF2.js";
+
+// dist/cli/commands/annotation-command.js
+function limitAnnotationEntries(values, limit) {
+  if (limit === void 0)
+    return values;
+  if (limit === 0)
+    return [];
+  return values.slice(Math.max(0, values.length - limit));
+}
+function readAnnotationEntries(source, collectionKey) {
+  const value = source[collectionKey];
+  return Array.isArray(value) ? value : [];
+}
+function parseAnnotationTextInput(raw, options = {}) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const textPrefixMatch = /^(?:[-*+]\s*)?text\s*[:=]/i.exec(trimmed);
+  if (options.stripPlainTextPrefix === true && textPrefixMatch && !trimmed.startsWith("```")) {
+    const text = trimmed.slice(textPrefixMatch[0].length).trim();
+    return text || trimmed;
+  }
+  const looksStructured = /^(?:[-*+]\s*)?text\s*[:=]/im.test(trimmed) || trimmed.startsWith("```");
+  if (!looksStructured) {
+    return trimmed;
+  }
+  try {
+    const kv = parseCsvKv(trimmed, "--add");
+    const keys = Object.keys(kv).map((key) => key.trim().toLowerCase());
+    if (keys.some((key) => key !== "text")) {
+      return trimmed;
+    }
+    const text = kv.text?.trim();
+    return text || trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+function wrapOwnershipConflict(error, guidance) {
+  if (error instanceof PmCliError && error.exitCode === EXIT_CODE.CONFLICT && error.message.includes("is assigned to") && error.message.includes("Use --force to override")) {
+    throw new PmCliError(error.message, error.exitCode, {
+      code: "ownership_conflict",
+      required: guidance.required,
+      examples: guidance.examples,
+      nextSteps: guidance.nextSteps
+    });
+  }
+  throw error;
+}
+async function runAnnotationCommand(id, options, global, config) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const limit = parseLimit(options.limit);
+  if (config.input.mode === "list") {
+    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+    if (!located) {
+      throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
+    }
+    const loaded = await readLocatedItem(located, { schema: settings.schema });
+    const allEntries2 = readAnnotationEntries(loaded.document.metadata, config.collectionKey);
+    return renderAnnotationResult(located.id, config.collectionKey, allEntries2, limit, options.includeMeta === true);
+  }
+  const author = resolveAuthor(options.author, settings.author_default);
+  if (config.input.mode === "delete") {
+    const op = config.deleteOp ?? config.op;
+    let result2;
+    try {
+      result2 = await mutateItem({
+        pmRoot,
+        settings,
+        id,
+        op,
+        author,
+        message: options.message,
+        force: options.force,
+        bypassAssigneeConflict: config.allowAuditBypass,
+        mutate(document) {
+          const entries = readAnnotationEntries(document.metadata, config.collectionKey);
+          const arrayIndex = resolveAnnotationIndex(config.input.index, entries.length, config.collectionKey);
+          entries.splice(arrayIndex, 1);
+          document.metadata[config.collectionKey] = entries;
+          return { changedFields: [config.collectionKey] };
+        }
+      });
+    } catch (error) {
+      wrapOwnershipConflict(error, config.conflictGuidance);
+    }
+    const allEntries2 = readAnnotationEntries(result2.item, config.collectionKey);
+    return renderAnnotationResult(result2.item.id, config.collectionKey, allEntries2, limit, options.includeMeta === true);
+  }
+  const text = config.parseText(config.input.value ?? "");
+  if (!text.trim()) {
+    throw new PmCliError(`${config.input.emptyFlag ?? "--add"} text cannot be empty`, EXIT_CODE.USAGE);
+  }
+  if (config.input.mode === "edit") {
+    const op = config.editOp ?? config.op;
+    let result2;
+    try {
+      result2 = await mutateItem({
+        pmRoot,
+        settings,
+        id,
+        op,
+        author,
+        message: options.message,
+        force: options.force,
+        bypassAssigneeConflict: config.allowAuditBypass,
+        mutate(document) {
+          const entries = readAnnotationEntries(document.metadata, config.collectionKey);
+          const arrayIndex = resolveAnnotationIndex(config.input.index, entries.length, config.collectionKey);
+          const existing = entries[arrayIndex];
+          entries[arrayIndex] = {
+            ...existing,
+            text,
+            edited_at: nowIso()
+          };
+          document.metadata[config.collectionKey] = entries;
+          return { changedFields: [config.collectionKey] };
+        }
+      });
+    } catch (error) {
+      wrapOwnershipConflict(error, config.conflictGuidance);
+    }
+    const allEntries2 = readAnnotationEntries(result2.item, config.collectionKey);
+    return renderAnnotationResult(result2.item.id, config.collectionKey, allEntries2, limit, options.includeMeta === true);
+  }
+  let result;
+  try {
+    result = await mutateItem({
+      pmRoot,
+      settings,
+      id,
+      op: config.op,
+      author,
+      message: options.message,
+      force: options.force,
+      bypassAssigneeConflict: config.allowAuditBypass,
+      mutate(document) {
+        const entries = readAnnotationEntries(document.metadata, config.collectionKey);
+        entries.push({
+          created_at: nowIso(),
+          author,
+          text
+        });
+        document.metadata[config.collectionKey] = entries;
+        return { changedFields: [config.collectionKey] };
+      }
+    });
+  } catch (error) {
+    wrapOwnershipConflict(error, config.conflictGuidance);
+  }
+  const allEntries = readAnnotationEntries(result.item, config.collectionKey);
+  return renderAnnotationResult(result.item.id, config.collectionKey, allEntries, limit, options.includeMeta === true);
+}
+function resolveAnnotationIndex(oneBasedIndex, count, collectionKey) {
+  if (oneBasedIndex === void 0 || !Number.isInteger(oneBasedIndex) || oneBasedIndex < 1 || oneBasedIndex > count) {
+    const singular = collectionKey.replace(/s$/, "");
+    const label = `${singular.charAt(0).toUpperCase()}${singular.slice(1)}`;
+    const noun = count === 1 ? `1 ${singular}` : `${count} ${collectionKey}`;
+    throw new PmCliError(`${label} index ${oneBasedIndex ?? "(missing)"} out of range (item has ${noun})`, EXIT_CODE.USAGE);
+  }
+  return oneBasedIndex - 1;
+}
+function renderAnnotationResult(id, collectionKey, allEntries, limit, includeMeta) {
+  const entries = limitAnnotationEntries(allEntries, limit);
+  return {
+    id,
+    [collectionKey]: entries,
+    count: entries.length,
+    ...includeMeta ? {
+      total_count: allEntries.length,
+      returned_count: entries.length,
+      has_more: entries.length < allEntries.length,
+      ...limit !== void 0 ? { limit } : {}
+    } : {}
+  };
+}
+
+export {
+  parseAnnotationTextInput,
+  wrapOwnershipConflict,
+  runAnnotationCommand
+};
+//# sourceMappingURL=chunk-EKFNL33R.js.map
+
+//# debugId=1775008a-959d-5fa2-a867-2a4d24c3a190