@unbrained/pm-cli 2026.6.24 → 2026.7.1

package/dist/cli-bundle/chunks/{chunk-N5B6WZC5.js → chunk-3XZCOZ5J.js}

@@ -1,5 +1,5 @@
 
-!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]="eca9038d-c58d-57e0-9b7d-a32f72ff68b8")}catch(e){}}();
+!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]="a2588018-8995-5c3e-b957-a7afc236729b")}catch(e){}}();
 import {
   LINKED_TEST_PM_CONTEXT_MODE_VALUES,
   LINKED_TEST_PROTECTED_ENV_KEYS,
@@ -15,27 +15,24 @@ import {
   parseLinkedTestMinLines,
   parseLinkedTestRegexList,
   parseLinkedTestStringList
-} from "./chunk-AYPQUFCX.js";
+} from "./chunk-EJUDVUYZ.js";
 import {
   createStdinTokenResolver,
   parseCsvKv,
   parseOptionalNumber
-} from "./chunk-KIEAK7YE.js";
+} from "./chunk-ZRP4VG5U.js";
 import {
   runInit
-} from "./chunk-EWRSXOIZ.js";
+} from "./chunk-V3NOKJF2.js";
 import {
   locateItem,
   mutateItem,
   readLocatedItem
-} from "./chunk-KJZOSF7J.js";
-import {
-  resolveItemTypeRegistry
-} from "./chunk-TKPP4GOO.js";
+} from "./chunk-JSU5P7VS.js";
 import {
   compareTimestampStrings,
   nowIso
-} from "./chunk-FMWW2JDU.js";
+} from "./chunk-AXIDKKAT.js";
 import {
   EXIT_CODE,
   ITEM_FILE_EXTENSIONS,
@@ -46,9 +43,10 @@ import {
   pathExists,
   readSettings,
   resolveGlobalPmRoot,
+  resolveItemTypeRegistry,
   resolvePmRoot,
   stableValueEquals
-} from "./chunk-VSAABFGQ.js";
+} from "./chunk-7R4QEMZZ.js";
 
 // dist/cli/commands/test.js
 import { spawn } from "node:child_process";
@@ -620,23 +618,24 @@ function extractPmInvocationArgsFromSegment(segment) {
   if (executable === "node" && args.length > 0 && isPmCliScriptToken(args[0])) {
     return args.slice(1);
   }
+  return extractPackageManagerPmInvocationArgs(executable, args);
+}
+function extractPackageManagerPmInvocationArgs(executable, args) {
+  const parsed = parsePackageManagerPmInvocation(executable, args);
+  if (!parsed || !isPmExecutableToken(parsed.command) && !isPmCliPackageToken(parsed.command)) {
+    return null;
+  }
+  return parsed.args;
+}
+function parsePackageManagerPmInvocation(executable, args) {
   if (executable === "npx" || executable === "bunx") {
-    const parsed = parseNpxCommand(args);
-    if (parsed && (isPmExecutableToken(parsed.command) || isPmCliPackageToken(parsed.command))) {
-      return parsed.args;
-    }
+    return parseNpxCommand(args);
   }
   if (executable === "pnpm") {
-    const parsed = parsePnpmDlxCommand(args);
-    if (parsed && (isPmExecutableToken(parsed.command) || isPmCliPackageToken(parsed.command))) {
-      return parsed.args;
-    }
+    return parsePnpmDlxCommand(args);
   }
   if (executable === "npm") {
-    const parsed = parseNpmExecCommand(args);
-    if (parsed && (isPmExecutableToken(parsed.command) || isPmCliPackageToken(parsed.command))) {
-      return parsed.args;
-    }
+    return parseNpmExecCommand(args);
   }
   return null;
 }
