@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,401 @@
+import {
+  isRemoteLinkedArtifactReference
+} from "./chunk-7M2HAZEB.js";
+import {
+  assertNoUnknownCsvKeys,
+  createStdinTokenResolver,
+  looksLikeGenericKeyValueEntry,
+  parseCsvKv
+} from "./chunk-AZYGZGGI.js";
+import {
+  resolveAuthor
+} from "./chunk-WW4E2DC3.js";
+import {
+  splitCommaList
+} from "./chunk-5HIZDR5A.js";
+import {
+  listAllFrontMatter,
+  locateItem,
+  mutateItem,
+  readLocatedItem
+} from "./chunk-5VAA4YHR.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings
+} from "./chunk-SHQY2IDC.js";
+import {
+  EXIT_CODE,
+  SCOPE_VALUES,
+  getSettingsPath,
+  pathExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot
+} from "./chunk-LK6XLOGP.js";
+
+// dist/cli/commands/linked-artifacts.js
+import fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+!(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] = "56979df9-0c63-585c-a792-b330cfa6b169");
+  } catch (e2) {
+  }
+})();
+var LINKED_ARTIFACT_ADD_KEYS = ["path", "scope", "note"];
+var LINKED_ARTIFACT_ADD_GLOB_KEYS = ["pattern", "glob", "path", "scope", "note"];
+var LINKED_ARTIFACT_REMOVE_KEYS = ["path"];
+var LINKED_ARTIFACT_MIGRATE_KEYS = ["from", "to"];
+var LINKED_ARTIFACT_REMOVE_UNSUPPORTED_KEYS = /* @__PURE__ */ new Set(["note", "scope"]);
+function ensureScope(raw) {
+  const value = raw ?? "project";
+  if (!SCOPE_VALUES.includes(value)) {
+    throw new PmCliError(`Invalid scope "${raw}". Valid scopes: ${SCOPE_VALUES.join(", ")} (default: project).`, EXIT_CODE.USAGE);
+  }
+  return value;
+}
+function looksLikeStructuredPathEntry(raw) {
+  if (raw.startsWith("```") || raw.includes("\n")) {
+    return true;
+  }
+  if (/^(?:[-*+]\s+)?(?:path|scope|note)\s*[:=]/i.test(raw)) {
+    return true;
+  }
+  return looksLikeGenericKeyValueEntry(raw);
+}
+function expandBareCommaSeparatedAddEntries(raw) {
+  return raw.flatMap((entry) => {
+    const trimmed = entry.trim();
+    if (trimmed.length === 0 || looksLikeStructuredPathEntry(trimmed) || !trimmed.includes(",")) {
+      return [entry];
+    }
+    return splitCommaList(trimmed);
+  });
+}
+function parseAddEntries(raw, bareNoun) {
+  if (!raw)
+    return [];
+  return expandBareCommaSeparatedAddEntries(raw).map((entry) => {
+    const trimmed = entry.trim();
+    const kv = looksLikeStructuredPathEntry(trimmed) ? parseCsvKv(entry, "--add") : { path: trimmed };
+    assertNoUnknownCsvKeys(kv, "--add", LINKED_ARTIFACT_ADD_KEYS);
+    if (!kv.path) {
+      throw new PmCliError(`--add requires path=<value> or a bare ${bareNoun} path`, EXIT_CODE.USAGE);
+    }
+    return {
+      path: kv.path,
+      scope: ensureScope(kv.scope),
+      note: kv.note?.trim() || void 0
+    };
+  });
+}
+function parseAddGlobEntries(raw) {
+  if (!raw)
+    return [];
+  return raw.map((entry) => {
+    const trimmed = entry.trim();
+    if (!trimmed) {
+      throw new PmCliError("--add-glob requires a glob pattern value", EXIT_CODE.USAGE);
+    }
+    if (trimmed.includes("=") || /^(?:[-*+]\s+)?(?:pattern|glob|path)\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
+      const kv = parseCsvKv(trimmed, "--add-glob");
+      assertNoUnknownCsvKeys(kv, "--add-glob", LINKED_ARTIFACT_ADD_GLOB_KEYS);
+      const pattern = kv.pattern?.trim() || kv.glob?.trim() || kv.path?.trim();
+      if (!pattern) {
+        throw new PmCliError("--add-glob key/value form requires pattern=<glob>", EXIT_CODE.USAGE);
+      }
+      return {
+        pattern,
+        scope: ensureScope(kv.scope),
+        note: kv.note?.trim() || void 0
+      };
+    }
+    return {
+      pattern: trimmed,
+      scope: "project"
+    };
+  });
+}
+function parseRemoveEntries(raw) {
+  if (!raw)
+    return [];
+  return raw.map((entry) => {
+    const trimmed = entry.trim();
+    if (!trimmed) {
+      throw new PmCliError("--remove requires a path value", EXIT_CODE.USAGE);
+    }
+    if (trimmed.includes("=") || /^(?:[-*+]\s+)?path\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
+      const kv = parseCsvKv(trimmed, "--remove");
+      const unsupportedRemoveKeys = Object.keys(kv).filter((key) => LINKED_ARTIFACT_REMOVE_UNSUPPORTED_KEYS.has(key.toLowerCase()));
+      if (unsupportedRemoveKeys.length > 0) {
+        throw new PmCliError(`--remove identifies a linked artifact by path only and does not accept ${unsupportedRemoveKeys.map((key) => `"${key}"`).join(", ")}. Pass just the path (path=<value>, path:<value>, or a bare path); record removal context with --message "<why removed>".`, EXIT_CODE.USAGE);
+      }
+      assertNoUnknownCsvKeys(kv, "--remove", LINKED_ARTIFACT_REMOVE_KEYS);
+      if (!kv.path) {
+        throw new PmCliError("--remove key/value form requires path=<value>", EXIT_CODE.USAGE);
+      }
+      return kv.path;
+    }
+    return trimmed;
+  });
+}
+function parseMigrateEntries(raw) {
+  if (!raw)
+    return [];
+  return raw.map((entry) => {
+    const kv = parseCsvKv(entry, "--migrate");
+    assertNoUnknownCsvKeys(kv, "--migrate", LINKED_ARTIFACT_MIGRATE_KEYS);
+    const from = kv.from?.trim();
+    const to = kv.to?.trim();
+    if (!from || !to) {
+      throw new PmCliError("--migrate requires from=<value> and to=<value>", EXIT_CODE.USAGE);
+    }
+    return { from, to };
+  });
+}
+function applyPathMigrations(artifactPath, migrations) {
+  let next = artifactPath;
+  for (const migration of migrations) {
+    if (next.startsWith(migration.from)) {
+      next = `${migration.to}${next.slice(migration.from.length)}`;
+    }
+  }
+  return next;
+}
+function normalizeLinkedPath(value) {
+  return value.split(path.sep).join("/");
+}
+async function expandAddGlobEntries(entries) {
+  const expanded = [];
+  for (const entry of entries) {
+    const absolutePattern = path.isAbsolute(entry.pattern);
+    const matches = await fg(entry.pattern, {
+      cwd: process.cwd(),
+      absolute: absolutePattern,
+      onlyFiles: true,
+      dot: true,
+      unique: true,
+      followSymbolicLinks: true
+    });
+    const sortedMatches = [...new Set(matches.map((match) => normalizeLinkedPath(path.normalize(match))))].sort((left, right) => left.localeCompare(right));
+    for (const matchedPath of sortedMatches) {
+      expanded.push({
+        path: matchedPath,
+        scope: entry.scope,
+        note: entry.note
+      });
+    }
+  }
+  return expanded;
+}
+function applyStandaloneNote(adds, note, hasAddFlags) {
+  if (note === void 0) {
+    return adds;
+  }
+  if (!hasAddFlags) {
+    throw new PmCliError("--note requires --add or --add-glob in the same invocation (the note annotates the links being added)", EXIT_CODE.USAGE);
+  }
+  const trimmed = note.trim();
+  if (trimmed.length === 0) {
+    return adds;
+  }
+  return adds.map((entry) => entry.note === void 0 ? { ...entry, note: trimmed } : entry);
+}
+function artifactKey(value) {
+  return `${value.path}::${value.scope}`;
+}
+function sortLinkedArtifacts(artifacts) {
+  return [...artifacts].sort((left, right) => {
+    const byPath = left.path.localeCompare(right.path);
+    if (byPath !== 0)
+      return byPath;
+    return left.scope.localeCompare(right.scope);
+  });
+}
+function dedupeLinkedArtifacts(artifacts) {
+  return [...new Map(artifacts.map((entry) => [artifactKey(entry), entry])).values()].map((entry) => ({
+    ...entry,
+    note: entry.note?.trim() || void 0
+  }));
+}
+async function validateLinkedPaths(paths) {
+  const uniquePaths = [...new Set(paths)].sort((left, right) => left.localeCompare(right));
+  const existingFiles = [];
+  const missingPaths = [];
+  const nonFilePaths = [];
+  const remoteReferences = [];
+  for (const relativePath of uniquePaths) {
+    if (isRemoteLinkedArtifactReference(relativePath)) {
+      remoteReferences.push(relativePath.trim());
+      continue;
+    }
+    const resolvedPath = path.isAbsolute(relativePath) ? relativePath : path.resolve(process.cwd(), relativePath);
+    try {
+      const stats = await fs.stat(resolvedPath);
+      if (stats.isFile()) {
+        existingFiles.push(relativePath);
+      } else {
+        nonFilePaths.push(relativePath);
+      }
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+        missingPaths.push(relativePath);
+        continue;
+      }
+      nonFilePaths.push(relativePath);
+    }
+  }
+  return {
+    checked: uniquePaths.length,
+    existing_files: existingFiles,
+    missing_paths: missingPaths,
+    non_file_paths: nonFilePaths,
+    remote_references: remoteReferences
+  };
+}
+function buildLinkedPathAudit(paths, allItems) {
+  const index = /* @__PURE__ */ new Map();
+  for (const item of allItems) {
+    for (const linkedArtifact of item.artifacts ?? []) {
+      const seen = index.get(linkedArtifact.path) ?? /* @__PURE__ */ new Set();
+      seen.add(item.id);
+      index.set(linkedArtifact.path, seen);
+    }
+  }
+  return [...new Set(paths)].sort((left, right) => left.localeCompare(right)).map((linkedPath) => {
+    const linkedIds = [...index.get(linkedPath) ?? /* @__PURE__ */ new Set()].sort((left, right) => left.localeCompare(right));
+    return {
+      path: linkedPath,
+      linked_by_count: linkedIds.length,
+      linked_item_ids: linkedIds
+    };
+  });
+}
+async function runLinkedArtifacts(id, options, global2, config) {
+  const { metadataKey } = config;
+  const stdinResolver = createStdinTokenResolver();
+  const pmRoot = resolvePmRoot(process.cwd(), global2.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const resolvedAdds = await stdinResolver.resolveList(options.add, "--add");
+  const resolvedAddGlobs = await stdinResolver.resolveList(options.addGlob, "--add-glob");
+  const resolvedRemoves = await stdinResolver.resolveList(options.remove, "--remove");
+  const resolvedMigrations = await stdinResolver.resolveList(options.migrate, "--migrate");
+  const parsedAdds = parseAddEntries(resolvedAdds, config.bareNoun);
+  const addGlobs = parseAddGlobEntries(resolvedAddGlobs);
+  const expandedGlobAdds = await expandAddGlobEntries(addGlobs);
+  const adds = applyStandaloneNote([...parsedAdds, ...expandedGlobAdds], options.note, parsedAdds.length > 0 || addGlobs.length > 0);
+  const removes = parseRemoveEntries(resolvedRemoves);
+  const migrations = parseMigrateEntries(resolvedMigrations);
+  const shouldMutate = adds.length > 0 || removes.length > 0 || migrations.length > 0;
+  const collectAuditItems = async () => (await listAllFrontMatter(pmRoot, settings.item_format, typeRegistry.type_to_folder, void 0, settings.schema)).map((entry) => ({
+    id: entry.id,
+    artifacts: entry[metadataKey]
+  }));
+  if (!shouldMutate) {
+    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+    if (!located) {
+      throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
+    }
+    const loaded = await readLocatedItem(located, { schema: settings.schema });
+    const artifacts2 = loaded.document.metadata[metadataKey] ?? [];
+    return {
+      id: located.id,
+      artifacts: artifacts2,
+      changed: false,
+      count: artifacts2.length,
+      validation: options.validatePaths ? await validateLinkedPaths(artifacts2.map((entry) => entry.path)) : void 0,
+      audit: options.audit ? buildLinkedPathAudit(artifacts2.map((entry) => entry.path), await collectAuditItems()) : void 0
+    };
+  }
+  const author = resolveAuthor(options.author, settings.author_default);
+  const result = await mutateItem({
+    pmRoot,
+    settings,
+    id,
+    op: config.op,
+    author,
+    message: options.message,
+    force: options.force,
+    mutate(document) {
+      const metadata = document.metadata;
+      const next = [...metadata[metadataKey] ?? []];
+      let migrationCount2 = 0;
+      if (migrations.length > 0) {
+        for (let index = 0; index < next.length; index += 1) {
+          const migratedPath = applyPathMigrations(next[index].path, migrations);
+          if (migratedPath !== next[index].path) {
+            next[index] = { ...next[index], path: migratedPath };
+            migrationCount2 += 1;
+          }
+        }
+      }
+      const migratedAdds = adds.map((entry) => {
+        const migratedPath = applyPathMigrations(entry.path, migrations);
+        if (migratedPath !== entry.path) {
+          migrationCount2 += 1;
+        }
+        return {
+          ...entry,
+          path: migratedPath
+        };
+      });
+      const migratedRemoves = removes.map((entry) => applyPathMigrations(entry, migrations));
+      for (const add of migratedAdds) {
+        const exists = next.some((entry) => entry.path === add.path && entry.scope === add.scope);
+        if (!exists) {
+          next.push(add);
+        }
+      }
+      if (migratedRemoves.length > 0) {
+        for (let i = next.length - 1; i >= 0; i -= 1) {
+          if (migratedRemoves.includes(next[i].path)) {
+            next.splice(i, 1);
+          }
+        }
+      }
+      const deduped = dedupeLinkedArtifacts(next);
+      const normalized = config.supportsAppendStable && options.appendStable ? deduped : sortLinkedArtifacts(deduped);
+      if (normalized.length > 0) {
+        metadata[metadataKey] = normalized;
+      } else {
+        delete metadata[metadataKey];
+      }
+      return { changedFields: [metadataKey], warnings: migrationCount2 > 0 ? [`path_migrations_applied:${migrationCount2}`] : [] };
+    }
+  });
+  const artifacts = result.item[metadataKey] ?? [];
+  const migrationWarning = result.warnings.find((warning) => warning.startsWith("path_migrations_applied:"));
+  const migrationCount = migrationWarning ? Number(migrationWarning.slice("path_migrations_applied:".length)) : 0;
+  const allItems = options.audit ? await collectAuditItems() : [];
+  return {
+    id: result.item.id,
+    artifacts,
+    changed: true,
+    count: artifacts.length,
+    migrations_applied: migrationCount > 0 ? migrationCount : void 0,
+    validation: options.validatePaths ? await validateLinkedPaths(artifacts.map((entry) => entry.path)) : void 0,
+    audit: options.audit ? buildLinkedPathAudit(artifacts.map((entry) => entry.path), allItems) : void 0
+  };
+}
+function renameArtifactsResultKey(result, key) {
+  const out = {};
+  for (const [field, value] of Object.entries(result)) {
+    out[field === "artifacts" ? key : field] = value;
+  }
+  return out;
+}
+
+export {
+  normalizeLinkedPath,
+  sortLinkedArtifacts,
+  dedupeLinkedArtifacts,
+  runLinkedArtifacts,
+  renameArtifactsResultKey
+};
+//# sourceMappingURL=chunk-GBAX2ZAQ.js.map

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

@@ -0,0 +1,105 @@
+
+!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]="f39b19d5-1033-5c41-bbb2-d1fdfc10beaa")}catch(e){}}();
+import {
+  clearFocusedItem,
+  getFocusedItem,
+  setFocusedItem
+} from "./chunk-XG625QP4.js";
+import {
+  buildItemNotFoundError,
+  locateItem,
+  readLocatedItem
+} from "./chunk-ENGQOEUY.js";
+import {
+  normalizeItemId
+} from "./chunk-G24G7ZAV.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings
+} from "./chunk-E3SZTQ4K.js";
+import {
+  EXIT_CODE,
+  getSettingsPath,
+  pathExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot
+} from "./chunk-57NWPFF2.js";
+
+// dist/cli/commands/focus.js
+async function ensureInitialized(pmRoot) {
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+}
+async function runFocus(id, options, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  await ensureInitialized(pmRoot);
+  const clear = options.clear === true;
+  if (clear) {
+    if (id !== void 0) {
+      throw new PmCliError("pm focus --clear does not take an item id. Use 'pm focus --clear' to clear focus or 'pm focus <id>' to set it.", EXIT_CODE.USAGE);
+    }
+    await clearFocusedItem(pmRoot);
+    return {
+      action: "clear",
+      focused_item: null,
+      title: null,
+      message: "Focus cleared. New items will not inherit a default parent."
+    };
+  }
+  if (id === void 0) {
+    const current = await getFocusedItem(pmRoot);
+    if (current === void 0) {
+      return {
+        action: "show",
+        focused_item: null,
+        title: null,
+        message: "No focus set. Use 'pm focus <id>' to set a default parent for new items."
+      };
+    }
+    const title2 = await resolveFocusedTitle(pmRoot, current);
+    return {
+      action: "show",
+      focused_item: current,
+      title: title2,
+      message: `Focused on ${current}${title2 ? ` (${title2})` : ""}. New items default --parent to it.`
+    };
+  }
+  const settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+  if (!located) {
+    throw await buildItemNotFoundError(pmRoot, id, settings.id_prefix, typeRegistry.type_to_folder);
+  }
+  const normalizedId = normalizeItemId(located.id, settings.id_prefix);
+  const loaded = await readLocatedItem(located, { schema: settings.schema });
+  const title = nonEmptyTitleOrNull(loaded.document.metadata.title);
+  await setFocusedItem(pmRoot, normalizedId);
+  return {
+    action: "set",
+    focused_item: normalizedId,
+    title,
+    message: `Focused on ${normalizedId}${title ? ` (${title})` : ""}. New items default --parent to it (override with --parent or clear via 'pm focus --clear').`
+  };
+}
+async function resolveFocusedTitle(pmRoot, id) {
+  const settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+  if (!located) {
+    return null;
+  }
+  const loaded = await readLocatedItem(located, { schema: settings.schema });
+  return nonEmptyTitleOrNull(loaded.document.metadata.title);
+}
+function nonEmptyTitleOrNull(title) {
+  return title.trim().length > 0 ? title : null;
+}
+
+export {
+  runFocus
+};
+//# sourceMappingURL=chunk-GDDAGPWJ.js.map
+
+//# debugId=f39b19d5-1033-5c41-bbb2-d1fdfc10beaa

