@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,533 +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]="b091c012-afb7-5159-95d2-527f565dc5e7")}catch(e){}}();
-import {
-  normalizeAddTypeInput
-} from "./chunk-NER3KUUS.js";
-import {
-  evictOldestMemoEntries
-} from "./chunk-NNHHXJB2.js";
-import {
-  DEFAULT_RUNTIME_STATUS_DEFINITIONS,
-  RUNTIME_FIELD_COMMAND_VALUES,
-  RUNTIME_FIELD_TYPE_VALUES,
-  RUNTIME_STATUS_ROLE_VALUES
-} from "./chunk-YD5FML7K.js";
-
-// dist/core/schema/status-defs-file.js
-var RUNTIME_STATUS_ROLE_SET = new Set(RUNTIME_STATUS_ROLE_VALUES);
-var STATUS_TOKEN_MEMO_MAX_ENTRIES = 2e3;
-var statusTokenMemo = /* @__PURE__ */ new Map();
-var BUILTIN_STATUS_IDS = new Set(DEFAULT_RUNTIME_STATUS_DEFINITIONS.map((definition) => normalizeStatusToken(definition.id)).filter((id) => id.length > 0));
-function normalizeStatusToken(value) {
-  if (typeof value !== "string") {
-    return "";
-  }
-  const memoized = statusTokenMemo.get(value);
-  if (memoized !== void 0) {
-    return memoized;
-  }
-  const normalized = value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_");
-  if (statusTokenMemo.size >= STATUS_TOKEN_MEMO_MAX_ENTRIES) {
-    evictOldestMemoEntries(statusTokenMemo);
-  }
-  statusTokenMemo.set(value, normalized);
-  return normalized;
-}
-function dedupeTokens(values) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const value of values) {
-    const token = normalizeStatusToken(value);
-    if (token.length > 0) {
-      seen.add(token);
-    }
-  }
-  return [...seen].sort((left, right) => left.localeCompare(right));
-}
-function normalizeAddStatusInput(raw) {
-  const id = normalizeStatusToken(raw.id);
-  if (id.length === 0) {
-    throw new Error("Status id must not be empty.");
-  }
-  if (BUILTIN_STATUS_IDS.has(id)) {
-    throw new Error(`Cannot add-status the built-in status "${id}". Built-in statuses are reserved: ${[...BUILTIN_STATUS_IDS].join(", ")}.`);
-  }
-  let roles;
-  if (raw.roles !== void 0) {
-    roles = [];
-    const seenRoles = /* @__PURE__ */ new Set();
-    for (const rawRole of raw.roles) {
-      const role = typeof rawRole === "string" ? rawRole.trim().toLowerCase() : "";
-      if (role.length === 0) {
-        continue;
-      }
-      if (!RUNTIME_STATUS_ROLE_SET.has(role)) {
-        throw new Error(`Invalid status role "${rawRole}". Allowed roles: ${RUNTIME_STATUS_ROLE_VALUES.join(", ")}.`);
-      }
-      if (!seenRoles.has(role)) {
-        seenRoles.add(role);
-        roles.push(role);
-      }
-    }
-  }
-  const aliases = raw.aliases === void 0 ? void 0 : dedupeTokens(raw.aliases).filter((alias) => alias !== id);
-  const description = raw.description?.trim();
-  const order = typeof raw.order === "number" && Number.isFinite(raw.order) ? Math.trunc(raw.order) : void 0;
-  return {
-    id,
-    roles,
-    aliases,
-    description: description && description.length > 0 ? description : void 0,
-    order
-  };
-}
-function selectStatusesArray(parsed) {
-  if (Array.isArray(parsed)) {
-    return parsed;
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    return void 0;
-  }
-  const record = parsed;
-  if (Array.isArray(record.statuses)) {
-    return record.statuses;
-  }
-  if (Array.isArray(record.definitions)) {
-    return record.definitions;
-  }
-  return void 0;
-}
-function extractStatusDefinitions(parsed) {
-  const candidate = selectStatusesArray(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.id !== "string" || record.id.trim().length === 0) {
-      continue;
-    }
-    definitions.push(record);
-  }
-  return definitions;
-}
-function parseStatusDefsFile(raw) {
-  if (raw === null || raw === void 0 || raw.trim().length === 0) {
-    return { statuses: [] };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error("schema/statuses.json contains invalid JSON.");
-  }
-  return { statuses: extractStatusDefinitions(parsed) };
-}
-function serializeStatusDefsFile(file) {
-  return `${JSON.stringify({ statuses: file.statuses }, null, 2)}
-`;
-}
-function upsertStatusDef(file, input, baseDefinition) {
-  const statuses = file.statuses.slice();
-  const existingIndex = statuses.findIndex((definition) => normalizeStatusToken(definition.id) === input.id);
-  const existing = existingIndex >= 0 ? statuses[existingIndex] : baseDefinition;
-  const next = {
-    ...existing,
-    id: input.id
-  };
-  if (input.roles !== void 0) {
-    if (input.roles.length > 0) {
-      next.roles = [...input.roles];
-    } else if (next.roles !== void 0) {
-      delete next.roles;
-    }
-  }
-  if (input.aliases !== void 0) {
-    if (input.aliases.length > 0) {
-      next.aliases = [...input.aliases];
-    } else if (next.aliases !== void 0) {
-      delete next.aliases;
-    }
-  }
-  if (input.description !== void 0) {
-    next.description = input.description;
-  }
-  if (input.order !== void 0) {
-    next.order = input.order;
-  }
-  if (existingIndex >= 0) {
-    statuses[existingIndex] = next;
-  } else {
-    statuses.push(next);
-  }
-  return {
-    file: { statuses },
-    definition: next,
-    // "replaced" reflects whether the status already existed effectively (in the
-    // file OR in resolved settings), so the CLI reports "Updated" vs "Registered"
-    // correctly even when the prior definition lived only in settings.
-    replaced: existing !== void 0
-  };
-}
-function removeStatusDef(file, id) {
-  const normalizedId = normalizeStatusToken(id);
-  if (normalizedId.length === 0) {
-    throw new Error("Status id must not be empty.");
-  }
-  if (BUILTIN_STATUS_IDS.has(normalizedId)) {
-    throw new Error(`Cannot remove built-in status "${normalizedId}". Built-in statuses are reserved: ${[...BUILTIN_STATUS_IDS].join(", ")}.`);
-  }
-  const statuses = file.statuses.slice();
-  const existingIndex = statuses.findIndex((definition2) => normalizeStatusToken(definition2.id) === normalizedId);
-  if (existingIndex < 0) {
-    return { file: { statuses }, removed: false };
-  }
-  const [definition] = statuses.splice(existingIndex, 1);
-  return { file: { statuses }, removed: true, definition };
-}
-function assertStatusTokensAvailable(input, resolvedAliasToId) {
-  const candidates = [input.id, ...input.aliases ?? []];
-  for (const candidate of candidates) {
-    const token = normalizeStatusToken(candidate);
-    if (token.length === 0) {
-      continue;
-    }
-    const owner = resolvedAliasToId.get(token);
-    if (owner !== void 0 && owner !== input.id) {
-      throw new Error(`Status token "${token}" already belongs to status "${owner}". Choose a different id/alias to avoid shadowing it.`);
-    }
-  }
-}
-
-// dist/core/schema/fields-file.js
-var RUNTIME_FIELD_TYPE_SET = new Set(RUNTIME_FIELD_TYPE_VALUES);
-var RUNTIME_FIELD_COMMAND_SET = new Set(RUNTIME_FIELD_COMMAND_VALUES);
-var BUILTIN_FIELD_KEYS = /* @__PURE__ */ new Set([
-  "id",
-  "title",
-  "type",
-  "status",
-  "priority",
-  "tags",
-  "assignee",
-  "parent",
-  "description",
-  "body",
-  "created_at",
-  "updated_at",
-  "closed_at",
-  "author",
-  "deadline",
-  "estimate",
-  "sprint",
-  "release",
-  "risk",
-  "confidence",
-  "reviewer",
-  "resolution",
-  "expected",
-  "actual"
-]);
-var DEFAULT_FIELD_COMMANDS = ["create", "update"];
-function normalizeFieldKey(value) {
-  return typeof value === "string" ? value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_") : "";
-}
-function normalizeCliToken(value) {
-  if (typeof value !== "string") {
-    return "";
-  }
-  const collapsed = value.trim().toLowerCase().replaceAll(/[\s_]+/g, "-");
-  return collapsed.startsWith("--") ? collapsed.slice(2) : collapsed;
-}
-function keyToDefaultCliFlag(key) {
-  return key.replaceAll("_", "-");
-}
-function dedupeCliTokens(values, exclude) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const value of values) {
-    const token = normalizeCliToken(value);
-    if (token.length > 0 && token !== exclude) {
-      seen.add(token);
-    }
-  }
-  return [...seen].sort((left, right) => left.localeCompare(right));
-}
-function dedupeStringList(values) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const value of values ?? []) {
-    const trimmed = value.trim();
-    if (trimmed.length > 0) {
-      seen.add(trimmed);
-    }
-  }
-  return [...seen].sort((left, right) => left.localeCompare(right));
-}
-function normalizeFieldCommands(rawCommands) {
-  const seen = /* @__PURE__ */ new Set();
-  const normalized = [];
-  for (const rawCommand of rawCommands ?? []) {
-    const command = rawCommand.trim().toLowerCase();
-    if (command.length === 0) {
-      continue;
-    }
-    if (!RUNTIME_FIELD_COMMAND_SET.has(command)) {
-      throw new Error(`Invalid field command "${rawCommand}". Allowed: ${RUNTIME_FIELD_COMMAND_VALUES.join(", ")}.`);
-    }
-    if (!seen.has(command)) {
-      seen.add(command);
-      normalized.push(command);
-    }
-  }
-  return rawCommands === void 0 || normalized.length === 0 ? [...DEFAULT_FIELD_COMMANDS] : normalized;
-}
-function normalizeAddFieldInput(raw) {
-  const key = normalizeFieldKey(raw.key);
-  if (key.length === 0) {
-    throw new Error("Field key must not be empty.");
-  }
-  if (BUILTIN_FIELD_KEYS.has(key)) {
-    throw new Error(`Cannot define custom field "${key}": it shadows a built-in field. Built-in fields are reserved.`);
-  }
-  const typeCandidate = typeof raw.type === "string" && raw.type.trim().length > 0 ? raw.type.trim().toLowerCase() : "string";
-  if (!RUNTIME_FIELD_TYPE_SET.has(typeCandidate)) {
-    throw new Error(`Invalid field type "${raw.type}". Allowed: ${RUNTIME_FIELD_TYPE_VALUES.join(", ")}.`);
-  }
-  const type = typeCandidate;
-  const commands = normalizeFieldCommands(raw.commands);
-  const cliFlagToken = normalizeCliToken(raw.cliFlag);
-  const cliFlag = cliFlagToken.length > 0 && cliFlagToken !== keyToDefaultCliFlag(key) ? cliFlagToken : void 0;
-  const effectiveFlag = cliFlag ?? keyToDefaultCliFlag(key);
-  const cliAliases = dedupeCliTokens(raw.aliases ?? [], effectiveFlag);
-  const description = raw.description?.trim();
-  return {
-    key,
-    type,
-    commands,
-    description: description && description.length > 0 ? description : void 0,
-    cliFlag,
-    cliAliases,
-    required: raw.required === true,
-    requiredOnCreate: raw.requiredOnCreate === true,
-    // allow_unset defaults to true (omitted) and is only persisted when an
-    // operator explicitly disables it with --no-allow-unset (allowUnset === false).
-    allowUnset: raw.allowUnset !== false,
-    requiredTypes: dedupeStringList(raw.requiredTypes)
-  };
-}
-function selectFieldsArray(parsed) {
-  if (Array.isArray(parsed)) {
-    return parsed;
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    return void 0;
-  }
-  const record = parsed;
-  if (Array.isArray(record.fields)) {
-    return record.fields;
-  }
-  if (Array.isArray(record.definitions)) {
-    return record.definitions;
-  }
-  return void 0;
-}
-function extractFieldDefinitions(parsed) {
-  const candidate = selectFieldsArray(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.key !== "string" || record.key.trim().length === 0) {
-      continue;
-    }
-    definitions.push(record);
-  }
-  return definitions;
-}
-function parseFieldsFile(raw) {
-  if (raw === null || raw === void 0 || raw.trim().length === 0) {
-    return { fields: [] };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error("schema/fields.json contains invalid JSON.");
-  }
-  return { fields: extractFieldDefinitions(parsed) };
-}
-function serializeFieldsFile(file) {
-  return `${JSON.stringify({ fields: file.fields }, null, 2)}
-`;
-}
-function upsertField(file, input) {
-  const existing = file.fields.find((definition) => normalizeFieldKey(definition.key) === input.key);
-  const replaced = existing !== void 0;
-  const fields = file.fields.filter((definition) => normalizeFieldKey(definition.key) !== input.key);
-  const next = {
-    ...existing,
-    key: input.key,
-    type: input.type,
-    commands: [...input.commands]
-  };
-  applyOptionalString(next, "description", input.description);
-  applyOptionalString(next, "cli_flag", input.cliFlag);
-  if (input.cliAliases.length > 0) {
-    next.cli_aliases = [...input.cliAliases];
-  } else {
-    delete next.cli_aliases;
-  }
-  applyBooleanFlag(next, "required", input.required);
-  applyBooleanFlag(next, "required_on_create", input.requiredOnCreate);
-  if (input.allowUnset === false) {
-    next.allow_unset = false;
-  } else {
-    delete next.allow_unset;
-  }
-  if (input.requiredTypes.length > 0) {
-    next.required_types = [...input.requiredTypes];
-  } else {
-    delete next.required_types;
-  }
-  fields.push(next);
-  fields.sort((left, right) => normalizeFieldKey(left.key).localeCompare(normalizeFieldKey(right.key)));
-  return {
-    file: { fields },
-    definition: next,
-    replaced
-  };
-}
-function removeField(file, key) {
-  const normalizedKey = normalizeFieldKey(key);
-  if (normalizedKey.length === 0) {
-    throw new Error("Field key must not be empty.");
-  }
-  const removed = [];
-  const fields = file.fields.filter((definition) => {
-    if (normalizeFieldKey(definition.key) === normalizedKey) {
-      removed.push(definition);
-      return false;
-    }
-    return true;
-  });
-  if (removed.length === 0) {
-    return { file: { fields }, removed: false };
-  }
-  return { file: { fields }, removed: true, definition: removed[0] };
-}
-function applyOptionalString(definition, key, value) {
-  const record = definition;
-  if (value !== void 0 && value.length > 0) {
-    record[key] = value;
-  } else {
-    delete record[key];
-  }
-}
-function applyBooleanFlag(definition, key, value) {
-  const record = definition;
-  if (value) {
-    record[key] = true;
-  } else {
-    delete record[key];
-  }
-}
-
-// dist/core/schema/type-presets.js
-var TYPE_PRESET_NAMES = ["agile", "ops", "research"];
-var TYPE_PRESET_DEFINITIONS = {
-  agile: [
-    {
-      name: "Story",
-      description: "User-facing outcome or capability slice expressed from a stakeholder perspective.",
-      defaultStatus: "open",
-      folder: "stories",
-      aliases: ["user-story"]
-    },
-    {
-      name: "Spike",
-      description: "Time-boxed investigation used to reduce uncertainty before implementation.",
-      defaultStatus: "open",
-      folder: "spikes",
-      aliases: ["research-spike"]
-    }
-  ],
-  ops: [
-    {
-      name: "Incident",
-      description: "Operational disruption, degradation, or support escalation with recovery tracking.",
-      defaultStatus: "open",
-      folder: "incidents",
-      aliases: ["outage"]
-    },
-    {
-      name: "Runbook",
-      description: "Repeatable operational procedure, diagnostic path, or response playbook.",
-      defaultStatus: "open",
-      folder: "runbooks",
-      aliases: ["playbook"]
-    }
-  ],
-  research: [
-    {
-      name: "Experiment",
-      description: "Validated-learning activity with hypothesis, method, and outcome tracking.",
-      defaultStatus: "open",
-      folder: "experiments",
-      aliases: ["study"]
-    },
-    {
-      name: "Hypothesis",
-      description: "Testable claim or assumption that should be supported, rejected, or refined.",
-      defaultStatus: "open",
-      folder: "hypotheses",
-      aliases: ["assumption"]
-    }
-  ]
-};
-function normalizeTypePresetName(rawValue) {
-  if (rawValue === void 0) {
-    return void 0;
-  }
-  const normalized = rawValue.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized.length === 0) {
-    throw new Error("Type preset name must not be empty.");
-  }
-  if (normalized === "agile" || normalized === "ops" || normalized === "research") {
-    return normalized;
-  }
-  throw new Error(`Invalid type preset "${rawValue}". Allowed: ${TYPE_PRESET_NAMES.join(", ")}.`);
-}
-function resolveTypePresetDefinitions(preset) {
-  return TYPE_PRESET_DEFINITIONS[preset].map((rawDefinition) => normalizeAddTypeInput(rawDefinition));
-}
-
-export {
-  BUILTIN_STATUS_IDS,
-  normalizeStatusToken,
-  normalizeAddStatusInput,
-  parseStatusDefsFile,
-  serializeStatusDefsFile,
-  upsertStatusDef,
-  removeStatusDef,
-  assertStatusTokensAvailable,
-  normalizeFieldKey,
-  normalizeAddFieldInput,
-  parseFieldsFile,
-  serializeFieldsFile,
-  upsertField,
-  removeField,
-  TYPE_PRESET_NAMES,
-  TYPE_PRESET_DEFINITIONS,
-  normalizeTypePresetName,
-  resolveTypePresetDefinitions
-};
-//# sourceMappingURL=chunk-ZAHXPXVY.js.map
-
-//# debugId=b091c012-afb7-5159-95d2-527f565dc5e7

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

