@unbrained/pm-cli 2026.5.11 → 2026.5.14

package/packages/pm-linked-test-adapters/extensions/linked-test-adapters/index.js

@@ -0,0 +1,101 @@
+import {
+  runTestRunsListPackage,
+  runTestRunsLogsPackage,
+  runTestRunsResumePackage,
+  runTestRunsStatusPackage,
+  runTestRunsStopPackage,
+} from "./runtime.js";
+
+export const manifest = {
+  name: "builtin-linked-test-adapters",
+  version: "0.1.0",
+  entry: "./index.js",
+  priority: 0,
+  capabilities: ["commands", "schema"],
+};
+
+function testRunsCommand() {
+  return {
+    name: "test-runs",
+    action: "test-runs-list",
+    description: "List background linked-test runs.",
+    flags: [
+      { long: "--status", value_name: "value", value_type: "string", description: "Filter by background run status." },
+      { long: "--limit", value_name: "n", value_type: "string", description: "Limit number of runs returned." },
+    ],
+    run: async (context) => runTestRunsListPackage(context.options, context.global),
+  };
+}
+
+function testRunsListCommand() {
+  return {
+    name: "test-runs list",
+    action: "test-runs-list",
+    description: "List background linked-test runs.",
+    flags: [
+      { long: "--status", value_name: "value", value_type: "string", description: "Filter by background run status." },
+      { long: "--limit", value_name: "n", value_type: "string", description: "Limit number of runs returned." },
+    ],
+    run: async (context) => runTestRunsListPackage(context.options, context.global),
+  };
+}
+
+function testRunsStatusCommand() {
+  return {
+    name: "test-runs status",
+    action: "test-runs-status",
+    description: "Show status and health snapshot for a background linked-test run.",
+    arguments: [{ name: "runId", required: true, description: "Background run id." }],
+    run: async (context) => runTestRunsStatusPackage(context.args, context.global),
+  };
+}
+
+function testRunsLogsCommand() {
+  return {
+    name: "test-runs logs",
+    action: "test-runs-logs",
+    description: "Show tailed logs for a background linked-test run.",
+    arguments: [{ name: "runId", required: true, description: "Background run id." }],
+    flags: [
+      { long: "--stream", value_name: "value", value_type: "string", description: "Log stream selector: stdout|stderr|both." },
+      { long: "--tail", value_name: "n", value_type: "string", description: "Tail number of lines per selected stream." },
+    ],
+    run: async (context) => runTestRunsLogsPackage(context.args, context.options, context.global),
+  };
+}
+
+function testRunsStopCommand() {
+  return {
+    name: "test-runs stop",
+    action: "test-runs-stop",
+    description: "Stop a running background linked-test run.",
+    arguments: [{ name: "runId", required: true, description: "Background run id." }],
+    flags: [{ long: "--force", value_type: "boolean", description: "Force-stop via SIGKILL." }],
+    run: async (context) => runTestRunsStopPackage(context.args, context.options, context.global),
+  };
+}
+
+function testRunsResumeCommand() {
+  return {
+    name: "test-runs resume",
+    action: "test-runs-resume",
+    description: "Resume a terminal background linked-test run by starting a new attempt.",
+    arguments: [{ name: "runId", required: true, description: "Background run id." }],
+    flags: [{ long: "--author", value_name: "value", value_type: "string", description: "Resume author override." }],
+    run: async (context) => runTestRunsResumePackage(context.args, context.options, context.global),
+  };
+}
+
+export function activate(api) {
+  api.registerCommand(testRunsCommand());
+  api.registerCommand(testRunsListCommand());
+  api.registerCommand(testRunsStatusCommand());
+  api.registerCommand(testRunsLogsCommand());
+  api.registerCommand(testRunsStopCommand());
+  api.registerCommand(testRunsResumeCommand());
+}
+
+export default {
+  manifest,
+  activate,
+};

package/packages/pm-linked-test-adapters/extensions/linked-test-adapters/index.ts

