@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,121 @@
+
+!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-G24G7ZAV.js";
+import {
+  runActiveOnWriteHooks
+} from "./chunk-E3SZTQ4K.js";
+import {
+  TYPE_TO_FOLDER,
+  getItemFormatFromPath,
+  getItemPath,
+  readFileIfExists,
+  removeFileIfExists,
+  writeFileAtomic
+} from "./chunk-57NWPFF2.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-F3K4JGFD.js.map
+
+//# debugId=d421445d-3cb5-5ecd-84ba-b8af7024405c

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

@@ -0,0 +1,231 @@
+import {
+  PmCliError
+} from "./chunk-SHQY2IDC.js";
+import {
+  evictOldestMemoEntries
+} from "./chunk-7C2O74AE.js";
+import {
+  EXIT_CODE
+} from "./chunk-LK6XLOGP.js";
+
+// dist/core/shared/time.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] = "e10e1e6b-1d12-59cc-86e8-3e9c6415782a");
+  } catch (e2) {
+  }
+})();
+var RELATIVE_DEADLINE = /^([+-]?)(\d+)([hdwm])$/i;
+var COMPOUND_RELATIVE_DEADLINE = /^[+-]?\d+[hdwm](?:[+-]\d+[hdwm])+$/i;
+var COMPACT_DATE = /^(\d{4})(\d{2})(\d{2})$/;
+var COMPACT_DATETIME = /^(\d{4})(\d{2})(\d{2})(?:[T\s]?)(\d{2})(\d{2})(\d{2})?([.,]\d{1,3})?(Z|[+-]\d{2}:?\d{2})?$/i;
+var HYPHEN_TIME = /^(\d{4}-\d{2}-\d{2})[T\s](\d{2})-(\d{2})(?:-(\d{2}))?([.,]\d{1,3})?(Z|[+-]\d{2}:?\d{2})?$/i;
+var COMPACT_TIME = /^(\d{4}-\d{2}-\d{2})[T\s](\d{2})(\d{2})(\d{2})?([.,]\d{1,3})?(Z|[+-]\d{2}:?\d{2})?$/i;
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isTimestampLiteral(input) {
+  return Number.isFinite(Date.parse(input));
+}
+var TIMESTAMP_PARSE_MEMO_MAX_ENTRIES = 1e4;
+var timestampParseMemo = /* @__PURE__ */ new Map();
+function parseTimestampMsMemoized(value) {
+  const memoized = timestampParseMemo.get(value);
+  if (memoized !== void 0) {
+    return memoized;
+  }
+  const parsed = Date.parse(value);
+  if (timestampParseMemo.size >= TIMESTAMP_PARSE_MEMO_MAX_ENTRIES) {
+    evictOldestMemoEntries(timestampParseMemo);
+  }
+  timestampParseMemo.set(value, parsed);
+  return parsed;
+}
+function compareTimestampStrings(left, right) {
+  const leftMs = parseTimestampMsMemoized(left);
+  const rightMs = parseTimestampMsMemoized(right);
+  if (Number.isFinite(leftMs) && Number.isFinite(rightMs) && leftMs !== rightMs) {
+    return leftMs - rightMs;
+  }
+  return left.localeCompare(right);
+}
+function normalizeFraction(raw) {
+  if (!raw)
+    return "";
+  const digits = raw.slice(1);
+  return `.${digits.padEnd(3, "0").slice(0, 3)}`;
+}
+function normalizeOffset(raw) {
+  if (!raw)
+    return "";
+  if (raw.toUpperCase() === "Z")
+    return "Z";
+  const compact = /^([+-]\d{2})(\d{2})$/.exec(raw);
+  if (compact)
+    return `${compact[1]}:${compact[2]}`;
+  return raw;
+}
+function pushTimestampCandidate(candidates, input, value) {
+  if (!value)
+    return;
+  if (value === input)
+    return;
+  if (candidates.includes(value))
+    return;
+  candidates.push(value);
+}
+function normalizeTimestampCandidates(input) {
+  const candidates = [];
+  const push = (value) => pushTimestampCandidate(candidates, input, value);
+  const compactDate = COMPACT_DATE.exec(input);
+  if (compactDate) {
+    const [, year, month, day] = compactDate;
+    push(`${year}-${month}-${day}`);
+  }
+  const compactDateTime = COMPACT_DATETIME.exec(input);
+  if (compactDateTime) {
+    const [, year, month, day, hour, minute, secondRaw, fractionRaw, offsetRaw] = compactDateTime;
+    const second = secondRaw ? `:${secondRaw}` : "";
+    push(`${year}-${month}-${day}T${hour}:${minute}${second}${normalizeFraction(fractionRaw)}${normalizeOffset(offsetRaw)}`);
+  }
+  const hyphenTime = HYPHEN_TIME.exec(input);
+  if (hyphenTime) {
+    const [, datePart, hour, minute, secondRaw, fractionRaw, offsetRaw] = hyphenTime;
+    const second = secondRaw ? `:${secondRaw}` : "";
+    push(`${datePart}T${hour}:${minute}${second}${normalizeFraction(fractionRaw)}${normalizeOffset(offsetRaw)}`);
+  }
+  const compactTime = COMPACT_TIME.exec(input);
+  if (compactTime) {
+    const [, datePart, hour, minute, secondRaw, fractionRaw, offsetRaw] = compactTime;
+    const second = secondRaw ? `:${secondRaw}` : "";
+    push(`${datePart}T${hour}:${minute}${second}${normalizeFraction(fractionRaw)}${normalizeOffset(offsetRaw)}`);
+  }
+  const datePrefixLength = 10;
+  const datePrefix = input.slice(0, datePrefixLength);
+  if (isHyphenDatePrefix(datePrefix)) {
+    let index = datePrefixLength;
+    while (index < input.length && isWhitespaceCharacter(input[index])) {
+      index += 1;
+    }
+    if (index < input.length) {
+      push(`${datePrefix}T${input.slice(index)}`);
+    }
+  }
+  return candidates;
+}
+function parseTimestampWithFallbacks(input) {
+  const direct = Date.parse(input);
+  if (Number.isFinite(direct))
+    return direct;
+  for (const candidate of normalizeTimestampCandidates(input)) {
+    const parsed = Date.parse(candidate);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return Number.NaN;
+}
+function isHyphenDatePrefix(value) {
+  if (value.length !== 10) {
+    return false;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (index === 4 || index === 7) {
+      if (character !== "-") {
+        return false;
+      }
+      continue;
+    }
+    const code = character.charCodeAt(0);
+    if (code < 48 || code > 57) {
+      return false;
+    }
+  }
+  return true;
+}
+function isWhitespaceCharacter(character) {
+  if (!character) {
+    return false;
+  }
+  return character === " " || character === "	" || character === "\n" || character === "\r" || character === "\f" || character === "\v";
+}
+function daysInUtcMonth(year, monthIndex) {
+  return new Date(Date.UTC(year, monthIndex + 1, 0)).getUTCDate();
+}
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var LEADING_HYPHEN_DATE = /^(\d{4})-(\d{2})-(\d{2})/;
+var LEADING_COMPACT_DATE = /^(\d{4})(\d{2})(\d{2})(?:[T ]?\d{2}|$)/;
+function assertRealCalendarDate(originalInput, trimmed, fieldLabel) {
+  const match = LEADING_HYPHEN_DATE.exec(trimmed) ?? LEADING_COMPACT_DATE.exec(trimmed);
+  if (!match) {
+    return;
+  }
+  const year = Number.parseInt(match[1], 10);
+  const month = Number.parseInt(match[2], 10);
+  const day = Number.parseInt(match[3], 10);
+  const label = fieldLabel?.trim() || "deadline";
+  if (month < 1 || month > 12) {
+    throw new PmCliError(`Invalid ${label} value "${originalInput}". Month "${match[2]}" is out of range \u2014 use a month between 01 and 12.`, EXIT_CODE.USAGE);
+  }
+  const maxDay = daysInUtcMonth(year, month - 1);
+  if (day < 1 || day > maxDay) {
+    throw new PmCliError(`Invalid ${label} value "${originalInput}". ${MONTH_NAMES[month - 1]} ${year} has ${maxDay} days, so day "${match[3]}" does not exist. Use a real YYYY-MM-DD calendar date.`, EXIT_CODE.USAGE);
+  }
+}
+function addUtcMonths(now, amount) {
+  const result = new Date(now.getTime());
+  const startDay = result.getUTCDate();
+  const targetMonthIndex = result.getUTCMonth() + amount;
+  const targetYear = result.getUTCFullYear() + Math.floor(targetMonthIndex / 12);
+  const targetMonth = (targetMonthIndex % 12 + 12) % 12;
+  const day = Math.min(startDay, daysInUtcMonth(targetYear, targetMonth));
+  result.setUTCFullYear(targetYear, targetMonth, day);
+  return result;
+}
+function resolveIsoOrRelative(input, now = /* @__PURE__ */ new Date(), fieldLabel = "deadline") {
+  const trimmed = input.trim();
+  if (trimmed.toLowerCase() === "now") {
+    return now.toISOString();
+  }
+  const relative = RELATIVE_DEADLINE.exec(trimmed);
+  if (relative) {
+    const sign = relative[1] === "-" ? -1 : 1;
+    const amount = Number.parseInt(relative[2], 10) * sign;
+    const unit = relative[3].toLowerCase();
+    if (unit === "m") {
+      return addUtcMonths(now, amount).toISOString();
+    }
+    const msPerUnit = unit === "h" ? 60 * 60 * 1e3 : unit === "d" ? 24 * 60 * 60 * 1e3 : 7 * 24 * 60 * 60 * 1e3;
+    return new Date(now.getTime() + amount * msPerUnit).toISOString();
+  }
+  assertRealCalendarDate(input, trimmed, fieldLabel);
+  const timestamp = parseTimestampWithFallbacks(trimmed);
+  if (!Number.isFinite(timestamp)) {
+    const normalizedLabel = fieldLabel.trim().length > 0 ? fieldLabel.trim() : "deadline";
+    const guidance = COMPOUND_RELATIVE_DEADLINE.test(trimmed) ? "Compound relative expressions like +3d+1h are not supported; use a single relative token (for example +3d) or an ISO/date string." : 'Use ISO/date string input, "now", or relative +6h/-6h/+1d/-1d/+2w/-2w/+6m/-6m.';
+    throw new PmCliError(`Invalid ${normalizedLabel} value "${input}". ${guidance}`, EXIT_CODE.USAGE);
+  }
+  return new Date(timestamp).toISOString();
+}
+
+export {
+  nowIso,
+  isTimestampLiteral,
+  compareTimestampStrings,
+  resolveIsoOrRelative
+};
+//# sourceMappingURL=chunk-FLZSGSQR.js.map