@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,634 +0,0 @@
-import {
-  normalizeStatusToken
-} from "./chunk-CZVISY5A.js";
-import {
-  TYPE_PRESET_DEFINITIONS,
-  normalizeAddFieldInput,
-  normalizeAddStatusInput
-} from "./chunk-Y76TWC45.js";
-import {
-  parseNestedSettingValue,
-  resolveNestedSettingDescriptor
-} from "./chunk-VUHVWI4C.js";
-import {
-  normalizeAddTypeInput
-} from "./chunk-T35XLYZF.js";
-import {
-  BUILTIN_ITEM_TYPE_VALUES,
-  DEFAULT_RUNTIME_STATUS_DEFINITIONS,
-  toErrorMessage
-} from "./chunk-5VVUKE3U.js";
-
-// dist/core/profile/profile-presets.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] = "6353f7f8-4aed-512c-8f04-a61eef52a775");
-  } catch (e2) {
-  }
-})();
-var PROFILE_NAMES = ["agile", "ops", "research"];
-var BUILTIN_PROFILES = {
-  agile: {
-    name: "agile",
-    title: "Agile delivery",
-    summary: "Story/Spike delivery with a review stage, story points, and acceptance ownership.",
-    types: TYPE_PRESET_DEFINITIONS.agile,
-    statuses: [
-      {
-        id: "review",
-        roles: ["active"],
-        aliases: ["in-review"],
-        description: "Work is implementation-complete and awaiting peer review."
-      }
-    ],
-    fields: [
-      {
-        key: "story_points",
-        type: "number",
-        commands: ["create", "update", "list"],
-        description: "Relative estimation size for a story or spike.",
-        aliases: ["points"]
-      },
-      {
-        key: "acceptance_owner",
-        type: "string",
-        commands: ["create", "update", "list"],
-        description: "Stakeholder accountable for accepting the delivered story.",
-        aliases: ["acceptor"]
-      }
-    ],
-    workflows: [
-      {
-        type: "Story",
-        allowed_transitions: [
-          ["open", "in_progress"],
-          ["in_progress", "review"],
-          ["review", "in_progress"],
-          ["review", "closed"],
-          ["in_progress", "blocked"],
-          ["blocked", "in_progress"]
-        ]
-      }
-    ],
-    config: [
-      { key: "search_provider", value: "bm25", summary: "Offline BM25 lexical search works without an embedding service." },
-      { key: "search_max_results", value: "20", summary: "Sprint-sized result cap for quick triage." }
-    ],
-    templates: [
-      {
-        name: "story",
-        options: {
-          type: "Story",
-          priority: "2",
-          tags: "story",
-          acceptanceCriteria: "Story delivers the stated user outcome with tests and docs updated.",
-          body: "## As a\n\n## I want\n\n## So that\n\n## Acceptance\n- [ ] \n"
-        }
-      }
-    ],
-    packages: [
-      { spec: "templates", reason: "Reusable create templates for recurring story shapes." },
-      { spec: "calendar", reason: "Sprint and iteration scheduling views." },
-      { spec: "search-advanced", reason: "Richer retrieval as the backlog grows." }
-    ]
-  },
-  ops: {
-    name: "ops",
-    title: "Operations",
-    summary: "Incident/Runbook response with mitigation and monitoring stages, severity, and service fields.",
-    types: TYPE_PRESET_DEFINITIONS.ops,
-    statuses: [
-      {
-        id: "mitigating",
-        roles: ["active"],
-        aliases: ["mitigation"],
-        description: "Active mitigation is underway to restore service."
-      },
-      {
-        id: "monitoring",
-        roles: ["active"],
-        aliases: ["observing"],
-        description: "Mitigation applied; monitoring for recurrence before closure."
-      }
-    ],
-    fields: [
-      {
-        key: "severity",
-        type: "string",
-        commands: ["create", "update", "list"],
-        description: "Incident severity classification (e.g. sev1, sev2, sev3).",
-        aliases: ["sev"]
-      },
-      {
-        key: "service",
-        type: "string",
-        commands: ["create", "update", "list"],
-        description: "Primary affected service or component."
-      }
-    ],
-    workflows: [
-      {
-        type: "Incident",
-        allowed_transitions: [
-          ["open", "mitigating"],
-          ["mitigating", "monitoring"],
-          ["monitoring", "mitigating"],
-          ["monitoring", "closed"],
-          ["mitigating", "blocked"],
-          ["blocked", "mitigating"]
-        ]
-      }
-    ],
-    config: [
-      { key: "search_provider", value: "bm25", summary: "Offline BM25 lexical search for fast incident lookup." },
-      { key: "search_max_results", value: "25", summary: "Wider result cap to surface related incidents and runbooks." }
-    ],
-    templates: [
-      {
-        name: "incident",
-        options: {
-          type: "Incident",
-          priority: "1",
-          tags: "incident",
-          acceptanceCriteria: "Service restored, root cause documented, and follow-ups filed.",
-          body: "## Impact\n\n## Timeline\n\n## Root cause\n\n## Mitigation\n\n## Follow-ups\n"
-        }
-      }
-    ],
-    packages: [
-      { spec: "lifecycle-hooks", reason: "Automate transitions and notifications on incident state changes." },
-      { spec: "governance-audit", reason: "Audit incident metadata completeness and closure quality." },
-      { spec: "calendar", reason: "On-call and follow-up scheduling." }
-    ]
-  },
-  research: {
-    name: "research",
-    title: "Research",
-    summary: "Experiment/Hypothesis investigation with an analysis stage, hypothesis, and method fields.",
-    types: TYPE_PRESET_DEFINITIONS.research,
-    statuses: [
-      {
-        id: "analyzing",
-        roles: ["active"],
-        aliases: ["analysis"],
-        description: "Data collected; analysis and synthesis in progress."
-      }
-    ],
-    fields: [
-      {
-        key: "hypothesis",
-        type: "string",
-        commands: ["create", "update"],
-        description: "The testable claim the experiment evaluates."
-      },
-      {
-        key: "method",
-        type: "string",
-        commands: ["create", "update", "list"],
-        description: "Experimental method or protocol used to evaluate the hypothesis.",
-        aliases: ["protocol"]
-      }
-    ],
-    workflows: [
-      {
-        type: "Experiment",
-        allowed_transitions: [
-          ["open", "in_progress"],
-          ["in_progress", "analyzing"],
-          ["analyzing", "in_progress"],
-          ["analyzing", "closed"],
-          ["in_progress", "blocked"],
-          ["blocked", "in_progress"]
-        ]
-      }
-    ],
-    config: [
-      { key: "search_provider", value: "bm25", summary: "Offline BM25 lexical search across the research corpus." },
-      { key: "search_max_results", value: "50", summary: "Broader recall cap for literature and prior-experiment discovery." }
-    ],
-    templates: [
-      {
-        name: "experiment",
-        options: {
-          type: "Experiment",
-          priority: "2",
-          tags: "experiment",
-          acceptanceCriteria: "Hypothesis is supported, rejected, or refined with recorded evidence.",
-          body: "## Hypothesis\n\n## Method\n\n## Results\n\n## Conclusion\n"
-        }
-      }
-    ],
-    packages: [
-      { spec: "search-advanced", reason: "Semantic retrieval over experiments and findings." },
-      { spec: "templates", reason: "Consistent experiment and hypothesis scaffolds." },
-      { spec: "beads", reason: "Import structured prior work into the tracker." }
-    ]
-  }
-};
-function normalizeProfileName(rawValue) {
-  if (rawValue === void 0) {
-    return void 0;
-  }
-  const normalized = normalizeProfileLookupKey(rawValue);
-  if (normalized.length === 0) {
-    throw new Error("Profile name must not be empty.");
-  }
-  if (PROFILE_NAMES.includes(normalized)) {
-    return normalized;
-  }
-  throw new Error(`Invalid profile "${rawValue}". Allowed: ${PROFILE_NAMES.join(", ")}.`);
-}
-function resolveProfile(rawValue) {
-  const name = normalizeProfileName(rawValue);
-  if (name === void 0) {
-    throw new Error(`Profile name is required. Allowed: ${PROFILE_NAMES.join(", ")}.`);
-  }
-  return BUILTIN_PROFILES[name];
-}
-function listProfiles() {
-  return PROFILE_NAMES.map((name) => BUILTIN_PROFILES[name]);
-}
-function normalizeProfileLookupKey(rawValue) {
-  return rawValue.trim().toLowerCase().replaceAll("-", "_");
-}
-function formatAvailableProfileNames(profiles) {
-  return profiles.map((entry) => entry.definition.name).join(", ");
-}
-function resolveProfileCatalog(contributions = []) {
-  const profiles = PROFILE_NAMES.map((name) => ({
-    definition: BUILTIN_PROFILES[name],
-    source: "builtin"
-  }));
-  const builtinKeys = new Set(PROFILE_NAMES.map((name) => normalizeProfileLookupKey(name)));
-  const seen = new Set(builtinKeys);
-  const warnings = [];
-  for (const contribution of contributions) {
-    const key = normalizeProfileLookupKey(contribution.profile.name);
-    if (builtinKeys.has(key)) {
-      warnings.push(`Extension "${contribution.name}" profile "${contribution.profile.name}" uses a name reserved by a built-in archetype and was ignored.`);
-      continue;
-    }
-    if (seen.has(key)) {
-      warnings.push(`Profile "${contribution.profile.name}" from extension "${contribution.name}" duplicates an already-registered profile and was ignored.`);
-      continue;
-    }
-    seen.add(key);
-    profiles.push({ definition: contribution.profile, source: "extension", package: contribution.name });
-  }
-  return { profiles, warnings };
-}
-function resolveProfileEntry(rawValue, contributions = []) {
-  const { profiles, warnings } = resolveProfileCatalog(contributions);
-  if (typeof rawValue !== "string" || rawValue.trim().length === 0) {
-    throw new Error(`Profile name is required. Allowed: ${formatAvailableProfileNames(profiles)}.`);
-  }
-  const key = normalizeProfileLookupKey(rawValue);
-  const match = profiles.find((entry) => normalizeProfileLookupKey(entry.definition.name) === key);
-  if (match === void 0) {
-    throw new Error(`Invalid profile "${rawValue}". Allowed: ${formatAvailableProfileNames(profiles)}.`);
-  }
-  return { resolved: match, warnings };
-}
-
-// dist/core/profile/profile-lint.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] = "22ba01dc-013c-507c-b2f7-fbe6b71b3bc3");
-  } catch (e2) {
-  }
-})();
-var PROFILE_LINT_DIMENSIONS = [
-  "profile",
-  "types",
-  "statuses",
-  "fields",
-  "workflows",
-  "config",
-  "templates",
-  "packages"
-];
-var PROFILE_LINT_CODES = [
-  "profile_name_empty",
-  "profile_name_not_normalized",
-  "profile_title_empty",
-  "profile_summary_empty",
-  "type_invalid",
-  "type_duplicate",
-  "status_invalid",
-  "status_duplicate",
-  "field_invalid",
-  "field_duplicate",
-  "workflow_type_empty",
-  "workflow_type_unknown",
-  "workflow_duplicate_type",
-  "workflow_transition_malformed",
-  "workflow_status_unknown",
-  "config_key_unknown",
-  "config_value_invalid",
-  "config_duplicate",
-  "template_type_unknown",
-  "package_spec_empty"
-];
-var BUILTIN_STATUS_TOKENS = new Set(DEFAULT_RUNTIME_STATUS_DEFINITIONS.flatMap((definition) => [
-  normalizeStatusToken(definition.id),
-  ...(definition.aliases ?? []).map((alias) => normalizeStatusToken(alias))
-]).filter((token) => token.length > 0));
-var BUILTIN_TYPE_KEYS = new Set(BUILTIN_ITEM_TYPE_VALUES.map((name) => name.toLowerCase()));
-function lintProfileIdentity(profile, findings) {
-  if (profile.name.trim().length === 0) {
-    findings.push({
-      severity: "error",
-      code: "profile_name_empty",
-      dimension: "profile",
-      message: "Profile name must not be empty; profile resolution requires a non-blank name."
-    });
-  } else if (profile.name !== normalizeProfileLookupKey(profile.name)) {
-    findings.push({
-      severity: "warning",
-      code: "profile_name_not_normalized",
-      dimension: "profile",
-      target: profile.name,
-      message: `Profile name "${profile.name}" is not in canonical form; resolution folds it to "${normalizeProfileLookupKey(profile.name)}" (lowercase, hyphens as underscores).`
-    });
-  }
-  if (profile.title.trim().length === 0) {
-    findings.push({
-      severity: "warning",
-      code: "profile_title_empty",
-      dimension: "profile",
-      message: "Profile title is empty; list and show surfaces will render a blank title."
-    });
-  }
-  if (profile.summary.trim().length === 0) {
-    findings.push({
-      severity: "warning",
-      code: "profile_summary_empty",
-      dimension: "profile",
-      message: "Profile summary is empty; list and show surfaces will render a blank archetype description."
-    });
-  }
-}
-function lintTypes(profile, findings) {
-  const declared = /* @__PURE__ */ new Set();
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, type] of profile.types.entries()) {
-    let name;
-    try {
-      name = normalizeAddTypeInput(type).name;
-    } catch (error) {
-      findings.push({
-        severity: "error",
-        code: "type_invalid",
-        dimension: "types",
-        target: typeof type.name === "string" ? type.name : `#${index}`,
-        message: toErrorMessage(error)
-      });
-      continue;
-    }
-    const key = name.toLowerCase();
-    if (seen.has(key)) {
-      findings.push({
-        severity: "error",
-        code: "type_duplicate",
-        dimension: "types",
-        target: name,
-        message: `Item type "${name}" is declared more than once; the later definition silently overwrites the earlier upsert.`
-      });
-      continue;
-    }
-    seen.add(key);
-    declared.add(key);
-  }
-  return declared;
-}
-function lintStatuses(profile, findings) {
-  const declared = /* @__PURE__ */ new Set();
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, status] of profile.statuses.entries()) {
-    let normalized;
-    try {
-      normalized = normalizeAddStatusInput(status);
-    } catch (error) {
-      findings.push({
-        severity: "error",
-        code: "status_invalid",
-        dimension: "statuses",
-        target: typeof status.id === "string" ? status.id : `#${index}`,
-        message: toErrorMessage(error)
-      });
-      continue;
-    }
-    if (seen.has(normalized.id)) {
-      findings.push({
-        severity: "error",
-        code: "status_duplicate",
-        dimension: "statuses",
-        target: normalized.id,
-        message: `Status "${normalized.id}" is declared more than once; the later definition silently overwrites the earlier upsert.`
-      });
-      continue;
-    }
-    seen.add(normalized.id);
-    declared.add(normalized.id);
-    for (const alias of normalized.aliases ?? []) {
-      declared.add(normalizeStatusToken(alias));
-    }
-  }
-  return declared;
-}
-function lintFields(profile, findings) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, field] of profile.fields.entries()) {
-    let key;
-    try {
-      key = normalizeAddFieldInput(field).key;
-    } catch (error) {
-      findings.push({
-        severity: "error",
-        code: "field_invalid",
-        dimension: "fields",
-        target: typeof field.key === "string" ? field.key : `#${index}`,
-        message: toErrorMessage(error)
-      });
-      continue;
-    }
-    if (seen.has(key)) {
-      findings.push({
-        severity: "error",
-        code: "field_duplicate",
-        dimension: "fields",
-        target: key,
-        message: `Field "${key}" is declared more than once; the later definition silently overwrites the earlier upsert.`
-      });
-      continue;
-    }
-    seen.add(key);
-  }
-}
-function lintWorkflows(profile, declaredTypes, declaredStatuses, findings) {
-  const seenTypes = /* @__PURE__ */ new Set();
-  for (const [index, workflow] of profile.workflows.entries()) {
-    const typeKey = workflow.type.trim().toLowerCase();
-    if (typeKey.length === 0) {
-      findings.push({
-        severity: "error",
-        code: "workflow_type_empty",
-        dimension: "workflows",
-        target: `#${index}`,
-        message: "Workflow has an empty type; the workflow resolver drops entries without a type."
-      });
-      continue;
-    }
-    const duplicate = seenTypes.has(typeKey);
-    seenTypes.add(typeKey);
-    if (duplicate) {
-      findings.push({
-        severity: "warning",
-        code: "workflow_duplicate_type",
-        dimension: "workflows",
-        target: workflow.type,
-        message: `Workflow type "${workflow.type}" is declared more than once; the later transition set wins.`
-      });
-    } else if (!BUILTIN_TYPE_KEYS.has(typeKey) && !declaredTypes.has(typeKey)) {
-      findings.push({
-        severity: "warning",
-        code: "workflow_type_unknown",
-        dimension: "workflows",
-        target: workflow.type,
-        message: `Workflow governs type "${workflow.type}" which is neither a built-in type nor declared by this profile; it has no effect unless that type already exists.`
-      });
-    }
-    const reportedUnknownStatuses = /* @__PURE__ */ new Set();
-    for (const pair of workflow.allowed_transitions) {
-      const from = normalizeStatusToken(pair[0]);
-      const to = normalizeStatusToken(pair[1]);
-      if (from.length === 0 || to.length === 0) {
-        findings.push({
-          severity: "error",
-          code: "workflow_transition_malformed",
-          dimension: "workflows",
-          target: workflow.type,
-          message: `Workflow "${workflow.type}" has a transition with an empty status; the workflow resolver silently drops it.`
-        });
-        continue;
-      }
-      for (const token of [from, to]) {
-        if (BUILTIN_STATUS_TOKENS.has(token) || declaredStatuses.has(token) || reportedUnknownStatuses.has(token)) {
-          continue;
-        }
-        reportedUnknownStatuses.add(token);
-        findings.push({
-          severity: "warning",
-          code: "workflow_status_unknown",
-          dimension: "workflows",
-          target: token,
-          message: `Workflow "${workflow.type}" references status "${token}" which is neither a built-in status nor declared by this profile; transitions to or from it are unreachable.`
-        });
-      }
-    }
-  }
-}
-function lintConfig(profile, findings) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of profile.config) {
-    const descriptor = resolveNestedSettingDescriptor(entry.key);
-    if (descriptor === void 0) {
-      findings.push({
-        severity: "error",
-        code: "config_key_unknown",
-        dimension: "config",
-        target: entry.key,
-        message: `Config knob "${entry.key}" is not a recognized setting; apply rejects it with a usage error.`
-      });
-      continue;
-    }
-    if (seen.has(descriptor.key)) {
-      findings.push({
-        severity: "error",
-        code: "config_duplicate",
-        dimension: "config",
-        target: descriptor.key,
-        message: `Config knob "${descriptor.key}" is set more than once; the later value silently overwrites the earlier one.`
-      });
-    } else {
-      seen.add(descriptor.key);
-    }
-    const parsed = parseNestedSettingValue(descriptor, entry.value);
-    if (!parsed.ok) {
-      findings.push({
-        severity: "error",
-        code: "config_value_invalid",
-        dimension: "config",
-        target: entry.key,
-        message: parsed.error.message
-      });
-    }
-  }
-}
-function lintTemplates(profile, declaredTypes, findings) {
-  for (const template of profile.templates) {
-    const typeOption = template.options.type;
-    if (typeof typeOption !== "string" || typeOption.trim().length === 0) {
-      continue;
-    }
-    const typeKey = typeOption.trim().toLowerCase();
-    if (!BUILTIN_TYPE_KEYS.has(typeKey) && !declaredTypes.has(typeKey)) {
-      findings.push({
-        severity: "warning",
-        code: "template_type_unknown",
-        dimension: "templates",
-        target: template.name,
-        message: `Template "${template.name}" creates type "${typeOption}" which is neither a built-in type nor declared by this profile.`
-      });
-    }
-  }
-}
-function lintPackages(profile, findings) {
-  for (const [index, recommendation] of profile.packages.entries()) {
-    if (recommendation.spec.trim().length === 0) {
-      findings.push({
-        severity: "warning",
-        code: "package_spec_empty",
-        dimension: "packages",
-        target: `#${index}`,
-        message: "Package recommendation has an empty spec; it cannot be surfaced as an install hint."
-      });
-    }
-  }
-}
-function lintProjectProfile(profile) {
-  const findings = [];
-  lintProfileIdentity(profile, findings);
-  const declaredTypes = lintTypes(profile, findings);
-  const declaredStatuses = lintStatuses(profile, findings);
-  lintFields(profile, findings);
-  lintWorkflows(profile, declaredTypes, declaredStatuses, findings);
-  lintConfig(profile, findings);
-  lintTemplates(profile, declaredTypes, findings);
-  lintPackages(profile, findings);
-  const errorCount = findings.filter((finding) => finding.severity === "error").length;
-  const warningCount = findings.length - errorCount;
-  return {
-    profile: profile.name,
-    ok: errorCount === 0,
-    findings,
-    errorCount,
-    warningCount
-  };
-}
-
-export {
-  PROFILE_NAMES,
-  BUILTIN_PROFILES,
-  normalizeProfileName,
-  resolveProfile,
-  listProfiles,
-  resolveProfileCatalog,
-  resolveProfileEntry,
-  PROFILE_LINT_DIMENSIONS,
-  PROFILE_LINT_CODES,
-  lintProjectProfile
-};
-//# sourceMappingURL=chunk-DLQ4ZTCU.js.map