@@ -780,29 +779,21 @@ function segmentInvokesUnsafeDirectTestRunner(normalizedSegment) {
     return true;
   }
   if (executable === "node") {
-    return args.includes("--test") || args.some((arg) => arg === "vitest" || arg === "vitest.mjs" || arg.endsWith("/vitest") || arg.endsWith("/vitest.mjs"));
+    return nodeArgsInvokeUnsafeDirectTestRunner(args);
   }
+  return packageManagerInvokesUnsafeDirectTestRunner(executable, args);
+}
+function nodeArgsInvokeUnsafeDirectTestRunner(args) {
+  return args.includes("--test") || args.some((arg) => arg === "vitest" || arg === "vitest.mjs" || arg.endsWith("/vitest") || arg.endsWith("/vitest.mjs"));
+}
+function packageManagerInvokesUnsafeDirectTestRunner(executable, args) {
   if (executable === "npx" || executable === "bunx") {
     return isDirectTestRunnerSubcommand(parseNpxCommand(args)?.command);
   }
-  if (executable === "pnpm") {
-    const dlx = parsePnpmDlxCommand(args);
-    if (isDirectTestRunnerSubcommand(dlx?.command)) {
-      return true;
-    }
-    return firstDirectTestRunnerSubcommand(executable, args) === "vitest";
+  if (executable === "pnpm" || executable === "npm") {
+    return isDirectTestRunnerSubcommand(parsePackageManagerPmInvocation(executable, args)?.command) || firstDirectTestRunnerSubcommand(executable, args) === "vitest";
   }
-  if (executable === "npm") {
-    const exec = parseNpmExecCommand(args);
-    if (isDirectTestRunnerSubcommand(exec?.command)) {
-      return true;
-    }
-    return firstDirectTestRunnerSubcommand(executable, args) === "vitest";
-  }
-  if (executable === "yarn" || executable === "bun") {
-    return firstDirectTestRunnerSubcommand(executable, args) === "vitest";
-  }
-  return false;
+  return (executable === "yarn" || executable === "bun") && firstDirectTestRunnerSubcommand(executable, args) === "vitest";
 }
 function assertSandboxSafeTestRunnerCommand(command) {
   const normalized = normalizeCommandForValidation(command);
@@ -821,48 +812,46 @@ function getRuntimeSafetySkipReason(command) {
 function parseAddEntries(raw) {
   if (!raw)
     return [];
-  return raw.map((entry) => {
-    const trimmed = entry.trim();
-    const kv = looksLikeStructuredLinkedTestEntry(trimmed) ? normalizeStructuredLinkedTestEntry(parseCsvKv(entry, "--add"), "--add") : { command: trimmed };
-    const command = kv.command?.trim() || void 0;
-    const filePath = kv.path?.trim() || void 0;
-    if (!command) {
-      throw new PmCliError("--add requires command=<value> or a bare command (path=<value> is optional metadata)", EXIT_CODE.USAGE);
-    }
-    const sharedHostSafe = parseLinkedTestBoolean(kv.shared_host_safe?.trim(), "--add", "shared_host_safe");
-    if (command) {
-      assertNoRecursiveTestAllCommand(command);
-      assertSandboxSafeTestRunnerCommand(command);
-    }
-    const timeoutSecondsRaw = kv.timeout_seconds?.trim();
-    const timeoutAliasRaw = kv.timeout?.trim();
-    if (timeoutSecondsRaw && timeoutAliasRaw && timeoutSecondsRaw !== timeoutAliasRaw) {
-      throw new PmCliError("--add timeout and timeout_seconds must match when both are provided", EXIT_CODE.USAGE);
-    }
-    const timeoutRaw = timeoutSecondsRaw ?? timeoutAliasRaw;
-    const timeoutSeconds = timeoutRaw === void 0 ? void 0 : Math.floor(parseOptionalNumber(timeoutRaw, "timeout_seconds"));
-    const envSet = parseLinkedTestEnvSet(kv.env_set?.trim(), "--add");
-    const envClear = parseLinkedTestEnvClear(kv.env_clear?.trim(), "--add");
-    const pmContextMode = parseLinkedTestContextMode(kv.pm_context_mode?.trim(), "--add");
-    return {
-      command,
-      path: filePath,
-      scope: ensureScope(kv.scope),
-      timeout_seconds: timeoutSeconds,
-      pm_context_mode: pmContextMode,
-      env_set: envSet,
-      env_clear: envClear,
-      shared_host_safe: sharedHostSafe,
-      assert_stdout_contains: parseLinkedTestStringList(kv.assert_stdout_contains?.trim()),
-      assert_stdout_regex: parseLinkedTestRegexList(kv.assert_stdout_regex?.trim(), "--add", "assert_stdout_regex"),
-      assert_stderr_contains: parseLinkedTestStringList(kv.assert_stderr_contains?.trim()),
-      assert_stderr_regex: parseLinkedTestRegexList(kv.assert_stderr_regex?.trim(), "--add", "assert_stderr_regex"),
-      assert_stdout_min_lines: parseLinkedTestMinLines(kv.assert_stdout_min_lines?.trim(), "--add"),
-      assert_json_field_equals: parseLinkedTestAssertionEqualsMap(kv.assert_json_field_equals?.trim(), "--add"),
-      assert_json_field_gte: parseLinkedTestAssertionGteMap(kv.assert_json_field_gte?.trim(), "--add"),
-      note: kv.note?.trim() || void 0
-    };
-  });
+  return raw.map(parseAddEntry);
+}
+function parseAddEntry(entry) {
+  const trimmed = entry.trim();
+  const kv = looksLikeStructuredLinkedTestEntry(trimmed) ? normalizeStructuredLinkedTestEntry(parseCsvKv(entry, "--add"), "--add") : { command: trimmed };
+  const command = trimLinkedTestEntryField(kv.command);
+  if (!command) {
+    throw new PmCliError("--add requires command=<value> or a bare command (path=<value> is optional metadata)", EXIT_CODE.USAGE);
+  }
+  assertNoRecursiveTestAllCommand(command);
+  assertSandboxSafeTestRunnerCommand(command);
+  return {
+    command,
+    path: trimLinkedTestEntryField(kv.path),
+    scope: ensureScope(kv.scope),
+    timeout_seconds: parseLinkedTestTimeoutSeconds(trimLinkedTestEntryField(kv.timeout_seconds), trimLinkedTestEntryField(kv.timeout)),
+    pm_context_mode: parseLinkedTestContextMode(trimLinkedTestEntryField(kv.pm_context_mode), "--add"),
+    env_set: parseLinkedTestEnvSet(trimLinkedTestEntryField(kv.env_set), "--add"),
+    env_clear: parseLinkedTestEnvClear(trimLinkedTestEntryField(kv.env_clear), "--add"),
+    shared_host_safe: parseLinkedTestBoolean(trimLinkedTestEntryField(kv.shared_host_safe), "--add", "shared_host_safe"),
+    assert_stdout_contains: parseLinkedTestStringList(trimLinkedTestEntryField(kv.assert_stdout_contains)),
+    assert_stdout_regex: parseLinkedTestRegexList(trimLinkedTestEntryField(kv.assert_stdout_regex), "--add", "assert_stdout_regex"),
+    assert_stderr_contains: parseLinkedTestStringList(trimLinkedTestEntryField(kv.assert_stderr_contains)),
+    assert_stderr_regex: parseLinkedTestRegexList(trimLinkedTestEntryField(kv.assert_stderr_regex), "--add", "assert_stderr_regex"),
+    assert_stdout_min_lines: parseLinkedTestMinLines(trimLinkedTestEntryField(kv.assert_stdout_min_lines), "--add"),
+    assert_json_field_equals: parseLinkedTestAssertionEqualsMap(trimLinkedTestEntryField(kv.assert_json_field_equals), "--add"),
+    assert_json_field_gte: parseLinkedTestAssertionGteMap(trimLinkedTestEntryField(kv.assert_json_field_gte), "--add"),
+    note: trimLinkedTestEntryField(kv.note)
+  };
+}
+function trimLinkedTestEntryField(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function parseLinkedTestTimeoutSeconds(timeoutSecondsRaw, timeoutAliasRaw) {
+  if (timeoutSecondsRaw && timeoutAliasRaw && timeoutSecondsRaw !== timeoutAliasRaw) {
+    throw new PmCliError("--add timeout and timeout_seconds must match when both are provided", EXIT_CODE.USAGE);
+  }
+  const timeoutRaw = timeoutSecondsRaw ?? timeoutAliasRaw;
+  return timeoutRaw === void 0 ? void 0 : Math.floor(parseOptionalNumber(timeoutRaw, "timeout_seconds"));
 }
 function parseAddJsonEntries(raw) {
   if (!raw)
@@ -1224,7 +1213,7 @@ function applySharedHostSafeDefaults(env) {
   }
 }
 function resolveEffectiveLinkedTestDirectives(runtimeDirectives, linkedTest) {
-  const envSet = { ...runtimeDirectives.env_set, ...linkedTest.env_set ?? {} };
+  const envSet = { ...runtimeDirectives.env_set, ...linkedTest.env_set };
   const envClear = [.../* @__PURE__ */ new Set([...runtimeDirectives.env_clear, ...linkedTest.env_clear ?? []])];
   const sharedHostSafe = linkedTest.shared_host_safe ?? runtimeDirectives.shared_host_safe;
   return {
@@ -1391,42 +1380,11 @@ function compareAssertionValues(actual, expected) {
 }
 function evaluateLinkedTestAssertions(linkedTest, stdout, stderr) {
   const failures = [];
-  for (const expected of linkedTest.assert_stdout_contains ?? []) {
-    if (!stdout.includes(expected)) {
-      failures.push(`stdout missing required text: "${expected}"`);
-    }
-  }
-  for (const pattern of linkedTest.assert_stdout_regex ?? []) {
-    try {
-      const regex = new RegExp(pattern, "m");
-      if (!regex.test(stdout)) {
-        failures.push(`stdout failed regex assertion: /${pattern}/m`);
-      }
-    } catch (error) {
-      failures.push(`stdout regex assertion is invalid: /${pattern}/ (${error instanceof Error ? error.message : String(error)})`);
-    }
-  }
-  for (const expected of linkedTest.assert_stderr_contains ?? []) {
-    if (!stderr.includes(expected)) {
-      failures.push(`stderr missing required text: "${expected}"`);
-    }
-  }
-  for (const pattern of linkedTest.assert_stderr_regex ?? []) {
-    try {
-      const regex = new RegExp(pattern, "m");
-      if (!regex.test(stderr)) {
-        failures.push(`stderr failed regex assertion: /${pattern}/m`);
-      }
-    } catch (error) {
-      failures.push(`stderr regex assertion is invalid: /${pattern}/ (${error instanceof Error ? error.message : String(error)})`);
-    }
-  }
-  if (typeof linkedTest.assert_stdout_min_lines === "number") {
-    const lineCount = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).length;
-    if (lineCount < linkedTest.assert_stdout_min_lines) {
-      failures.push(`stdout line count ${lineCount} is below required minimum ${linkedTest.assert_stdout_min_lines}`);
-    }
-  }
+  failures.push(...evaluateContainsAssertions("stdout", stdout, linkedTest.assert_stdout_contains));
+  failures.push(...evaluateRegexAssertions("stdout", stdout, linkedTest.assert_stdout_regex));
+  failures.push(...evaluateContainsAssertions("stderr", stderr, linkedTest.assert_stderr_contains));
+  failures.push(...evaluateRegexAssertions("stderr", stderr, linkedTest.assert_stderr_regex));
+  failures.push(...evaluateStdoutLineCountAssertion(stdout, linkedTest.assert_stdout_min_lines));
   const jsonEqualsAssertions = linkedTest.assert_json_field_equals ?? {};
   const jsonGteAssertions = linkedTest.assert_json_field_gte ?? {};
   const needsJsonAssertions = Object.keys(jsonEqualsAssertions).length > 0 || Object.keys(jsonGteAssertions).length > 0;
@@ -1467,6 +1425,36 @@ function evaluateLinkedTestAssertions(linkedTest, stdout, stderr) {
   }
   return failures;
 }
+function evaluateContainsAssertions(streamName, output, expectedValues) {
+  const failures = [];
+  for (const expected of expectedValues ?? []) {
+    if (!output.includes(expected)) {
+      failures.push(`${streamName} missing required text: "${expected}"`);
+    }
+  }
+  return failures;
+}
+function evaluateRegexAssertions(streamName, output, patterns) {
+  const failures = [];
+  for (const pattern of patterns ?? []) {
+    try {
+      const regex = new RegExp(pattern, "m");
+      if (!regex.test(output)) {
+        failures.push(`${streamName} failed regex assertion: /${pattern}/m`);
+      }
+    } catch (error) {
+      failures.push(`${streamName} regex assertion is invalid: /${pattern}/ (${error instanceof Error ? error.message : String(error)})`);
+    }
+  }
+  return failures;
+}
+function evaluateStdoutLineCountAssertion(stdout, minimum) {
+  if (typeof minimum !== "number") {
+    return [];
+  }
+  const lineCount = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).length;
+  return lineCount < minimum ? [`stdout line count ${lineCount} is below required minimum ${minimum}`] : [];
+}
 var EMPTY_LINKED_TEST_RUN_PATTERNS = [
   { code: "no_projects_matched_filters", regex: /\bNo projects matched the filters\b/i },
   { code: "no_test_files_found", regex: /\bNo test files found\b/i },
@@ -1706,6 +1694,7 @@ async function runTest(id, options, global) {
   const shouldMutate = adds.length > 0 || removes.length > 0;
   let tests = [];
   let itemId;
+  let changed = false;
   if (shouldMutate) {
     const author = resolveAuthor(options.author, settings.author_default);
     const result = await mutateItem({
@@ -1716,7 +1705,9 @@ async function runTest(id, options, global) {
       author,
       message: options.message,
       force: options.force,
+      skipNoop: true,
       mutate(document) {
+        const previous = document.metadata.tests ?? [];
         const next = [...document.metadata.tests ?? []];
         for (const add of adds) {
           const exists = next.some((entry) => entry.command === add.command && entry.path === add.path && entry.scope === add.scope && entry.pm_context_mode === add.pm_context_mode);
@@ -1733,11 +1724,12 @@ async function runTest(id, options, global) {
           }
         }
         document.metadata.tests = next;
-        return { changedFields: ["tests"] };
+        return { changedFields: stableValueEquals(previous, next) ? [] : ["tests"] };
       }
     });
     tests = result.item.tests ?? [];
     itemId = result.item.id;
+    changed = result.changedFields.length > 0;
   } else {
     const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
     if (!located) {
@@ -1842,7 +1834,7 @@ async function runTest(id, options, global) {
     } : void 0,
     fail_on_skipped_triggered: failOnSkippedTriggered ? true : void 0,
     warnings: warnings.length > 0 ? warnings : void 0,
-    changed: shouldMutate,
+    changed,
     count: tests.length
   };
 }
@@ -1884,6 +1876,6 @@ export {
   runTest,
   _testOnlyTestCommand
 };
-//# sourceMappingURL=chunk-N5B6WZC5.js.map
+//# sourceMappingURL=chunk-3XZCOZ5J.js.map
 
-//# debugId=eca9038d-c58d-57e0-9b7d-a32f72ff68b8
+//# debugId=a2588018-8995-5c3e-b957-a7afc236729b