@unbrained/pm-cli 2026.5.31 → 2026.6.5

package/packages/pm-search-advanced/extensions/search-advanced/index.ts

@@ -1,4 +1,11 @@
-import type { CommandDefinition, ExtensionApi } from "../../../../src/sdk/index.js";
+import type {
+  CommandDefinition,
+  ExtensionApi,
+  ItemDocument,
+  SearchProviderDefinition,
+  SearchProviderHit,
+  SearchProviderQueryContext,
+} from "../../../../src/sdk/index.js";
 import { runAdvancedReindexPackage, runAdvancedSearchPackage } from "./runtime.js";
 
 export const manifest = {
@@ -6,9 +13,90 @@ export const manifest = {
   version: "0.1.0",
   entry: "./index.js",
   priority: 0,
-  capabilities: ["commands", "schema"],
+  capabilities: ["commands", "schema", "search"],
 };
 
+/**
+ * Provider name selected via `pm config set search.provider search-advanced-local`.
+ * Core search invokes the registered `query` when this name is configured.
+ */
+export const SEARCH_ADVANCED_LOCAL_PROVIDER = "search-advanced-local";
+
+const SEARCH_FIELD_WEIGHTS = { title: 3, tags: 2, description: 1 } as const;
+
+function tokenizeSearchText(value: string): string[] {
+  // Unicode-aware: keep letters/numbers from any script (é, ü, CJK, Cyrillic, ...)
+  // so the provider works for non-English/multilingual corpora.
+  return value.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+
+function scoreDocumentForQuery(
+  queryTokens: readonly string[],
+  document: ItemDocument,
+): { score: number; matched_fields: string[] } {
+  const metadata = document?.metadata;
+  // A non-string id would crash hits.sort()'s localeCompare; treat as unscoreable.
+  if (!metadata || typeof metadata.id !== "string") {
+    return { score: 0, matched_fields: [] };
+  }
+  const fields: Array<{ field: keyof typeof SEARCH_FIELD_WEIGHTS; tokens: string[] }> = [
+    { field: "title", tokens: tokenizeSearchText(typeof metadata.title === "string" ? metadata.title : "") },
+    {
+      field: "tags",
+      tokens: Array.isArray(metadata.tags)
+        ? metadata.tags.flatMap((tag) => (tag == null ? [] : tokenizeSearchText(String(tag))))
+        : [],
+    },
+    {
+      field: "description",
+      tokens: tokenizeSearchText(typeof metadata.description === "string" ? metadata.description : ""),
+    },
+  ];
+  let score = 0;
+  const matched: string[] = [];
+  for (const { field, tokens } of fields) {
+    const available = new Set(tokens);
+    let fieldMatches = 0;
+    for (const queryToken of queryTokens) {
+      if (available.has(queryToken)) {
+        fieldMatches += 1;
+      }
+    }
+    if (fieldMatches > 0) {
+      score += fieldMatches * SEARCH_FIELD_WEIGHTS[field];
+      matched.push(field);
+    }
+  }
+  return { score, matched_fields: matched };
+}
+
+/**
+ * First-party exemplar SearchProvider: a deterministic, dependency-free local
+ * lexical ranker over the in-memory document corpus. Core search calls `query`
+ * when `settings.search.provider === "search-advanced-local"`. Authors building
+ * embedding-backed providers (for example Ollama or a hosted model) implement
+ * `embed`/`embedBatch` on this same SearchProviderDefinition shape instead.
+ */
+export function searchAdvancedLocalProvider(): SearchProviderDefinition {
+  return {
+    name: SEARCH_ADVANCED_LOCAL_PROVIDER,
+    query(context: SearchProviderQueryContext): SearchProviderHit[] {
+      const queryTokens = tokenizeSearchText(context.query);
+      if (queryTokens.length === 0) {
+        return [];
+      }
+      const hits: SearchProviderHit[] = [];
+      for (const document of context.documents) {
+        const { score, matched_fields } = scoreDocumentForQuery(queryTokens, document);
+        if (score > 0) {
+          hits.push({ id: document.metadata.id, score, matched_fields });
+        }
+      }
+      return hits.sort((left, right) => right.score - left.score || left.id.localeCompare(right.id));
+    },
+  };
+}
+
 const searchAdvancedFlags = [
   {
     long: "--mode",
@@ -160,6 +248,7 @@ export function activate(api: ExtensionApi): void {
   api.registerFlags("search-advanced", [...searchAdvancedFlags]);
   api.registerCommand(searchAdvancedCommand());
   api.registerCommand(reindexCommand());
+  api.registerSearchProvider(searchAdvancedLocalProvider());
 }
 
 export default {

package/packages/pm-search-advanced/extensions/search-advanced/manifest.json

@@ -3,5 +3,17 @@
   "version": "0.1.0",
   "entry": "./index.js",
   "priority": 0,
-  "capabilities": ["commands", "schema"]
+  "capabilities": [
+    "commands",
+    "schema",
+    "search"
+  ],
+  "manifest_version": 1,
+  "pm_min_version": "2026.5.0",
+  "activation": {
+    "commands": [
+      "reindex",
+      "search-advanced"
+    ]
+  }
 }

package/packages/pm-templates/extensions/templates/manifest.json

@@ -3,5 +3,10 @@
   "version": "0.1.0",
   "entry": "./index.js",
   "priority": 0,
-  "capabilities": ["commands", "schema"]
+  "capabilities": ["commands", "schema"],
+  "manifest_version": 1,
+  "pm_min_version": "2026.5.0",
+  "activation": {
+    "commands": ["templates", "templates list", "templates save", "templates show"]
+  }
 }

package/packages/pm-todos/extensions/todos/index.js

@@ -4,7 +4,7 @@ export const manifest = {
     version: "0.1.0",
     entry: "./index.js",
     priority: 0,
-    capabilities: ["commands", "schema"],
+    capabilities: ["commands", "schema", "importers"],
 };
 function asOptionalString(value) {
     return typeof value === "string" ? value : undefined;
@@ -36,8 +36,7 @@ async function runTodosExportFromRuntime(options, global) {
     return runtime.runTodosExport(options, global);
 }
 export function activate(api) {
-    api.registerCommand({
-        name: "todos import",
+    api.registerImporter("todos", async (context) => runTodosImportFromRuntime(toImportOptions(context.options), context.global), {
         action: "todos-import",
         description: "Import Todo markdown files into pm items.",
         flags: [
@@ -60,10 +59,8 @@ export function activate(api) {
                 description: "Override import history message.",
             },
         ],
-        run: async (context) => runTodosImportFromRuntime(toImportOptions(context.options), context.global),
     });
-    api.registerCommand({
-        name: "todos export",
+    api.registerExporter("todos", async (context) => runTodosExportFromRuntime(toExportOptions(context.options), context.global), {
         action: "todos-export",
         description: "Export pm items into Todo markdown files.",
         flags: [
@@ -74,7 +71,6 @@ export function activate(api) {
                 description: "Destination folder for exported Todo markdown files.",
             },
         ],
-        run: async (context) => runTodosExportFromRuntime(toExportOptions(context.options), context.global),
     });
 }
 export default {

package/packages/pm-todos/extensions/todos/index.ts

@@ -1,4 +1,9 @@
-import type { CommandDefinition, ExtensionApi, GlobalOptions } from "../../../../src/sdk/index.js";
+import type {
+  ExtensionApi,
+  GlobalOptions,
+  ImportExportContext,
+  ImportExportRegistrationOptions,
+} from "../../../../src/sdk/index.js";
 import type { TodosExportOptions, TodosExportResult, TodosImportOptions, TodosImportResult } from "./runtime.js";
 import { loadPackageRuntimeModule } from "./runtime-loader.js";
 
@@ -7,7 +12,7 @@ export const manifest = {
   version: "0.1.0",
   entry: "./index.js",
   priority: 0,
-  capabilities: ["commands", "schema"],
+  capabilities: ["commands", "schema", "importers"],
 };
 
 type RuntimeModule = {
@@ -50,46 +55,54 @@ async function runTodosExportFromRuntime(options: TodosExportOptions, global: Gl
 }
 
 export function activate(api: ExtensionApi): void {
-  api.registerCommand({
-    name: "todos import",
-    action: "todos-import",
-    description: "Import Todo markdown files into pm items.",
-    flags: [
-      {
-        long: "--folder",
-        value_name: "path",
-        value_type: "string",
-        description: "Source folder containing Todo markdown files.",
-      },
-      {
-        long: "--author",
-        value_name: "author",
-        value_type: "string",
-        description: "Override import mutation author.",
-      },
-      {
-        long: "--message",
-        value_name: "text",
-        value_type: "string",
-        description: "Override import history message.",
-      },
-    ],
-    run: async (context) => runTodosImportFromRuntime(toImportOptions(context.options), context.global),
-  } satisfies CommandDefinition);
-  api.registerCommand({
-    name: "todos export",
-    action: "todos-export",
-    description: "Export pm items into Todo markdown files.",
-    flags: [
-      {
-        long: "--folder",
-        value_name: "path",
-        value_type: "string",
-        description: "Destination folder for exported Todo markdown files.",
-      },
-    ],
-    run: async (context) => runTodosExportFromRuntime(toExportOptions(context.options), context.global),
-  } satisfies CommandDefinition);
+  // First-party exemplar for the importers capability: registerImporter/
+  // registerExporter create the `todos import` / `todos export` command paths,
+  // and the options object keeps the command description + flags as discoverable
+  // as the previous registerCommand registration.
+  api.registerImporter(
+    "todos",
+    async (context: ImportExportContext) => runTodosImportFromRuntime(toImportOptions(context.options), context.global),
+    {
+      action: "todos-import",
+      description: "Import Todo markdown files into pm items.",
+      flags: [
+        {
+          long: "--folder",
+          value_name: "path",
+          value_type: "string",
+          description: "Source folder containing Todo markdown files.",
+        },
+        {
+          long: "--author",
+          value_name: "author",
+          value_type: "string",
+          description: "Override import mutation author.",
+        },
+        {
+          long: "--message",
+          value_name: "text",
+          value_type: "string",
+          description: "Override import history message.",
+        },
+      ],
+    } satisfies ImportExportRegistrationOptions,
+  );
+  api.registerExporter(
+    "todos",
+    async (context: ImportExportContext) => runTodosExportFromRuntime(toExportOptions(context.options), context.global),
+    {
+      action: "todos-export",
+      description: "Export pm items into Todo markdown files.",
+      flags: [
+        {
+          long: "--folder",
+          value_name: "path",
+          value_type: "string",
+          description: "Destination folder for exported Todo markdown files.",
+        },
+      ],
+    } satisfies ImportExportRegistrationOptions,
+  );
 }
 
 export default {

package/packages/pm-todos/extensions/todos/manifest.json

@@ -3,5 +3,17 @@
   "version": "0.1.0",
   "entry": "./index.js",
   "priority": 0,
-  "capabilities": ["commands", "schema"]
+  "capabilities": [
+    "commands",
+    "schema",
+    "importers"
+  ],
+  "manifest_version": 1,
+  "pm_min_version": "2026.5.0",
+  "activation": {
+    "commands": [
+      "todos export",
+      "todos import"
+    ]
+  }
 }

package/scripts/bundle-cli.mjs

@@ -1,30 +1,134 @@
 #!/usr/bin/env node
 
-import { readFile, rm, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readdir, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { build } from "esbuild";
 
 const repoRoot = process.cwd();
 const entryPoint = path.join(repoRoot, "dist", "cli", "main.js");
 const outputDir = path.join(repoRoot, "dist", "cli-bundle");
+const lockDir = path.join(repoRoot, "dist", ".cli-bundle-build.lock");
 const binPath = path.join(repoRoot, "dist", "cli.js");
+const lockRetryMs = 250;
+const lockTimeoutMs = 120_000;
+const staleLockMs = 10 * 60_000;
+const bundleStaleRetentionMs = 10 * 60_000;
 
-await rm(outputDir, { recursive: true, force: true });
-
-await build({
-  entryPoints: [entryPoint],
-  outdir: outputDir,
-  bundle: true,
-  splitting: true,
-  format: "esm",
-  platform: "node",
-  target: ["node20"],
-  packages: "external",
-  sourcemap: true,
-  entryNames: "[name]",
-  chunkNames: "chunks/[name]-[hash]",
-  logLevel: "warning",
-});
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function acquireBundleBuildLock() {
+  await mkdir(path.dirname(lockDir), { recursive: true });
+  const startedAt = Date.now();
+  while (true) {
+    try {
+      await mkdir(lockDir);
+      return async () => {
+        await rm(lockDir, { recursive: true, force: true });
+      };
+    } catch (error) {
+      if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
+        throw error;
+      }
+      const lockStats = await stat(lockDir).catch((statError) => {
+        if (statError && typeof statError === "object" && "code" in statError && statError.code === "ENOENT") {
+          return null;
+        }
+        throw statError;
+      });
+      if (!lockStats) {
+        continue;
+      }
+      if (Date.now() - lockStats.mtimeMs > staleLockMs) {
+        const staleCandidateDir = `${lockDir}.stale.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+        try {
+          await rename(lockDir, staleCandidateDir);
+          await rm(staleCandidateDir, { recursive: true, force: true });
+        } catch (staleError) {
+          if (
+            !staleError ||
+            typeof staleError !== "object" ||
+            !("code" in staleError) ||
+            !["ENOENT", "EEXIST", "ENOTEMPTY"].includes(String(staleError.code))
+          ) {
+            throw staleError;
+          }
+        }
+        continue;
+      }
+      if (Date.now() - startedAt > lockTimeoutMs) {
+        throw new Error(`Timed out waiting for bundle build lock at ${lockDir}`);
+      }
+      await sleep(lockRetryMs);
+    }
+  }
+}
+
+async function collectFiles(directory) {
+  const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  });
+  const files = [];
+  for (const entry of entries) {
+    const absolutePath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(absolutePath));
+      continue;
+    }
+    if (entry.isFile() || entry.isSymbolicLink()) {
+      files.push(absolutePath);
+    }
+  }
+  return files;
+}
+
+async function removeStaleBundleFiles(outputs) {
+  const expectedFiles = new Set(
+    Object.keys(outputs).map((outputPath) => path.resolve(repoRoot, outputPath)),
+  );
+  const existingFiles = await collectFiles(outputDir);
+  const now = Date.now();
+  await Promise.all(
+    existingFiles
+      .filter((filePath) => !expectedFiles.has(filePath))
+      .map(async (filePath) => {
+        const fileStats = await lstat(filePath).catch(() => null);
+        if (!fileStats || now - fileStats.mtimeMs < bundleStaleRetentionMs) {
+          return;
+        }
+        await unlink(filePath).catch(() => {});
+      }),
+  );
+}
+
+// Do not delete the live bundle before rebuilding. Agents often run docs,
+// dogfood, and build gates concurrently in one checkout; removing this folder
+// creates a transient broken `dist/cli.js` runtime.
+const releaseBundleBuildLock = await acquireBundleBuildLock();
+try {
+  const buildResult = await build({
+    entryPoints: [entryPoint],
+    outdir: outputDir,
+    bundle: true,
+    splitting: true,
+    format: "esm",
+    platform: "node",
+    target: ["node20"],
+    packages: "external",
+    sourcemap: true,
+    metafile: true,
+    entryNames: "[name]",
+    chunkNames: "chunks/[name]-[hash]",
+    logLevel: "warning",
+  });
+  await removeStaleBundleFiles(buildResult.metafile.outputs);
+} finally {
+  await releaseBundleBuildLock();
+}
 
 const binSource = await readFile(binPath, "utf8");
 const sourceImport = 'await import("./cli/main.js")';

package/dist/cli-bundle/chunks/activity-OWYSUZOY.js

@@ -1,17 +0,0 @@
-import {
-  runActivity
-} from "./chunk-L2FXEKDB.js";
-import "./chunk-LRBOHPUE.js";
-import "./chunk-JFWUHHS2.js";
-import "./chunk-SEXQN4KL.js";
-import "./chunk-BUPWJ3IJ.js";
-import "./chunk-4AEZR5EJ.js";
-import "./chunk-CEFIVZPG.js";
-import "./chunk-MD7K4JYF.js";
-import "./chunk-WDPXDQFG.js";
-import "./chunk-PVNQLCIS.js";
-import "./chunk-LSXGH6NE.js";
-export {
-  runActivity
-};
-//# sourceMappingURL=activity-OWYSUZOY.js.map