@@ -0,0 +1,102 @@
+import type { CommandDefinition, ExtensionApi } from "../../../../src/sdk/index.js";
+import {
+  runTestRunsListPackage,
+  runTestRunsLogsPackage,
+  runTestRunsResumePackage,
+  runTestRunsStatusPackage,
+  runTestRunsStopPackage,
+} from "./runtime.js";
+
+export const manifest = {
+  name: "builtin-linked-test-adapters",
+  version: "0.1.0",
+  entry: "./index.js",
+  priority: 0,
+  capabilities: ["commands", "schema"],
+};
+
+function testRunsCommand(): CommandDefinition {
+  return {
+    name: "test-runs",
+    action: "test-runs-list",
+    description: "List background linked-test runs.",
+    flags: [
+      { long: "--status", value_name: "value", value_type: "string", description: "Filter by background run status." },
+      { long: "--limit", value_name: "n", value_type: "string", description: "Limit number of runs returned." },
+    ],
+    run: async (context) => runTestRunsListPackage(context.options, context.global),
+  };
+}
+
+function testRunsListCommand(): CommandDefinition {
+  return {
+    name: "test-runs list",
+    action: "test-runs-list",
+    description: "List background linked-test runs.",
+    flags: [
+      { long: "--status", value_name: "value", value_type: "string", description: "Filter by background run status." },
+      { long: "--limit", value_name: "n", value_type: "string", description: "Limit number of runs returned." },
+    ],
+    run: async (context) => runTestRunsListPackage(context.options, context.global),
+  };
+}
+
+function testRunsStatusCommand(): CommandDefinition {
+  return {
+    name: "test-runs status",
+    action: "test-runs-status",
+    description: "Show status and health snapshot for a background linked-test run.",
+    arguments: [{ name: "runId", required: true, description: "Background run id." }],
+    run: async (context) => runTestRunsStatusPackage(context.args, context.global),
+  };
+}
+
+function testRunsLogsCommand(): CommandDefinition {
+  return {
+    name: "test-runs logs",
+    action: "test-runs-logs",
+    description: "Show tailed logs for a background linked-test run.",
+    arguments: [{ name: "runId", required: true, description: "Background run id." }],
+    flags: [
+      { long: "--stream", value_name: "value", value_type: "string", description: "Log stream selector: stdout|stderr|both." },
+      { long: "--tail", value_name: "n", value_type: "string", description: "Tail number of lines per selected stream." },
+    ],
+    run: async (context) => runTestRunsLogsPackage(context.args, context.options, context.global),
+  };
+}
+
+function testRunsStopCommand(): CommandDefinition {
+  return {
+    name: "test-runs stop",
+    action: "test-runs-stop",
+    description: "Stop a running background linked-test run.",
+    arguments: [{ name: "runId", required: true, description: "Background run id." }],
+    flags: [{ long: "--force", value_type: "boolean", description: "Force-stop via SIGKILL." }],
+    run: async (context) => runTestRunsStopPackage(context.args, context.options, context.global),
+  };
+}
+
+function testRunsResumeCommand(): CommandDefinition {
+  return {
+    name: "test-runs resume",
+    action: "test-runs-resume",
+    description: "Resume a terminal background linked-test run by starting a new attempt.",
+    arguments: [{ name: "runId", required: true, description: "Background run id." }],
+    flags: [{ long: "--author", value_name: "value", value_type: "string", description: "Resume author override." }],
+    run: async (context) => runTestRunsResumePackage(context.args, context.options, context.global),
+  };
+}
+
+export function activate(api: ExtensionApi): void {
+  api.registerCommand(testRunsCommand());
+  api.registerCommand(testRunsListCommand());
+  api.registerCommand(testRunsStatusCommand());
+  api.registerCommand(testRunsLogsCommand());
+  api.registerCommand(testRunsStopCommand());
+  api.registerCommand(testRunsResumeCommand());
+}
+
+export default {
+  manifest,
+  activate,
+};

package/packages/pm-linked-test-adapters/extensions/linked-test-adapters/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "builtin-linked-test-adapters",
+  "version": "0.1.0",
+  "entry": "./index.js",
+  "priority": 0,
+  "capabilities": ["commands", "schema"]
+}

