@unbrained/pm-cli 2026.7.4 → 2026.7.5

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

@@ -0,0 +1,634 @@
+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