package/dist/cli-bundle/chunks/chunk-GDDAGPWJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../cli/commands/focus.ts"],"sourcesContent":["/**\n * @module cli/commands/focus\n *\n * Implements the pm focus command surface and its agent-facing runtime behavior.\n */\nimport { pathExists } from \"../../core/fs/fs-utils.js\";\nimport { getActiveExtensionRegistrations } from \"../../core/extensions/index.js\";\nimport { normalizeItemId } from \"../../core/item/id.js\";\nimport { resolveItemTypeRegistry } from \"../../core/item/type-registry.js\";\nimport { EXIT_CODE } from \"../../core/shared/constants.js\";\nimport type { GlobalOptions } from \"../../core/shared/command-types.js\";\nimport { PmCliError } from \"../../core/shared/errors.js\";\nimport {\n  clearFocusedItem,\n  getFocusedItem,\n  setFocusedItem,\n} from \"../../core/session/session-state.js\";\nimport { buildItemNotFoundError, locateItem, readLocatedItem } from \"../../core/store/item-store.js\";\nimport { getSettingsPath, resolvePmRoot } from \"../../core/store/paths.js\";\nimport { readSettings } from \"../../core/store/settings.js\";\n\n/**\n * Documents the focus options payload exchanged by command, SDK, and package integrations.\n */\nexport interface FocusOptions {\n  clear?: boolean;\n}\n\n/**\n * Documents the focus result payload exchanged by command, SDK, and package integrations.\n */\nexport interface FocusResult {\n  action: \"set\" | \"clear\" | \"show\";\n  focused_item: string | null;\n  title: string | null;\n  message: string;\n}\n\nasync function ensureInitialized(pmRoot: string): Promise<void> {\n  if (!(await pathExists(getSettingsPath(pmRoot)))) {\n    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);\n  }\n}\n\n/**\n * Implements run focus for the public runtime surface of this module.\n */\nexport async function runFocus(\n  id: string | undefined,\n  options: FocusOptions,\n  global: GlobalOptions,\n): Promise<FocusResult> {\n  const pmRoot = resolvePmRoot(process.cwd(), global.path);\n  await ensureInitialized(pmRoot);\n\n  const clear = options.clear === true;\n\n  if (clear) {\n    if (id !== undefined) {\n      throw new PmCliError(\n        \"pm focus --clear does not take an item id. Use 'pm focus --clear' to clear focus or 'pm focus <id>' to set it.\",\n        EXIT_CODE.USAGE,\n      );\n    }\n    await clearFocusedItem(pmRoot);\n    return {\n      action: \"clear\",\n      focused_item: null,\n      title: null,\n      message: \"Focus cleared. New items will not inherit a default parent.\",\n    };\n  }\n\n  if (id === undefined) {\n    const current = await getFocusedItem(pmRoot);\n    if (current === undefined) {\n      return {\n        action: \"show\",\n        focused_item: null,\n        title: null,\n        message: \"No focus set. Use 'pm focus <id>' to set a default parent for new items.\",\n      };\n    }\n    const title = await resolveFocusedTitle(pmRoot, current);\n    return {\n      action: \"show\",\n      focused_item: current,\n      title,\n      message: `Focused on ${current}${title ? ` (${title})` : \"\"}. New items default --parent to it.`,\n    };\n  }\n\n  const settings = await readSettings(pmRoot);\n  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());\n  const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);\n  if (!located) {\n    throw await buildItemNotFoundError(pmRoot, id, settings.id_prefix, typeRegistry.type_to_folder);\n  }\n  const normalizedId = normalizeItemId(located.id, settings.id_prefix);\n  const loaded = await readLocatedItem(located, { schema: settings.schema });\n  const title = nonEmptyTitleOrNull(loaded.document.metadata.title);\n  await setFocusedItem(pmRoot, normalizedId);\n  return {\n    action: \"set\",\n    focused_item: normalizedId,\n    title,\n    message: `Focused on ${normalizedId}${title ? ` (${title})` : \"\"}. New items default --parent to it (override with --parent or clear via 'pm focus --clear').`,\n  };\n}\n\nasync function resolveFocusedTitle(pmRoot: string, id: string): Promise<string | null> {\n  // The tracker is already known to be initialized (ensureInitialized ran), so\n  // readSettings/locateItem behave like the `pm get` read path: a deleted/stale\n  // focused item simply locates to null and yields no title hint.\n  const settings = await readSettings(pmRoot);\n  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());\n  const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);\n  if (!located) {\n    return null;\n  }\n  const loaded = await readLocatedItem(located, { schema: settings.schema });\n  return nonEmptyTitleOrNull(loaded.document.metadata.title);\n}\n\nfunction nonEmptyTitleOrNull(title: string): string | null {\n  return title.trim().length > 0 ? title : null;\n}\n"],"names":["title"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,eAAe,kBAAkB,QAAc;AAC7C,MAAI,CAAE,MAAM,WAAW,gBAAgB,MAAM,CAAC,GAAI;AAChD,UAAM,IAAI,WAAW,iCAAiC,MAAM,wBAAwB,UAAU,SAAS;EACzG;AACF;AAKA,eAAsB,SACpB,IACA,SACA,QAAqB;AAErB,QAAM,SAAS,cAAc,QAAQ,IAAG,GAAI,OAAO,IAAI;AACvD,QAAM,kBAAkB,MAAM;AAE9B,QAAM,QAAQ,QAAQ,UAAU;AAEhC,MAAI,OAAO;AACT,QAAI,OAAO,QAAW;AACpB,YAAM,IAAI,WACR,kHACA,UAAU,KAAK;IAEnB;AACA,UAAM,iBAAiB,MAAM;AAC7B,WAAO;MACL,QAAQ;MACR,cAAc;MACd,OAAO;MACP,SAAS;;EAEb;AAEA,MAAI,OAAO,QAAW;AACpB,UAAM,UAAU,MAAM,eAAe,MAAM;AAC3C,QAAI,YAAY,QAAW;AACzB,aAAO;QACL,QAAQ;QACR,cAAc;QACd,OAAO;QACP,SAAS;;IAEb;AACA,UAAMA,SAAQ,MAAM,oBAAoB,QAAQ,OAAO;AACvD,WAAO;MACL,QAAQ;MACR,cAAc;MACd,OAAAA;MACA,SAAS,cAAc,OAAO,GAAGA,SAAQ,KAAKA,MAAK,MAAM,EAAE;;EAE/D;AAEA,QAAM,WAAW,MAAM,aAAa,MAAM;AAC1C,QAAM,eAAe,wBAAwB,UAAU,gCAA+B,CAAE;AACxF,QAAM,UAAU,MAAM,WAAW,QAAQ,IAAI,SAAS,WAAW,SAAS,aAAa,aAAa,cAAc;AAClH,MAAI,CAAC,SAAS;AACZ,UAAM,MAAM,uBAAuB,QAAQ,IAAI,SAAS,WAAW,aAAa,cAAc;EAChG;AACA,QAAM,eAAe,gBAAgB,QAAQ,IAAI,SAAS,SAAS;AACnE,QAAM,SAAS,MAAM,gBAAgB,SAAS,EAAE,QAAQ,SAAS,OAAM,CAAE;AACzE,QAAM,QAAQ,oBAAoB,OAAO,SAAS,SAAS,KAAK;AAChE,QAAM,eAAe,QAAQ,YAAY;AACzC,SAAO;IACL,QAAQ;IACR,cAAc;IACd;IACA,SAAS,cAAc,YAAY,GAAG,QAAQ,KAAK,KAAK,MAAM,EAAE;;AAEpE;AAEA,eAAe,oBAAoB,QAAgB,IAAU;AAI3D,QAAM,WAAW,MAAM,aAAa,MAAM;AAC1C,QAAM,eAAe,wBAAwB,UAAU,gCAA+B,CAAE;AACxF,QAAM,UAAU,MAAM,WAAW,QAAQ,IAAI,SAAS,WAAW,SAAS,aAAa,aAAa,cAAc;AAClH,MAAI,CAAC,SAAS;AACZ,WAAO;EACT;AACA,QAAM,SAAS,MAAM,gBAAgB,SAAS,EAAE,QAAQ,SAAS,OAAM,CAAE;AACzE,SAAO,oBAAoB,OAAO,SAAS,SAAS,KAAK;AAC3D;AAEA,SAAS,oBAAoB,OAAa;AACxC,SAAO,MAAM,KAAI,EAAG,SAAS,IAAI,QAAQ;AAC3C","debugId":"f39b19d5-1033-5c41-bbb2-d1fdfc10beaa"}