package/packages/pm-linked-test-adapters/extensions/linked-test-adapters/runtime.js

@@ -0,0 +1,142 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
+let runtimeBundle = null;
+let runtimeBundlePromise = null;
+
+async function ensureRuntimeBundle() {
+  if (runtimeBundle) {
+    return runtimeBundle;
+  }
+  if (!runtimeBundlePromise) {
+    runtimeBundlePromise = loadRuntimeBundle();
+  }
+  runtimeBundle = await runtimeBundlePromise;
+  return runtimeBundle;
+}
+
+async function loadRuntimeBundle() {
+  const envRoot = process.env[PM_PACKAGE_ROOT_ENV];
+  if (typeof envRoot !== "string" || envRoot.trim().length === 0) {
+    throw new Error(
+      `builtin-linked-test-adapters requires ${PM_PACKAGE_ROOT_ENV} to locate core SDK runtime exports.`,
+    );
+  }
+  const modulePath = path.join(path.resolve(envRoot.trim()), "dist", "sdk", "runtime.js");
+  try {
+    const sdkLoaded = await import(pathToFileURL(modulePath).href);
+    if (
+      typeof sdkLoaded.runTestRunsList === "function" &&
+      typeof sdkLoaded.runTestRunsStatus === "function" &&
+      typeof sdkLoaded.runTestRunsLogs === "function" &&
+      typeof sdkLoaded.runTestRunsStop === "function" &&
+      typeof sdkLoaded.runTestRunsResume === "function" &&
+      typeof sdkLoaded.PmCliError === "function" &&
+      typeof sdkLoaded.EXIT_CODE === "object" &&
+      sdkLoaded.EXIT_CODE !== null
+    ) {
+      return {
+        sdk: sdkLoaded,
+      };
+    }
+  } catch {
+    // Fall through to deterministic failure message below.
+  }
+  throw new Error(
+    `builtin-linked-test-adapters failed to load test-runs SDK runtime exports from ${modulePath}.`,
+  );
+}
+
+function readStringOption(options, key, aliases = []) {
+  const keys = [key, ...aliases];
+  for (const candidate of keys) {
+    const value = options[candidate];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function readBooleanOption(options, key, aliases = []) {
+  const keys = [key, ...aliases];
+  for (const candidate of keys) {
+    const value = options[candidate];
+    if (value === undefined) {
+      continue;
+    }
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+        return true;
+      }
+      if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") {
+        return false;
+      }
+    }
+  }
+  return undefined;
+}
+
+function requireRunId(bundle, commandName, args) {
+  const runId = args[0];
+  if (typeof runId === "string" && runId.trim().length > 0) {
+    return runId.trim();
+  }
+  throw new bundle.sdk.PmCliError(`${commandName} requires a runId argument.`, bundle.sdk.EXIT_CODE.USAGE);
+}
+
+export async function runTestRunsListPackage(options, global) {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsList(
+    {
+      status: readStringOption(options, "status"),
+      limit: readStringOption(options, "limit"),
+    },
+    global,
+  );
+}
+
+export async function runTestRunsStatusPackage(args, global) {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsStatus(requireRunId(bundle, "test-runs status", args), global);
+}
+
+export async function runTestRunsLogsPackage(args, options, global) {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsLogs(
+    requireRunId(bundle, "test-runs logs", args),
+    {
+      stream: readStringOption(options, "stream"),
+      tail: readStringOption(options, "tail"),
+    },
+    global,
+  );
+}
+
+export async function runTestRunsStopPackage(args, options, global) {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsStop(
+    requireRunId(bundle, "test-runs stop", args),
+    {
+      force: readBooleanOption(options, "force") === true,
+    },
+    global,
+  );
+}
+
+export async function runTestRunsResumePackage(args, options, global) {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsResume(
+    requireRunId(bundle, "test-runs resume", args),
+    {
+      author: readStringOption(options, "author"),
+      noExtensions: global.noExtensions === true,
+    },
+    global,
+  );
+}

