@unbrained/pm-cli 2026.7.20 → 2026.7.21

package/dist/cli-bundle/chunks/{chunk-QJKL5PHS.js → chunk-7656MAUL.js}

@@ -4,7 +4,7 @@ import {
   parseAnnotationTextInput,
   resolveAnnotationInput,
   runAnnotationCommand
-} from "./chunk-HB3P4M52.js";
+} from "./chunk-TRSHFPRZ.js";
 
 // dist/cli/commands/learnings.js
 async function runLearnings(id, options, global) {
@@ -30,6 +30,6 @@ async function runLearnings(id, options, global) {
 export {
   runLearnings
 };
-//# sourceMappingURL=chunk-QJKL5PHS.js.map
+//# sourceMappingURL=chunk-7656MAUL.js.map
 
 //# debugId=1bec9be5-4967-5914-933d-cf3ebd310ca5

package/dist/cli-bundle/chunks/{chunk-3AO5VSDR.js → chunk-7RW4JCU2.js}

@@ -1,6 +1,3 @@
-import {
-  refreshMergeAttributeFenceIfInstalled
-} from "./chunk-R5U2VZ3K.js";
 import {
   BUILTIN_STATUS_IDS,
   TYPE_PRESET_NAMES,
@@ -57,8 +54,323 @@ import {
   writeFileAtomic
 } from "./chunk-7AVEY74G.js";
 
-// dist/sdk/schema.js
+// dist/sdk/workspace.js
+import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+!(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] = "2ebcdfcf-c29b-50d6-940d-299d7699059a");
+  } catch (e2) {
+  }
+})();
+var PM_GITIGNORE_START = "# pm-cli:runtime-cache:start";
+var PM_GITIGNORE_END = "# pm-cli:runtime-cache:end";
+var PM_GITIGNORE_DEFAULT_TRACKER_ROOT = ".agents/pm";
+var PM_GITIGNORE_RUNTIME_DIRECTORIES = [
+  "runtime/",
+  "search/",
+  "locks/",
+  "transactions/",
+  "checkpoints/"
+];
+function normalizeTrackerRelativeRoot(trackerRelativeRoot) {
+  return trackerRelativeRoot.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+}
+function isPathOutsideRoot(relativePath) {
+  const normalized = relativePath.replaceAll("\\", "/");
+  return path.isAbsolute(relativePath) || normalized === ".." || normalized.startsWith("../");
+}
+function getPmGitignoreBlock(trackerRelativeRoot = PM_GITIGNORE_DEFAULT_TRACKER_ROOT) {
+  const root = normalizeTrackerRelativeRoot(trackerRelativeRoot);
+  return [
+    PM_GITIGNORE_START,
+    ...PM_GITIGNORE_RUNTIME_DIRECTORIES.map((directory) => `${root}/${directory}`),
+    PM_GITIGNORE_END
+  ].join("\n");
+}
+async function ensurePmGitignore(workspaceRoot, options = {}) {
+  const gitignorePath = path.join(workspaceRoot, ".gitignore");
+  let trackerRelativeRoot = PM_GITIGNORE_DEFAULT_TRACKER_ROOT;
+  if (options.pmRoot !== void 0) {
+    const relative = normalizeTrackerRelativeRoot(path.relative(path.resolve(workspaceRoot), path.resolve(options.pmRoot)));
+    if (isPathOutsideRoot(relative)) {
+      return { path: gitignorePath, changed: false };
+    }
+    if (relative.length > 0) {
+      trackerRelativeRoot = relative;
+    }
+  }
+  let current = "";
+  try {
+    current = await readFile(gitignorePath, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+      throw error;
+    }
+  }
+  const start = current.indexOf(PM_GITIGNORE_START);
+  const end = current.indexOf(PM_GITIGNORE_END);
+  const withoutManagedBlock = start >= 0 && end >= start ? `${current.slice(0, start)}${current.slice(end + PM_GITIGNORE_END.length)}` : current;
+  const prefix = withoutManagedBlock.trimEnd();
+  const next = `${prefix.length > 0 ? `${prefix}
+
+` : ""}${getPmGitignoreBlock(trackerRelativeRoot)}
+`;
+  if (next === current) {
+    return { path: gitignorePath, changed: false };
+  }
+  await writeFile(gitignorePath, next, "utf8");
+  return { path: gitignorePath, changed: true };
+}
+
+// dist/sdk/merge/install.js
+import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import path2 from "node:path";
+import { promisify } from "node:util";
+!(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] = "86f1b43a-3b30-5791-ba03-fc362dfe5585");
+  } catch (e2) {
+  }
+})();
+var execFileAsync = promisify(execFile);
+var PM_GITATTRIBUTES_START = "# pm-cli:merge-drivers:start";
+var PM_GITATTRIBUTES_END = "# pm-cli:merge-drivers:end";
+var MERGE_FENCE_LOCK_ID = "merge-fence";
+var MERGE_DRIVER_DEFINITIONS = [
+  {
+    key: "pm-item-toon",
+    name: "pm field-aware TOON item document merge",
+    artifact: "item",
+    itemPath: "item.toon"
+  },
+  {
+    key: "pm-item-markdown",
+    name: "pm field-aware JSON-markdown item document merge",
+    artifact: "item",
+    itemPath: "item.md"
+  },
+  {
+    key: "pm-history",
+    name: "pm append-only history stream merge",
+    artifact: "history",
+    itemPath: void 0
+  },
+  {
+    key: "pm-relationship",
+    name: "pm append-only relationship event store merge",
+    artifact: "relationship",
+    itemPath: void 0
+  },
+  {
+    key: "pm-json",
+    name: "pm key-level JSON config merge",
+    artifact: "json",
+    itemPath: void 0
+  }
+];
+async function resolveGitWorkspaceRoot(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", windowsHide: true, timeout: 1e4 });
+    return stdout.trim();
+  } catch {
+    throw new PmCliError("pm merge install requires a git repository (merge drivers are git configuration).", EXIT_CODE.USAGE);
+  }
+}
+function toPosixRelative(fromPath, toPath) {
+  return path2.relative(fromPath, toPath).replaceAll("\\", "/");
+}
+function quoteGitAttributePattern(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function buildMergeAttributePatterns(trackerRelativeRoot, typeFolders) {
+  const prefix = trackerRelativeRoot.length > 0 ? `${trackerRelativeRoot}/` : "";
+  const patterns = [];
+  for (const folder of typeFolders) {
+    patterns.push(`${quoteGitAttributePattern(`${prefix}${folder}/*.toon`)} merge=pm-item-toon`);
+    patterns.push(`${quoteGitAttributePattern(`${prefix}${folder}/*.md`)} merge=pm-item-markdown`);
+  }
+  patterns.push(`${quoteGitAttributePattern(`${prefix}**/*.jsonl`)} merge=pm-relationship`);
+  patterns.push(`${quoteGitAttributePattern(`${prefix}history/*.jsonl`)} merge=pm-history`);
+  patterns.push(`${quoteGitAttributePattern(`${prefix}settings.json`)} merge=pm-json`);
+  patterns.push(`${quoteGitAttributePattern(`${prefix}schema/*.json`)} merge=pm-json`);
+  return patterns;
+}
+async function reconcileGitattributesBlock(workspaceRoot, patterns, dryRun) {
+  const gitattributesPath = path2.join(workspaceRoot, ".gitattributes");
+  let current = "";
+  try {
+    current = await readFile2(gitattributesPath, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+      throw error;
+    }
+  }
+  const block = [
+    PM_GITATTRIBUTES_START,
+    ...patterns,
+    PM_GITATTRIBUTES_END
+  ].join("\n");
+  const start = current.indexOf(PM_GITATTRIBUTES_START);
+  const end = current.indexOf(PM_GITATTRIBUTES_END);
+  const withoutManagedBlock = start >= 0 && end > start ? `${current.slice(0, start)}${current.slice(end + PM_GITATTRIBUTES_END.length)}` : current.replace(PM_GITATTRIBUTES_START, "").replace(PM_GITATTRIBUTES_END, "");
+  const prefix = withoutManagedBlock.trimEnd();
+  const next = `${prefix.length > 0 ? `${prefix}
+
+` : ""}${block}
+`;
+  if (next === current) {
+    return { path: gitattributesPath, changed: false };
+  }
+  if (!dryRun) {
+    await writeFile2(gitattributesPath, next, "utf8");
+  }
+  return { path: gitattributesPath, changed: true };
+}
+async function auditMergeAttributeFence(pmRoot, typeFolders) {
+  const resolvedRoot = path2.resolve(pmRoot);
+  let fenceDirectory = null;
+  let fenceContent = "";
+  let directory = resolvedRoot;
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidate = path2.join(directory, ".gitattributes");
+    try {
+      const raw = await readFile2(candidate, "utf8");
+      if (raw.includes(PM_GITATTRIBUTES_START)) {
+        fenceDirectory = directory;
+        fenceContent = raw;
+        break;
+      }
+    } catch {
+    }
+    const parent = path2.dirname(directory);
+    if (parent === directory) {
+      break;
+    }
+    directory = parent;
+  }
+  if (fenceDirectory === null) {
+    return { status: "not_installed", missing_patterns: [], stale_patterns: [] };
+  }
+  const fencePath = path2.join(fenceDirectory, ".gitattributes");
+  const start = fenceContent.indexOf(PM_GITATTRIBUTES_START);
+  const end = fenceContent.indexOf(PM_GITATTRIBUTES_END);
+  const committed = end > start ? fenceContent.slice(start + PM_GITATTRIBUTES_START.length, end).split("\n").map((line) => line.trim()).filter((line) => line.length > 0) : [];
+  const expected = buildMergeAttributePatterns(toPosixRelative(fenceDirectory, resolvedRoot), typeFolders);
+  const committedSet = new Set(committed);
+  const expectedSet = new Set(expected);
+  const missing = expected.filter((line) => !committedSet.has(line));
+  const stale = committed.filter((line) => !expectedSet.has(line));
+  return {
+    status: missing.length > 0 || stale.length > 0 ? "drift" : "ok",
+    path: fencePath,
+    missing_patterns: missing,
+    stale_patterns: stale
+  };
+}
+async function refreshMergeAttributeFenceIfInstalled(pmRoot) {
+  let workspaceRoot;
+  try {
+    workspaceRoot = await resolveGitWorkspaceRoot(path2.resolve(pmRoot));
+  } catch {
+    return { status: "no_git" };
+  }
+  const trackerRelativeRoot = toPosixRelative(workspaceRoot, path2.resolve(pmRoot));
+  const lockSettings = await readSettings(pmRoot);
+  const owner = (process.env.PM_AUTHOR ?? lockSettings.author_default).trim();
+  const releaseLock = await acquireLock(pmRoot, MERGE_FENCE_LOCK_ID, lockSettings.locks.ttl_seconds, owner.length > 0 ? owner : "unknown", false, resolveGovernanceKnobs(lockSettings).force_required_for_stale_lock, lockSettings.locks.wait_ms);
+  try {
+    const gitattributesPath = path2.join(workspaceRoot, ".gitattributes");
+    let current;
+    try {
+      current = await readFile2(gitattributesPath, "utf8");
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return { status: "not_installed", path: gitattributesPath };
+      }
+      throw error;
+    }
+    if (!current.includes(PM_GITATTRIBUTES_START)) {
+      return { status: "not_installed", path: gitattributesPath };
+    }
+    const settings = await readSettings(pmRoot);
+    const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+    const typeFolders = [
+      ...new Set(Object.values(typeRegistry.type_to_folder))
+    ].sort((left, right) => left.localeCompare(right));
+    const outcome = await reconcileGitattributesBlock(workspaceRoot, buildMergeAttributePatterns(trackerRelativeRoot, typeFolders), false);
+    return {
+      status: outcome.changed ? "refreshed" : "unchanged",
+      path: outcome.path
+    };
+  } finally {
+    await releaseLock();
+  }
+}
+async function runMergeInstall(options, global2) {
+  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 dryRun = options.dryRun === true;
+  const workspaceRoot = await resolveGitWorkspaceRoot(process.cwd());
+  const trackerRelativeRoot = toPosixRelative(workspaceRoot, path2.resolve(pmRoot));
+  if (isPathOutsideRoot(trackerRelativeRoot)) {
+    throw new PmCliError(`Tracker root ${pmRoot} is outside the git repository ${workspaceRoot}; there is nothing to configure for this repository.`, EXIT_CODE.USAGE);
+  }
+  const settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const typeFolders = [
+    ...new Set(Object.values(typeRegistry.type_to_folder))
+  ].sort((left, right) => left.localeCompare(right));
+  const patterns = buildMergeAttributePatterns(trackerRelativeRoot, typeFolders);
+  const gitattributes = await reconcileGitattributesBlock(workspaceRoot, patterns, dryRun);
+  const gitConfigEntries = [];
+  for (const definition of MERGE_DRIVER_DEFINITIONS) {
+    gitConfigEntries.push({
+      key: `merge.${definition.key}.name`,
+      value: definition.name
+    });
+    gitConfigEntries.push({
+      key: `merge.${definition.key}.driver`,
+      value: `pm merge driver ${definition.artifact} "%O" "%A" "%B"${definition.itemPath === void 0 ? "" : ` --item-path ${definition.itemPath}`}`
+    });
+  }
+  if (!dryRun) {
+    for (const entry of gitConfigEntries) {
+      await execFileAsync("git", ["config", entry.key, entry.value], {
+        cwd: workspaceRoot,
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 1e4
+      });
+    }
+  }
+  return {
+    ok: true,
+    dry_run: dryRun,
+    workspace_root: workspaceRoot,
+    gitattributes: {
+      path: gitattributes.path,
+      changed: gitattributes.changed,
+      patterns
+    },
+    git_config: gitConfigEntries,
+    guidance: [
+      "Commit .gitattributes so every branch and collaborator shares the merge mapping.",
+      'git config is per-clone: each collaborator (and each fresh worktree/clone) runs "pm merge install" once.',
+      'After merging branches, run "pm validate" and, if history drift is reported, "pm history-repair --all" to reconcile item state with merged history.',
+      "Custom item types registered later refresh this fence automatically (pm schema add-type/remove-type); rerun pm merge install only after out-of-band type-folder edits."
+    ],
+    generated_at: nowIso()
+  };
+}
+
+// dist/sdk/schema.js
+import path3 from "node:path";
 import { mkdir } from "node:fs/promises";
 
 // dist/core/schema/type-inference.js
@@ -358,7 +670,7 @@ function typesPathFor(pmRoot, schema) {
 async function ensureTypeFolderScaffold(pmRoot, definitions, warnings, op) {
   for (const definition of definitions) {
     const folder = definition.folder ?? toDefaultFolder(definition.name);
-    const target = path.join(pmRoot, folder);
+    const target = path3.join(pmRoot, folder);
     if (await pathExists(target)) {
       continue;
     }
@@ -1241,6 +1553,16 @@ var _testOnlySchemaCommand = {
 };
 
 export {
+  PM_GITIGNORE_START,
+  PM_GITIGNORE_END,
+  getPmGitignoreBlock,
+  ensurePmGitignore,
+  PM_GITATTRIBUTES_START,
+  PM_GITATTRIBUTES_END,
+  buildMergeAttributePatterns,
+  auditMergeAttributeFence,
+  refreshMergeAttributeFenceIfInstalled,
+  runMergeInstall,
   SCHEMA_SUBCOMMANDS,
   runSchemaAddType,
   runSchemaRemoveType,
@@ -1271,4 +1593,4 @@ export {
   formatSchemaInferTypesHuman,
   _testOnlySchemaCommand
 };
-//# sourceMappingURL=chunk-3AO5VSDR.js.map
+//# sourceMappingURL=chunk-7RW4JCU2.js.map