@unbrained/pm-cli 2026.6.7 → 2026.6.9

package/dist/cli-bundle/chunks/{chunk-HV5SSZXF.js → chunk-4TJWRPIH.js}

@@ -1,7 +1,7 @@
 import {
   EXIT_CODE,
   PmCliError
-} from "./chunk-UJUT6AHZ.js";
+} from "./chunk-C72IQIBT.js";
 
 // dist/core/item/parse.js
 !(function() {
@@ -338,4 +338,4 @@ export {
   createStdinTokenResolver,
   parseOptionalNumber
 };
-//# sourceMappingURL=chunk-HV5SSZXF.js.map
+//# sourceMappingURL=chunk-4TJWRPIH.js.map

package/dist/cli-bundle/chunks/{chunk-UYQ7HXH4.js → chunk-5ATRWEZO.js}

@@ -3,7 +3,7 @@
 import {
   compareTimestampStrings,
   isTimestampLiteral
-} from "./chunk-B2KZGPM2.js";
+} from "./chunk-PW7C262O.js";
 import {
   CONFIDENCE_TEXT_VALUES,
   EXIT_CODE,
@@ -19,7 +19,7 @@ import {
   resolveRuntimeStatusRegistry,
   runtimeFieldOptionTarget,
   weekdayOrderIndex
-} from "./chunk-X4IZKYHP.js";
+} from "./chunk-5JF76OJF.js";
 
 // dist/core/schema/runtime-field-values.js
 function toCamelToken(value) {
@@ -1324,6 +1324,6 @@ export {
   serializeItemDocument,
   canonicalDocument
 };
-//# sourceMappingURL=chunk-UYQ7HXH4.js.map
+//# sourceMappingURL=chunk-5ATRWEZO.js.map
 
 //# debugId=8e6380db-298c-5343-b79e-9939444e8ad2

package/dist/cli-bundle/chunks/{chunk-X4IZKYHP.js → chunk-5JF76OJF.js}

@@ -1,7 +1,7 @@
 // dist/core/fs/fs-utils.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]="bcdcd911-483c-5908-892f-1986b07ffaae")}catch(e){}}();
-import fs from "node:fs/promises";
+!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]="fb874b51-e242-55eb-aa06-2173035fe85d")}catch(e){}}();
+import * as fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
 async function ensureDir(dirPath) {
@@ -30,7 +30,26 @@ async function writeFileAtomic(targetPath, contents) {
   await ensureDir(dirPath);
   const tempPath = path.join(dirPath, `.${path.basename(targetPath)}.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString("hex")}.tmp`);
   await fs.writeFile(tempPath, contents, "utf8");
-  await fs.rename(tempPath, targetPath);
+  try {
+    await fs.rename(tempPath, targetPath);
+  } catch (error) {
+    if (isErrno(error, "EXDEV")) {
+      try {
+        await fs.copyFile(tempPath, targetPath);
+      } finally {
+        try {
+          await fs.unlink(tempPath);
+        } catch {
+        }
+      }
+      return;
+    }
+    try {
+      await fs.unlink(tempPath);
+    } catch {
+    }
+    throw error;
+  }
 }
 async function appendLineAtomic(targetPath, line) {
   const dirPath = path.dirname(targetPath);
@@ -101,6 +120,18 @@ function resolvePmPackageRootFromModule(metaUrl, fallbackRelativeSegments = [])
   }
   return path3.resolve(path3.dirname(modulePath), ...fallbackRelativeSegments);
 }
