@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,260 +0,0 @@
-
-!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]="1b7c28c0-5af8-526d-a895-fe83ffb2841e")}catch(e){}}();
-import {
-  BUILTIN_ITEM_TYPE_VALUES,
-  toDefaultFolder
-} from "./chunk-YD5FML7K.js";
-
-// dist/core/schema/item-types-file.js
-var BUILTIN_NAME_LOOKUP = new Map(BUILTIN_ITEM_TYPE_VALUES.map((name) => [name.toLowerCase(), name]));
-var TYPE_NAME_TOKEN_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
-function assertValidTypeToken(value, label) {
-  if (!TYPE_NAME_TOKEN_PATTERN.test(value)) {
-    throw new Error(`${label} "${value}" is not a valid identifier. Use a single letter-led token of letters, digits, hyphen, or underscore with no spaces or punctuation (e.g. "Spike" or "code-review").`);
-  }
-}
-function matchBuiltinTypeName(name) {
-  return BUILTIN_NAME_LOOKUP.get(name.trim().toLowerCase());
-}
-function coerceAliasArray(value) {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
-}
-function escapeForDoubleQuotes(value) {
-  return value.replace(/[\\"`$]/g, (char) => `\\${char}`);
-}
-function dedupeAliases(values) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    const key = trimmed.toLowerCase();
-    if (!seen.has(key)) {
-      seen.set(key, trimmed);
-    }
-  }
-  return [...seen.values()].sort((left, right) => left.localeCompare(right));
-}
-function normalizeAddTypeInput(raw) {
-  const name = (raw.name ?? "").trim();
-  if (name.length === 0) {
-    throw new Error("Type name must not be empty.");
-  }
-  assertValidTypeToken(name, "Type name");
-  const builtinMatch = matchBuiltinTypeName(name);
-  if (builtinMatch) {
-    throw new Error(`Cannot redefine built-in item type "${builtinMatch}". Built-in types are reserved: ${BUILTIN_ITEM_TYPE_VALUES.join(", ")}.`);
-  }
-  const description = raw.description?.trim();
-  const defaultStatus = raw.defaultStatus?.trim();
-  const folder = raw.folder?.trim();
-  const aliases = dedupeAliases(raw.aliases ?? []);
-  for (const alias of aliases) {
-    assertValidTypeToken(alias, "Alias");
-    const aliasBuiltin = matchBuiltinTypeName(alias);
-    if (aliasBuiltin) {
-      throw new Error(`Alias "${alias}" collides with built-in item type "${aliasBuiltin}". Built-in types are reserved: ${BUILTIN_ITEM_TYPE_VALUES.join(", ")}.`);
-    }
-  }
-  return {
-    name,
-    description: description && description.length > 0 ? description : void 0,
-    defaultStatus: defaultStatus && defaultStatus.length > 0 ? defaultStatus : void 0,
-    folder: folder && folder.length > 0 ? folder : void 0,
-    aliases
-  };
-}
-function assertAliasesAvailable(input, existing) {
-  const selfLower = input.name.toLowerCase();
-  const taken = /* @__PURE__ */ new Map();
-  for (const definition of existing.definitions) {
-    if (typeof definition.name !== "string") {
-      continue;
-    }
-    const definitionName = definition.name.trim();
-    if (definitionName.length === 0 || definitionName.toLowerCase() === selfLower) {
-      continue;
-    }
-    taken.set(definitionName.toLowerCase(), definitionName);
-    for (const alias of coerceAliasArray(definition.aliases)) {
-      if (alias.trim().length > 0) {
-        taken.set(alias.trim().toLowerCase(), definitionName);
-      }
-    }
-  }
-  const nameOwner = taken.get(selfLower);
-  if (nameOwner) {
-    throw new Error(`Type name "${input.name}" collides with an alias of existing item type "${nameOwner}".`);
-  }
-  for (const alias of input.aliases) {
-    const owner = taken.get(alias.toLowerCase());
-    if (owner) {
-      throw new Error(`Alias "${alias}" already maps to existing item type "${owner}".`);
-    }
-  }
-}
-function resolveDefinitionFolder(name, folder) {
-  if (typeof folder === "string" && folder.trim().length > 0) {
-    return folder.trim().toLowerCase();
-  }
-  return toDefaultFolder(name).toLowerCase();
-}
-function assertTypeFolderAvailable(input, existing, reservedFolders) {
-  const selfLower = input.name.toLowerCase();
-  const inputFolder = resolveDefinitionFolder(input.name, input.folder);
-  const fail = (ownerName) => {
-    throw new Error(`Item type "${input.name}" would store items in folder "${inputFolder}", which already belongs to existing item type "${ownerName}". Pass a distinct --folder to keep their storage separate.`);
-  };
-  for (const definition of existing.definitions) {
-    if (typeof definition.name !== "string") {
-      continue;
-    }
-    const definitionName = definition.name.trim();
-    if (definitionName.length === 0 || definitionName.toLowerCase() === selfLower) {
-      continue;
-    }
-    if (resolveDefinitionFolder(definitionName, definition.folder) === inputFolder) {
-      fail(definitionName);
-    }
-  }
-  const reservedOwner = reservedFolders?.get(inputFolder);
-  if (reservedOwner !== void 0 && reservedOwner.toLowerCase() !== selfLower) {
-    fail(reservedOwner);
-  }
-}
-function parseItemTypesFile(raw) {
-  if (raw === null || raw === void 0 || raw.trim().length === 0) {
-    return { definitions: [] };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error("schema/types.json contains invalid JSON.");
-  }
-  return { definitions: extractDefinitions(parsed) };
-}
-function extractDefinitions(parsed) {
-  const candidate = selectDefinitionsArray(parsed);
-  if (!candidate) {
-    return [];
-  }
-  const definitions = [];
-  for (const entry of candidate) {
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-      continue;
-    }
-    const record = entry;
-    if (typeof record.name !== "string" || record.name.trim().length === 0) {
-      continue;
-    }
-    definitions.push(record);
-  }
-  return definitions;
-}
-function selectDefinitionsArray(parsed) {
-  if (Array.isArray(parsed)) {
-    return parsed;
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    return void 0;
-  }
-  const record = parsed;
-  if (Array.isArray(record.definitions)) {
-    return record.definitions;
-  }
-  if (typeof record.item_types === "object" && record.item_types !== null) {
-    const nested = record.item_types;
-    if (Array.isArray(nested.definitions)) {
-      return nested.definitions;
-    }
-  }
-  return void 0;
-}
-function upsertItemType(file, input) {
-  const lowerName = input.name.toLowerCase();
-  const definitions = file.definitions.slice();
-  const existingIndex = definitions.findIndex((definition) => typeof definition.name === "string" && definition.name.trim().toLowerCase() === lowerName);
-  const existing = existingIndex >= 0 ? definitions[existingIndex] : void 0;
-  const mergedAliases = dedupeAliases([...coerceAliasArray(existing?.aliases), ...input.aliases]);
-  const next = {
-    ...existing,
-    name: input.name
-  };
-  if (input.folder !== void 0) {
-    next.folder = input.folder;
-  }
-  if (mergedAliases.length > 0) {
-    next.aliases = mergedAliases;
-  } else if (next.aliases !== void 0) {
-    delete next.aliases;
-  }
-  applyAttribute(next, "description", input.description);
-  applyAttribute(next, "default_status", input.defaultStatus);
-  if (existingIndex >= 0) {
-    definitions[existingIndex] = next;
-  } else {
-    definitions.push(next);
-  }
-  definitions.sort((left, right) => left.name.localeCompare(right.name));
-  return {
-    file: { definitions },
-    definition: next,
-    replaced: existingIndex >= 0,
-    ...existing && typeof existing.name === "string" ? { previousName: existing.name } : {}
-  };
-}
-function removeItemType(file, name) {
-  const trimmed = (name ?? "").trim();
-  if (trimmed.length === 0) {
-    throw new Error("Type name must not be empty.");
-  }
-  const builtinMatch = matchBuiltinTypeName(trimmed);
-  if (builtinMatch) {
-    throw new Error(`Cannot remove built-in item type "${builtinMatch}". Built-in types are reserved: ${BUILTIN_ITEM_TYPE_VALUES.join(", ")}.`);
-  }
-  const lowerName = trimmed.toLowerCase();
-  const definitions = file.definitions.slice();
-  const existingIndex = definitions.findIndex((definition2) => typeof definition2.name === "string" && definition2.name.trim().toLowerCase() === lowerName);
-  if (existingIndex < 0) {
-    return { file: { definitions }, removed: false };
-  }
-  const [definition] = definitions.splice(existingIndex, 1);
-  return { file: { definitions }, removed: true, definition };
-}
-function applyAttribute(definition, key, value) {
-  const record = definition;
-  if (value !== void 0) {
-    record[key] = value;
-  }
-}
-function serializeItemTypesFile(file) {
-  return `${JSON.stringify({ definitions: file.definitions }, null, 2)}
-`;
-}
-function buildInvalidTypeHint(name, typesFilePath) {
-  const safeName = name.trim().length > 0 ? name.trim() : name;
-  const target = typesFilePath?.trim() || ".agents/pm/schema/types.json";
-  return `To register a custom type, run: pm schema add-type "${escapeForDoubleQuotes(safeName)}" (writes ${target}).`;
-}
-function buildInvalidTypeError(name, allowedTypes, typesFilePath) {
-  return `Invalid type value "${name}". Allowed: ${allowedTypes.join(", ")}. ${buildInvalidTypeHint(name, typesFilePath)}`;
-}
-
-export {
-  matchBuiltinTypeName,
-  escapeForDoubleQuotes,
-  normalizeAddTypeInput,
-  assertAliasesAvailable,
-  assertTypeFolderAvailable,
-  parseItemTypesFile,
-  upsertItemType,
-  removeItemType,
-  serializeItemTypesFile,
-  buildInvalidTypeHint,
-  buildInvalidTypeError
-};
-//# sourceMappingURL=chunk-NER3KUUS.js.map
-
-//# debugId=1b7c28c0-5af8-526d-a895-fe83ffb2841e