package/packages/pm-linked-test-adapters/extensions/linked-test-adapters/runtime.ts

@@ -0,0 +1,173 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { GlobalOptions } from "../../../../src/sdk/index.js";
+
+const PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
+
+interface RuntimeSdkModule {
+  EXIT_CODE: { USAGE: number };
+  PmCliError: new (message: string, exitCode?: number) => Error;
+  runTestRunsList: (options: Record<string, unknown>, global: GlobalOptions) => Promise<unknown>;
+  runTestRunsStatus: (runId: string, global: GlobalOptions) => Promise<unknown>;
+  runTestRunsLogs: (runId: string, options: Record<string, unknown>, global: GlobalOptions) => Promise<unknown>;
+  runTestRunsStop: (runId: string, options: Record<string, unknown>, global: GlobalOptions) => Promise<unknown>;
+  runTestRunsResume: (runId: string, options: Record<string, unknown>, global: GlobalOptions) => Promise<unknown>;
+}
+
+interface RuntimeBundle {
+  sdk: RuntimeSdkModule;
+}
+
+let runtimeBundle: RuntimeBundle | null = null;
+let runtimeBundlePromise: Promise<RuntimeBundle> | null = null;
+
+async function ensureRuntimeBundle(): Promise<RuntimeBundle> {
+  if (runtimeBundle) {
+    return runtimeBundle;
+  }
+  if (!runtimeBundlePromise) {
+    runtimeBundlePromise = loadRuntimeBundle();
+  }
+  runtimeBundle = await runtimeBundlePromise;
+  return runtimeBundle;
+}
+
+async function loadRuntimeBundle(): Promise<RuntimeBundle> {
+  const envRoot = process.env[PM_PACKAGE_ROOT_ENV];
+  if (typeof envRoot !== "string" || envRoot.trim().length === 0) {
+    throw new Error(
+      `builtin-linked-test-adapters requires ${PM_PACKAGE_ROOT_ENV} to locate core SDK runtime exports.`,
+    );
+  }
+  const modulePath = path.join(path.resolve(envRoot.trim()), "dist", "sdk", "runtime.js");
+  try {
+    const sdkLoaded = (await import(pathToFileURL(modulePath).href)) as Partial<RuntimeSdkModule>;
+    if (
+      typeof sdkLoaded.runTestRunsList === "function" &&
+      typeof sdkLoaded.runTestRunsStatus === "function" &&
+      typeof sdkLoaded.runTestRunsLogs === "function" &&
+      typeof sdkLoaded.runTestRunsStop === "function" &&
+      typeof sdkLoaded.runTestRunsResume === "function" &&
+      typeof sdkLoaded.PmCliError === "function" &&
+      typeof sdkLoaded.EXIT_CODE === "object" &&
+      sdkLoaded.EXIT_CODE !== null
+    ) {
+      return {
+        sdk: sdkLoaded as RuntimeSdkModule,
+      };
+    }
+  } catch {
+    // Fall through to deterministic failure message below.
+  }
+  throw new Error(
+    `builtin-linked-test-adapters failed to load test-runs SDK runtime exports from ${modulePath}.`,
+  );
+}
+
+function readStringOption(options: Record<string, unknown>, key: string, aliases: string[] = []): string | undefined {
+  const keys = [key, ...aliases];
+  for (const candidate of keys) {
+    const value = options[candidate];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function readBooleanOption(options: Record<string, unknown>, key: string, aliases: string[] = []): boolean | undefined {
+  const keys = [key, ...aliases];
+  for (const candidate of keys) {
+    const value = options[candidate];
+    if (value === undefined) {
+      continue;
+    }
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+        return true;
+      }
+      if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") {
+        return false;
+      }
+    }
+  }
+  return undefined;
+}
+
+function requireRunId(bundle: RuntimeBundle, commandName: string, args: string[]): string {
+  const runId = args[0];
+  if (typeof runId === "string" && runId.trim().length > 0) {
+    return runId.trim();
+  }
+  throw new bundle.sdk.PmCliError(`${commandName} requires a runId argument.`, bundle.sdk.EXIT_CODE.USAGE);
+}
+
+export async function runTestRunsListPackage(
+  options: Record<string, unknown>,
+  global: GlobalOptions,
+): Promise<unknown> {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsList(
+    {
+      status: readStringOption(options, "status"),
+      limit: readStringOption(options, "limit"),
+    },
+    global,
+  );
+}
+
+export async function runTestRunsStatusPackage(args: string[], global: GlobalOptions): Promise<unknown> {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsStatus(requireRunId(bundle, "test-runs status", args), global);
+}
+
+export async function runTestRunsLogsPackage(
+  args: string[],
+  options: Record<string, unknown>,
+  global: GlobalOptions,
+): Promise<unknown> {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsLogs(
+    requireRunId(bundle, "test-runs logs", args),
+    {
+      stream: readStringOption(options, "stream"),
+      tail: readStringOption(options, "tail"),
+    },
+    global,
+  );
+}
+
+export async function runTestRunsStopPackage(
+  args: string[],
+  options: Record<string, unknown>,
+  global: GlobalOptions,
+): Promise<unknown> {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsStop(
+    requireRunId(bundle, "test-runs stop", args),
+    {
+      force: readBooleanOption(options, "force") === true,
+    },
+    global,
+  );
+}
+
+export async function runTestRunsResumePackage(
+  args: string[],
+  options: Record<string, unknown>,
+  global: GlobalOptions,
+): Promise<unknown> {
+  const bundle = await ensureRuntimeBundle();
+  return bundle.sdk.runTestRunsResume(
+    requireRunId(bundle, "test-runs resume", args),
+    {
+      author: readStringOption(options, "author"),
+      noExtensions: global.noExtensions === true,
+    },
+    global,
+  );
+}