+function resolvePmCliVersion(metaUrl, fallbackRelativeSegments = []) {
+  try {
+    const packageJsonPath = path3.join(resolvePmPackageRootFromModule(metaUrl, fallbackRelativeSegments), "package.json");
+    if (!fs2.existsSync(packageJsonPath)) {
+      return void 0;
+    }
+    const parsed = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+    return typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // dist/core/extensions/extension-types.js
 var KNOWN_EXTENSION_CAPABILITIES = [
@@ -601,7 +632,14 @@ function resolvePmRoot(cwd, cliPath) {
   const envPath = process.env.PM_PATH;
   const explicitPath = cliPath?.trim() || envPath?.trim();
   if (explicitPath) {
-    return path4.resolve(cwd, explicitPath);
+    const resolved = path4.resolve(cwd, explicitPath);
+    if (!pathExists2(getSettingsPath(resolved))) {
+      const nestedRoot = path4.join(resolved, PM_DIRNAME);
+      if (pathExists2(getSettingsPath(nestedRoot))) {
+        return nestedRoot;
+      }
+    }
+    return resolved;
   }
   const discoveredRoot = discoverPmRootFromAncestors(cwd);
   if (discoveredRoot) {
@@ -1366,6 +1404,128 @@ import fs3 from "node:fs/promises";
 import path5 from "node:path";
 import { pathToFileURL } from "node:url";
 
+// dist/core/extensions/flag-value-types.js
+var FLAG_VALUE_KIND_BY_ALIAS = Object.freeze({
+  string: "string",
+  number: "number",
+  int: "number",
+  integer: "number",
+  float: "number",
+  boolean: "boolean",
+  bool: "boolean"
+});
+function resolveFlagValueKind(raw) {
+  if (typeof raw !== "string") {
+    return null;
+  }
+  return FLAG_VALUE_KIND_BY_ALIAS[raw.trim().toLowerCase()] ?? null;
+}
+function flattenFlagListValue(value) {
+  const entries = [];
+  const collect = (input) => {
+    if (Array.isArray(input)) {
+      for (const item of input) {
+        collect(item);
+      }
+      return;
+    }
+    if (typeof input === "string") {
+      for (const part of input.split(",")) {
+        const trimmed = part.trim();
+        if (trimmed.length > 0) {
+          entries.push(trimmed);
+        }
+      }
+      return;
+    }
+    if (input !== void 0 && input !== null) {
+      entries.push(input);
+    }
+  };
+  collect(value);
+  return entries;
+}
+function isFlagDefaultValueCoercible(value, kind) {
+  if (kind === "string") {
+    return true;
+  }
+  if (kind === "number") {
+    if (typeof value === "number") {
+      return Number.isFinite(value);
+    }
+    return typeof value === "string" && value.trim().length > 0 && Number.isFinite(Number(value));
+  }
+  if (typeof value === "boolean") {
+    return true;
+  }
+  return typeof value === "string" && ["true", "false", "1", "0"].includes(value.trim().toLowerCase());
+}
+
+// dist/core/shared/levenshtein.js
+function levenshteinDistanceWithinLimit(left, right, limit) {
+  if (left === right) {
+    return 0;
+  }
+  if (Math.abs(left.length - right.length) > limit) {
+    return null;
+  }
+  const width = right.length + 1;
+  const beforePrevious = new Array(width);
+  const previous = new Array(width);
+  const current = new Array(width);
+  for (let column = 0; column < width; column += 1) {
+    beforePrevious[column] = 0;
+    previous[column] = column;
+  }
+  for (let row = 1; row <= left.length; row += 1) {
+    current[0] = row;
+    let rowMin = current[0];
+    for (let column = 1; column <= right.length; column += 1) {
+      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+      const substitution = previous[column - 1] + cost;
+      const insertion = current[column - 1] + 1;
+      const deletion = previous[column] + 1;
+      let candidate = Math.min(substitution, insertion, deletion);
+      if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) {
+        candidate = Math.min(candidate, beforePrevious[column - 2] + 1);
+      }
+      current[column] = candidate;
+      if (candidate < rowMin) {
+        rowMin = candidate;
+      }
+    }
+    if (rowMin > limit) {
+      return null;
+    }
+    for (let column = 0; column < width; column += 1) {
+      beforePrevious[column] = previous[column];
+      previous[column] = current[column];
+    }
+  }
+  const result = previous[right.length];
+  return result <= limit ? result : null;
+}
+
+// dist/core/extensions/item-field-types.js
+var KNOWN_ITEM_FIELD_TYPES = ["string", "number", "boolean", "array", "object"];
+function normalizeItemFieldType(value) {
+  const normalized = value.trim().toLowerCase();
+  return KNOWN_ITEM_FIELD_TYPES.includes(normalized) ? normalized : null;
+}
+function suggestKnownItemFieldType(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized.length === 0) {
+    return null;
+  }
+  const limit = Math.max(1, Math.floor(normalized.length * 0.34));
+  for (const candidate of KNOWN_ITEM_FIELD_TYPES) {
+    if (levenshteinDistanceWithinLimit(normalized, candidate, limit) !== null) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
 // dist/core/extensions/extension-policy.js
 function normalizePolicyName(value) {
   if (typeof value !== "string") {
@@ -2497,21 +2657,28 @@ async function loadExtensions(options) {
     failed
   };
 }
+function toActivatableExtension(source) {
+  const activate = source.activate;
+  const activatable = {
+    activate: activate.bind(source)
+  };
+  if (typeof source.deactivate === "function") {
+    const deactivate = source.deactivate;
+    activatable.deactivate = deactivate.bind(source);
+  }
+  return activatable;
+}
 function resolveActivatableExtension(module) {
   const moduleRecord = asRecordLoose(module);
   if (!moduleRecord) {
     return null;
   }
   if (typeof moduleRecord.activate === "function") {
-    return {
-      activate: moduleRecord.activate
-    };
+    return toActivatableExtension(moduleRecord);
   }
   const defaultExport = asRecordLoose(moduleRecord.default);
   if (defaultExport && typeof defaultExport.activate === "function") {
-    return {
-      activate: defaultExport.activate
-    };
+    return toActivatableExtension(defaultExport);
   }
   return null;
 }
@@ -2638,6 +2805,25 @@ function assertOptionalStringField(name, value) {
     throw new TypeError(`${name} must be a non-empty string when provided`);
   }
 }
+function isFlagDefaultScalar(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function assertOptionalFlagDefaultField(name, value) {
+  if (value === void 0) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries()) {
+      if (!isFlagDefaultScalar(item)) {
+        throw new TypeError(`${name}[${index}] must be a string, number, or boolean`);
+      }
+    }
+    return;
+  }
+  if (!isFlagDefaultScalar(value)) {
+    throw new TypeError(`${name} must be a string, number, or boolean, or an array of these when provided`);
+  }
+}
 function assertOptionalStringArrayField(name, value) {
   if (value === void 0) {
     return;
@@ -2751,6 +2937,32 @@ function validateFlagDefinitions(flags) {
     assertOptionalBooleanField(`registerFlags flags[${index}].required`, record.required);
     assertOptionalBooleanField(`registerFlags flags[${index}].enabled`, record.enabled);
     assertOptionalBooleanField(`registerFlags flags[${index}].visible`, record.visible);
+    assertOptionalBooleanField(`registerFlags flags[${index}].list`, record.list);
+    assertOptionalFlagDefaultField(`registerFlags flags[${index}].default`, record.default);
+    if (Array.isArray(record.default) && record.list !== true) {
+      throw new TypeError(`registerFlags flags[${index}].default cannot be an array unless list is true.`);
+    }
+    assertFlagValueTypeAndDefault(`registerFlags flags[${index}]`, record);
+  }
+}
+function assertFlagValueTypeAndDefault(label, record) {
+  const declaredType = (typeof record.value_type === "string" ? record.value_type : void 0) ?? (typeof record.type === "string" ? record.type : void 0);
+  if (declaredType === void 0) {
+    return;
+  }
+  const kind = resolveFlagValueKind(declaredType);
+  if (kind === null) {
+    throw new TypeError(`${label} value_type "${declaredType}" is not a known flag value type (expected one of: string, number, boolean).`);
+  }
+  if (record.default === void 0) {
+    return;
+  }
+  const defaults = record.list === true ? flattenFlagListValue(record.default) : [record.default];
+  for (const [defaultIndex, defaultValue] of defaults.entries()) {
+    if (!isFlagDefaultValueCoercible(defaultValue, kind)) {
+      const suffix = defaults.length > 1 ? `default[${defaultIndex}]` : "default";
+      throw new TypeError(`${label}.${suffix} (${JSON.stringify(defaultValue)}) is not coercible to ${kind}.`);
+    }
   }
 }
 function validateItemFieldDefinitions(fields) {
@@ -2760,7 +2972,12 @@ function validateItemFieldDefinitions(fields) {
   for (const [index, raw] of fields.entries()) {
     const record = asRegistrationRecord(`registerItemFields fields[${index}]`, raw);
     assertNonEmptyString(`registerItemFields fields[${index}].name`, record.name);
-    assertNonEmptyString(`registerItemFields fields[${index}].type`, record.type);
+    const fieldType = assertNonEmptyString(`registerItemFields fields[${index}].type`, record.type);
+    if (normalizeItemFieldType(fieldType) === null) {
+      const suggestion = suggestKnownItemFieldType(fieldType);
+      const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
+      throw new TypeError(`registerItemFields fields[${index}].type "${fieldType}" is not a known field type (expected one of: ${KNOWN_ITEM_FIELD_TYPES.join(", ")}).${hint}`);
+    }
     assertOptionalBooleanField(`registerItemFields fields[${index}].optional`, record.optional);
   }
 }
@@ -2858,6 +3075,15 @@ function assertExtensionCapability(extension, capability, method) {
   }
 }
 function createExtensionApi(extension, hooks, commands, parsers, preflight, services, renderers, registrations, activationWarnings, policy) {
+  const selfIdentity = Object.freeze({
+    name: extension.name,
+    layer: extension.layer,
+    version: extension.version,
+    capabilities: Object.freeze((extension.capabilities ?? []).filter((capability) => KNOWN_EXTENSION_CAPABILITIES.includes(capability))),
+    pm_min_version: extension.pm_min_version,
+    pm_max_version: extension.pm_max_version,
+    source_package: extension.source_package
+  });
   const extensionRef = {
     layer: extension.layer,
     name: extension.name,
@@ -3299,6 +3525,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     });
   };
   return {
+    extension: selfIdentity,
     registerCommand,
     registerParser,
     registerPreflight,
@@ -4227,10 +4454,7 @@ async function loadRuntimeSchemaFromOptionalFiles(pmRoot, schema) {
   const statusFilePath = filePathForSchemaSection(pmRoot, normalizedSchema.files.statuses, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.statuses);
   const fieldsFilePath = filePathForSchemaSection(pmRoot, normalizedSchema.files.fields, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.fields);
   const workflowsFilePath = filePathForSchemaSection(pmRoot, normalizedSchema.files.workflows, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.workflows);
-  const typeDefinitionsFromFile = /* @__PURE__ */ (() => {
-    return void 0;
-  })();
-  let loadedTypeDefinitions = typeDefinitionsFromFile;
+  let loadedTypeDefinitions;
   let loadedStatuses;
   let loadedFields;
   let loadedWorkflow;
@@ -5701,6 +5925,7 @@ export {
   removeFileIfExists,
   isPathWithinDirectory,
   resolvePmPackageRootFromModule,
+  resolvePmCliVersion,
   KNOWN_EXTENSION_CAPABILITIES,
   EXTENSION_CAPABILITY_CONTRACT,
   KNOWN_EXTENSION_POLICY_MODES,
@@ -5746,6 +5971,10 @@ export {
   coercePositiveInteger,
   coerceNumberInRange,
   asRecordOrNull,
+  resolveFlagValueKind,
+  flattenFlagListValue,
+  levenshteinDistanceWithinLimit,
+  normalizeItemFieldType,
   parseUnknownExtensionCapabilityWarning,
   parseLegacyExtensionCapabilityAliasWarning,
   createEmptyExtensionRegistrationRegistry,
@@ -5823,6 +6052,6 @@ export {
   readSettings,
   writeSettings
 };
-//# sourceMappingURL=chunk-X4IZKYHP.js.map
+//# sourceMappingURL=chunk-5JF76OJF.js.map
 
-//# debugId=bcdcd911-483c-5908-892f-1986b07ffaae
+//# debugId=fb874b51-e242-55eb-aa06-2173035fe85d