@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,401 +0,0 @@
-import {
-  isRemoteLinkedArtifactReference
-} from "./chunk-7M2HAZEB.js";
-import {
-  resolveAuthor
-} from "./chunk-WW4E2DC3.js";
-import {
-  assertNoUnknownCsvKeys,
-  createStdinTokenResolver,
-  looksLikeGenericKeyValueEntry,
-  parseCsvKv
-} from "./chunk-T3ABIMGW.js";
-import {
-  splitCommaList
-} from "./chunk-5HIZDR5A.js";
-import {
-  listAllFrontMatter,
-  locateItem,
-  mutateItem,
-  readLocatedItem
-} from "./chunk-3U3VEWK6.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettings
-} from "./chunk-P5YORJRH.js";
-import {
-  EXIT_CODE,
-  SCOPE_VALUES,
-  getSettingsPath,
-  pathExists,
-  resolveItemTypeRegistry,
-  resolvePmRoot
-} from "./chunk-5VVUKE3U.js";
-
-// dist/cli/commands/linked-artifacts.js
-import fs from "node:fs/promises";
-import path from "node:path";
-import fg from "fast-glob";
-!(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] = "56979df9-0c63-585c-a792-b330cfa6b169");
-  } catch (e2) {
-  }
-})();
-var LINKED_ARTIFACT_ADD_KEYS = ["path", "scope", "note"];
-var LINKED_ARTIFACT_ADD_GLOB_KEYS = ["pattern", "glob", "path", "scope", "note"];
-var LINKED_ARTIFACT_REMOVE_KEYS = ["path"];
-var LINKED_ARTIFACT_MIGRATE_KEYS = ["from", "to"];
-var LINKED_ARTIFACT_REMOVE_UNSUPPORTED_KEYS = /* @__PURE__ */ new Set(["note", "scope"]);
-function ensureScope(raw) {
-  const value = raw ?? "project";
-  if (!SCOPE_VALUES.includes(value)) {
-    throw new PmCliError(`Invalid scope "${raw}". Valid scopes: ${SCOPE_VALUES.join(", ")} (default: project).`, EXIT_CODE.USAGE);
-  }
-  return value;
-}
-function looksLikeStructuredPathEntry(raw) {
-  if (raw.startsWith("```") || raw.includes("\n")) {
-    return true;
-  }
-  if (/^(?:[-*+]\s+)?(?:path|scope|note)\s*[:=]/i.test(raw)) {
-    return true;
-  }
-  return looksLikeGenericKeyValueEntry(raw);
-}
-function expandBareCommaSeparatedAddEntries(raw) {
-  return raw.flatMap((entry) => {
-    const trimmed = entry.trim();
-    if (trimmed.length === 0 || looksLikeStructuredPathEntry(trimmed) || !trimmed.includes(",")) {
-      return [entry];
-    }
-    return splitCommaList(trimmed);
-  });
-}
-function parseAddEntries(raw, bareNoun) {
-  if (!raw)
-    return [];
-  return expandBareCommaSeparatedAddEntries(raw).map((entry) => {
-    const trimmed = entry.trim();
-    const kv = looksLikeStructuredPathEntry(trimmed) ? parseCsvKv(entry, "--add") : { path: trimmed };
-    assertNoUnknownCsvKeys(kv, "--add", LINKED_ARTIFACT_ADD_KEYS);
-    if (!kv.path) {
-      throw new PmCliError(`--add requires path=<value> or a bare ${bareNoun} path`, EXIT_CODE.USAGE);
-    }
-    return {
-      path: kv.path,
-      scope: ensureScope(kv.scope),
-      note: kv.note?.trim() || void 0
-    };
-  });
-}
-function parseAddGlobEntries(raw) {
-  if (!raw)
-    return [];
-  return raw.map((entry) => {
-    const trimmed = entry.trim();
-    if (!trimmed) {
-      throw new PmCliError("--add-glob requires a glob pattern value", EXIT_CODE.USAGE);
-    }
-    if (trimmed.includes("=") || /^(?:[-*+]\s+)?(?:pattern|glob|path)\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
-      const kv = parseCsvKv(trimmed, "--add-glob");
-      assertNoUnknownCsvKeys(kv, "--add-glob", LINKED_ARTIFACT_ADD_GLOB_KEYS);
-      const pattern = kv.pattern?.trim() || kv.glob?.trim() || kv.path?.trim();
-      if (!pattern) {
-        throw new PmCliError("--add-glob key/value form requires pattern=<glob>", EXIT_CODE.USAGE);
-      }
-      return {
-        pattern,
-        scope: ensureScope(kv.scope),
-        note: kv.note?.trim() || void 0
-      };
-    }
-    return {
-      pattern: trimmed,
-      scope: "project"
-    };
-  });
-}
-function parseRemoveEntries(raw) {
-  if (!raw)
-    return [];
-  return raw.map((entry) => {
-    const trimmed = entry.trim();
-    if (!trimmed) {
-      throw new PmCliError("--remove requires a path value", EXIT_CODE.USAGE);
-    }
-    if (trimmed.includes("=") || /^(?:[-*+]\s+)?path\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
-      const kv = parseCsvKv(trimmed, "--remove");
-      const unsupportedRemoveKeys = Object.keys(kv).filter((key) => LINKED_ARTIFACT_REMOVE_UNSUPPORTED_KEYS.has(key.toLowerCase()));
-      if (unsupportedRemoveKeys.length > 0) {
-        throw new PmCliError(`--remove identifies a linked artifact by path only and does not accept ${unsupportedRemoveKeys.map((key) => `"${key}"`).join(", ")}. Pass just the path (path=<value>, path:<value>, or a bare path); record removal context with --message "<why removed>".`, EXIT_CODE.USAGE);
-      }
-      assertNoUnknownCsvKeys(kv, "--remove", LINKED_ARTIFACT_REMOVE_KEYS);
-      if (!kv.path) {
-        throw new PmCliError("--remove key/value form requires path=<value>", EXIT_CODE.USAGE);
-      }
-      return kv.path;
-    }
-    return trimmed;
-  });
-}
-function parseMigrateEntries(raw) {
-  if (!raw)
-    return [];
-  return raw.map((entry) => {
-    const kv = parseCsvKv(entry, "--migrate");
-    assertNoUnknownCsvKeys(kv, "--migrate", LINKED_ARTIFACT_MIGRATE_KEYS);
-    const from = kv.from?.trim();
-    const to = kv.to?.trim();
-    if (!from || !to) {
-      throw new PmCliError("--migrate requires from=<value> and to=<value>", EXIT_CODE.USAGE);
-    }
-    return { from, to };
-  });
-}
-function applyPathMigrations(artifactPath, migrations) {
-  let next = artifactPath;
-  for (const migration of migrations) {
-    if (next.startsWith(migration.from)) {
-      next = `${migration.to}${next.slice(migration.from.length)}`;
-    }
-  }
-  return next;
-}
-function normalizeLinkedPath(value) {
-  return value.split(path.sep).join("/");
-}
-async function expandAddGlobEntries(entries) {
-  const expanded = [];
-  for (const entry of entries) {
-    const absolutePattern = path.isAbsolute(entry.pattern);
-    const matches = await fg(entry.pattern, {
-      cwd: process.cwd(),
-      absolute: absolutePattern,
-      onlyFiles: true,
-      dot: true,
-      unique: true,
-      followSymbolicLinks: true
-    });
-    const sortedMatches = [...new Set(matches.map((match) => normalizeLinkedPath(path.normalize(match))))].sort((left, right) => left.localeCompare(right));
-    for (const matchedPath of sortedMatches) {
-      expanded.push({
-        path: matchedPath,
-        scope: entry.scope,
-        note: entry.note
-      });
-    }
-  }
-  return expanded;
-}
-function applyStandaloneNote(adds, note, hasAddFlags) {
-  if (note === void 0) {
-    return adds;
-  }
-  if (!hasAddFlags) {
-    throw new PmCliError("--note requires --add or --add-glob in the same invocation (the note annotates the links being added)", EXIT_CODE.USAGE);
-  }
-  const trimmed = note.trim();
-  if (trimmed.length === 0) {
-    return adds;
-  }
-  return adds.map((entry) => entry.note === void 0 ? { ...entry, note: trimmed } : entry);
-}
-function artifactKey(value) {
-  return `${value.path}::${value.scope}`;
-}
-function sortLinkedArtifacts(artifacts) {
-  return [...artifacts].sort((left, right) => {
-    const byPath = left.path.localeCompare(right.path);
-    if (byPath !== 0)
-      return byPath;
-    return left.scope.localeCompare(right.scope);
-  });
-}
-function dedupeLinkedArtifacts(artifacts) {
-  return [...new Map(artifacts.map((entry) => [artifactKey(entry), entry])).values()].map((entry) => ({
-    ...entry,
-    note: entry.note?.trim() || void 0
-  }));
-}
-async function validateLinkedPaths(paths) {
-  const uniquePaths = [...new Set(paths)].sort((left, right) => left.localeCompare(right));
-  const existingFiles = [];
-  const missingPaths = [];
-  const nonFilePaths = [];
-  const remoteReferences = [];
-  for (const relativePath of uniquePaths) {
-    if (isRemoteLinkedArtifactReference(relativePath)) {
-      remoteReferences.push(relativePath.trim());
-      continue;
-    }
-    const resolvedPath = path.isAbsolute(relativePath) ? relativePath : path.resolve(process.cwd(), relativePath);
-    try {
-      const stats = await fs.stat(resolvedPath);
-      if (stats.isFile()) {
-        existingFiles.push(relativePath);
-      } else {
-        nonFilePaths.push(relativePath);
-      }
-    } catch (error) {
-      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
-        missingPaths.push(relativePath);
-        continue;
-      }
-      nonFilePaths.push(relativePath);
-    }
-  }
-  return {
-    checked: uniquePaths.length,
-    existing_files: existingFiles,
-    missing_paths: missingPaths,
-    non_file_paths: nonFilePaths,
-    remote_references: remoteReferences
-  };
-}
-function buildLinkedPathAudit(paths, allItems) {
-  const index = /* @__PURE__ */ new Map();
-  for (const item of allItems) {
-    for (const linkedArtifact of item.artifacts ?? []) {
-      const seen = index.get(linkedArtifact.path) ?? /* @__PURE__ */ new Set();
-      seen.add(item.id);
-      index.set(linkedArtifact.path, seen);
-    }
-  }
-  return [...new Set(paths)].sort((left, right) => left.localeCompare(right)).map((linkedPath) => {
-    const linkedIds = [...index.get(linkedPath) ?? /* @__PURE__ */ new Set()].sort((left, right) => left.localeCompare(right));
-    return {
-      path: linkedPath,
-      linked_by_count: linkedIds.length,
-      linked_item_ids: linkedIds
-    };
-  });
-}
-async function runLinkedArtifacts(id, options, global2, config) {
-  const { metadataKey } = config;
-  const stdinResolver = createStdinTokenResolver();
-  const pmRoot = resolvePmRoot(process.cwd(), global2.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 resolvedAdds = await stdinResolver.resolveList(options.add, "--add");
-  const resolvedAddGlobs = await stdinResolver.resolveList(options.addGlob, "--add-glob");
-  const resolvedRemoves = await stdinResolver.resolveList(options.remove, "--remove");
-  const resolvedMigrations = await stdinResolver.resolveList(options.migrate, "--migrate");
-  const parsedAdds = parseAddEntries(resolvedAdds, config.bareNoun);
-  const addGlobs = parseAddGlobEntries(resolvedAddGlobs);
-  const expandedGlobAdds = await expandAddGlobEntries(addGlobs);
-  const adds = applyStandaloneNote([...parsedAdds, ...expandedGlobAdds], options.note, parsedAdds.length > 0 || addGlobs.length > 0);
-  const removes = parseRemoveEntries(resolvedRemoves);
-  const migrations = parseMigrateEntries(resolvedMigrations);
-  const shouldMutate = adds.length > 0 || removes.length > 0 || migrations.length > 0;
-  const collectAuditItems = async () => (await listAllFrontMatter(pmRoot, settings.item_format, typeRegistry.type_to_folder, void 0, settings.schema)).map((entry) => ({
-    id: entry.id,
-    artifacts: entry[metadataKey]
-  }));
-  if (!shouldMutate) {
-    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 artifacts2 = loaded.document.metadata[metadataKey] ?? [];
-    return {
-      id: located.id,
-      artifacts: artifacts2,
-      changed: false,
-      count: artifacts2.length,
-      validation: options.validatePaths ? await validateLinkedPaths(artifacts2.map((entry) => entry.path)) : void 0,
-      audit: options.audit ? buildLinkedPathAudit(artifacts2.map((entry) => entry.path), await collectAuditItems()) : void 0
-    };
-  }
-  const author = resolveAuthor(options.author, settings.author_default);
-  const result = await mutateItem({
-    pmRoot,
-    settings,
-    id,
-    op: config.op,
-    author,
-    message: options.message,
-    force: options.force,
-    mutate(document) {
-      const metadata = document.metadata;
-      const next = [...metadata[metadataKey] ?? []];
-      let migrationCount2 = 0;
-      if (migrations.length > 0) {
-        for (let index = 0; index < next.length; index += 1) {
-          const migratedPath = applyPathMigrations(next[index].path, migrations);
-          if (migratedPath !== next[index].path) {
-            next[index] = { ...next[index], path: migratedPath };
-            migrationCount2 += 1;
-          }
-        }
-      }
-      const migratedAdds = adds.map((entry) => {
-        const migratedPath = applyPathMigrations(entry.path, migrations);
-        if (migratedPath !== entry.path) {
-          migrationCount2 += 1;
-        }
-        return {
-          ...entry,
-          path: migratedPath
-        };
-      });
-      const migratedRemoves = removes.map((entry) => applyPathMigrations(entry, migrations));
-      for (const add of migratedAdds) {
-        const exists = next.some((entry) => entry.path === add.path && entry.scope === add.scope);
-        if (!exists) {
-          next.push(add);
-        }
-      }
-      if (migratedRemoves.length > 0) {
-        for (let i = next.length - 1; i >= 0; i -= 1) {
-          if (migratedRemoves.includes(next[i].path)) {
-            next.splice(i, 1);
-          }
-        }
-      }
-      const deduped = dedupeLinkedArtifacts(next);
-      const normalized = config.supportsAppendStable && options.appendStable ? deduped : sortLinkedArtifacts(deduped);
-      if (normalized.length > 0) {
-        metadata[metadataKey] = normalized;
-      } else {
-        delete metadata[metadataKey];
-      }
-      return { changedFields: [metadataKey], warnings: migrationCount2 > 0 ? [`path_migrations_applied:${migrationCount2}`] : [] };
-    }
-  });
-  const artifacts = result.item[metadataKey] ?? [];
-  const migrationWarning = result.warnings.find((warning) => warning.startsWith("path_migrations_applied:"));
-  const migrationCount = migrationWarning ? Number(migrationWarning.slice("path_migrations_applied:".length)) : 0;
-  const allItems = options.audit ? await collectAuditItems() : [];
-  return {
-    id: result.item.id,
-    artifacts,
-    changed: true,
-    count: artifacts.length,
-    migrations_applied: migrationCount > 0 ? migrationCount : void 0,
-    validation: options.validatePaths ? await validateLinkedPaths(artifacts.map((entry) => entry.path)) : void 0,
-    audit: options.audit ? buildLinkedPathAudit(artifacts.map((entry) => entry.path), allItems) : void 0
-  };
-}
-function renameArtifactsResultKey(result, key) {
-  const out = {};
-  for (const [field, value] of Object.entries(result)) {
-    out[field === "artifacts" ? key : field] = value;
-  }
-  return out;
-}
-
-export {
-  normalizeLinkedPath,
-  sortLinkedArtifacts,
-  dedupeLinkedArtifacts,
-  runLinkedArtifacts,
-  renameArtifactsResultKey
-};
-//# sourceMappingURL=chunk-WISPVC2E.js.map