package/packages/pm-linked-test-adapters/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@unbrained/pm-package-linked-test-adapters",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "First-party pm package for optional linked-test run management adapters and reporters.",
+  "homepage": "https://github.com/unbraind/pm-cli/tree/main/packages/pm-linked-test-adapters#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unbraind/pm-cli.git",
+    "directory": "packages/pm-linked-test-adapters"
+  },
+  "bugs": {
+    "url": "https://github.com/unbraind/pm-cli/issues"
+  },
+  "keywords": [
+    "pm-package",
+    "project-management",
+    "linked-tests",
+    "background-runs",
+    "test-runs"
+  ],
+  "pm": {
+    "aliases": [
+      "linked-test-adapters"
+    ],
+    "extensions": [
+      "extensions/linked-test-adapters"
+    ],
+    "catalog": {
+      "display_name": "Linked Test Adapters",
+      "category": "testing",
+      "summary": "Restore optional linked-test run management/reporting command surfaces.",
+      "tags": [
+        "tests",
+        "linked-tests",
+        "background",
+        "reporting"
+      ],
+      "links": {
+        "docs": "https://github.com/unbraind/pm-cli/tree/main/packages/pm-linked-test-adapters#readme",
+        "repository": "https://github.com/unbraind/pm-cli/tree/main/packages/pm-linked-test-adapters",
+        "report": "https://github.com/unbraind/pm-cli/issues"
+      }
+    },
+    "docs": [
+      "README.md"
+    ],
+    "examples": [
+      "README.md"
+    ]
+  }
+}

package/packages/pm-search-advanced/README.md

@@ -0,0 +1,27 @@
+# pm-search-advanced
+
+First-party package that restores optional advanced search surfaces in bare-core `pm`.
+
+## Commands and behavior
+
+- Adds `pm search-advanced` with:
+  - `--mode keyword|semantic|hybrid`
+  - `--include-linked`
+  - `--title-exact`
+  - `--phrase-exact`
+- Adds `pm reindex` with:
+  - `--mode keyword|semantic|hybrid`
+  - `--progress`
+
+## Install
+
+```bash
+pm install search-advanced --project
+```
+
+## Verify
+
+```bash
+pm search-advanced "vector cache" --mode hybrid --limit 5 --json
+pm reindex --mode hybrid --progress --json
+```