@@ -1,121 +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]="d421445d-3cb5-5ecd-84ba-b8af7024405c")}catch(e){}}();
-import {
-  parseItemDocument,
-  serializeItemDocument
-} from "./chunk-HK72NWAD.js";
-import {
-  runActiveOnWriteHooks
-} from "./chunk-US3T3W5J.js";
-import {
-  TYPE_TO_FOLDER,
-  getItemFormatFromPath,
-  getItemPath,
-  readFileIfExists,
-  removeFileIfExists,
-  writeFileAtomic
-} from "./chunk-YD5FML7K.js";
-
-// dist/core/store/item-format-migration.js
-import fs from "node:fs/promises";
-import path from "node:path";
-function alternateItemFormat(_targetFormat) {
-  return "json_markdown";
-}
-function normalizeRelativePath(pmRoot, absolutePath) {
-  return path.relative(pmRoot, absolutePath).replaceAll("\\", "/");
-}
-function errorSummary(error) {
-  return String(error).replaceAll(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 120);
-}
-async function migrateItemFilesToFormat(pmRoot, targetFormat, op = "item_format:migrate", typeToFolder = TYPE_TO_FOLDER, schema) {
-  if (targetFormat !== "toon") {
-    throw new Error("Only toon item-format migration targets are supported. Markdown item files are legacy read-only input.");
-  }
-  const migratedIds = /* @__PURE__ */ new Set();
-  const removedPaths = /* @__PURE__ */ new Set();
-  const warnings = [];
-  let scanned = 0;
-  const alternateFormat = alternateItemFormat(targetFormat);
-  const typeEntries = Object.entries(typeToFolder);
-  for (const [itemType, folder] of typeEntries) {
-    const directoryPath = path.join(pmRoot, folder);
-    let files = [];
-    try {
-      files = await fs.readdir(directoryPath);
-    } catch {
-      continue;
-    }
-    const variantsById = /* @__PURE__ */ new Map();
-    for (const file of files) {
-      const absolutePath = path.join(directoryPath, file);
-      const itemFormat = getItemFormatFromPath(absolutePath);
-      if (!itemFormat) {
-        continue;
-      }
-      const extension = path.extname(file);
-      const itemId = file.slice(0, file.length - extension.length).trim();
-      if (itemId.length === 0) {
-        continue;
-      }
-      const entry = variantsById.get(itemId) ?? {};
-      entry[itemFormat] = absolutePath;
-      variantsById.set(itemId, entry);
-    }
-    const itemIds = [...variantsById.keys()].sort((left, right) => left.localeCompare(right));
-    for (const itemId of itemIds) {
-      const variants = variantsById.get(itemId);
-      scanned += 1;
-      const alternatePath = variants[alternateFormat];
-      if (!alternatePath) {
-        continue;
-      }
-      const sourcePath = variants[targetFormat] ?? alternatePath;
-      const sourceFormat = sourcePath === variants[targetFormat] ? targetFormat : alternateFormat;
-      try {
-        const sourceRaw = await fs.readFile(sourcePath, "utf8");
-        const parsedDocument = parseItemDocument(sourceRaw, {
-          format: sourceFormat,
-          schema,
-          onWarning: (warning) => warnings.push(`item_format_migration_parse_warning:${itemId}:${warning}`)
-        });
-        const targetPath = getItemPath(pmRoot, itemType, itemId, targetFormat, typeToFolder);
-        const serializedTarget = serializeItemDocument(parsedDocument, { format: targetFormat, schema });
-        const existingTargetRaw = await readFileIfExists(targetPath);
-        if (existingTargetRaw !== serializedTarget) {
-          await writeFileAtomic(targetPath, serializedTarget);
-          warnings.push(...await runActiveOnWriteHooks({
-            path: targetPath,
-            scope: "project",
-            op
-          }));
-          migratedIds.add(itemId);
-        }
-        await removeFileIfExists(alternatePath);
-        removedPaths.add(normalizeRelativePath(pmRoot, alternatePath));
-        warnings.push(...await runActiveOnWriteHooks({
-          path: alternatePath,
-          scope: "project",
-          op: `${op}:remove`
-        }));
-        migratedIds.add(itemId);
-      } catch (error) {
-        warnings.push(`item_format_migration_skipped:${normalizeRelativePath(pmRoot, sourcePath)}:${errorSummary(error)}`);
-      }
-    }
-  }
-  return {
-    target_format: targetFormat,
-    scanned,
-    migrated: [...migratedIds].sort((left, right) => left.localeCompare(right)),
-    removed: [...removedPaths].sort((left, right) => left.localeCompare(right)),
-    warnings
-  };
-}
-
-export {
-  migrateItemFilesToFormat
-};
-//# sourceMappingURL=chunk-ZCJAA3JK.js.map
-
-//# debugId=d421445d-3cb5-5ecd-84ba-b8af7024405c