@aefree/pi-plastic 0.4.0 → 0.5.1

package/tests/plastic-branch-create-live.test.ts

@@ -1,78 +0,0 @@
-import assert from "node:assert/strict";
-import { invokeRegisteredTool } from "./pi-tool-harness.ts";
-
-type ToolEnvelope = {
-  ok?: boolean;
-  data?: Record<string, unknown>;
-};
-
-const parseToolEnvelope = (text: string): ToolEnvelope => {
-  const fencedJson = text.match(/```json\s*([\s\S]*?)\s*```/);
-  assert(fencedJson, "Expected a structured JSON tool result.");
-  return JSON.parse(fencedJson[1]) as ToolEnvelope;
-};
-
-const workspace = process.env.PI_PLASTIC_TEST_WORKSPACE?.trim();
-const mutationAllowed = process.env.PI_PLASTIC_ALLOW_MUTATION_TESTS?.trim().toLowerCase() === "true";
-
-if (!workspace || !mutationAllowed) {
-  console.log("SKIP: set PI_PLASTIC_TEST_WORKSPACE and PI_PLASTIC_ALLOW_MUTATION_TESTS=true to run branch mutation tests");
-  process.exit(0);
-}
-
-const status = parseToolEnvelope(await invokeRegisteredTool("plastic_status", { short: true, format: "json" }, workspace));
-assert.equal(status.ok, true, "Expected Plastic status to succeed.");
-const summary = status.data?.summary as Record<string, unknown> | undefined;
-const mergeState = status.data?.mergeState as Record<string, unknown> | undefined;
-assert.equal(summary?.totalPending, 0, "Live branch tests require a clean workspace.");
-assert.equal(mergeState?.hasMergeInProgress, false, "Live branch tests require no merge in progress.");
-
-const currentResult = parseToolEnvelope(await invokeRegisteredTool("plastic_currentBranch", { format: "json" }, workspace));
-const loadedBranch = currentResult.data?.branch;
-assert.equal(typeof loadedBranch, "string", "Expected a loaded Plastic branch.");
-
-const suffix = `${process.pid}-${Date.now().toString(36)}`;
-const parent = `${loadedBranch}/pi-live-parent-${suffix}`;
-const childLeaf = `child-${suffix}`;
-const child = `${parent}/${childLeaf}`;
-const blockedRoot = `/pi-live-root-${suffix}`;
-
-const exists = async (branch: string): Promise<boolean> =>
-  (await invokeRegisteredTool("plastic_branchExists", { branch }, workspace)).trim() === "true";
-
-assert.equal(await exists(parent), false, `Temporary parent already exists: ${parent}`);
-assert.equal(await exists(child), false, `Temporary child already exists: ${child}`);
-assert.equal(await exists(blockedRoot), false, `Temporary root already exists: ${blockedRoot}`);
-
-try {
-  await invokeRegisteredTool("plastic_branchCreate", { branch: parent, comment: "pi-plastic live parent test" }, workspace);
-  assert.equal(await exists(parent), true, "Expected full hierarchical branch creation to succeed.");
-
-  await invokeRegisteredTool("plastic_branchCreate", {
-    branch: childLeaf,
-    parent,
-    comment: "pi-plastic explicit-parent live test",
-  }, workspace);
-  assert.equal(await exists(child), true, "Expected creation beneath an explicit non-loaded parent to succeed.");
-
-  let rootGuarded = false;
-  try {
-    const output = await invokeRegisteredTool("plastic_branchCreate", { branch: blockedRoot }, workspace);
-    rootGuarded = /Refusing to create top-level branch/.test(output);
-  } catch (error) {
-    rootGuarded = /Refusing to create top-level branch/.test(error instanceof Error ? error.message : String(error));
-  }
-  assert.equal(rootGuarded, true, "Expected top-level creation to be rejected without allowRootBranch.");
-  assert.equal(await exists(blockedRoot), false, "Rejected top-level branch must not be created.");
-
-  const branchAfter = parseToolEnvelope(await invokeRegisteredTool("plastic_currentBranch", { format: "json" }, workspace));
-  assert.equal(branchAfter.data?.branch, loadedBranch, "Branch creation must not switch the workspace.");
-} finally {
-  if (await exists(child)) await invokeRegisteredTool("plastic_branchDelete", { branch: child }, workspace);
-  if (await exists(parent)) await invokeRegisteredTool("plastic_branchDelete", { branch: parent }, workspace);
-}
-
-assert.equal(await exists(child), false, "Temporary child branch cleanup failed.");
-assert.equal(await exists(parent), false, "Temporary parent branch cleanup failed.");
-assert.equal(await exists(blockedRoot), false, "Top-level guard cleanup invariant failed.");
-console.log("PASS: live hierarchical branch creation, explicit-parent behavior, top-level guard, and cleanup");

package/tests/plastic-branch-query.test.ts

@@ -1,26 +0,0 @@
-import assert from "node:assert/strict";
-import { __plasticBranchInternals } from "../src/plastic-core.ts";
-
-const { getBranchLeafName, resolveBranchCreationTarget } = __plasticBranchInternals;
-
-assert.equal(getBranchLeafName("/main/feature/test"), "test");
-assert.equal(getBranchLeafName("br:/main/feature/test"), "test");
-assert.equal(getBranchLeafName("br:/main/feature/test@repo@server"), "test");
-assert.equal(getBranchLeafName("test"), "test");
-
-assert.equal(resolveBranchCreationTarget("foo", "/main"), "/main/foo");
-assert.equal(resolveBranchCreationTarget("feature/foo", "/main"), "/main/feature/foo");
-assert.equal(resolveBranchCreationTarget("foo", "/release"), "/release/foo");
-assert.equal(resolveBranchCreationTarget("/release/foo"), "/release/foo");
-assert.equal(resolveBranchCreationTarget("br:/release/foo@repo@server"), "br:/release/foo@repo@server");
-assert.equal(resolveBranchCreationTarget("/foo", undefined, true), "/foo");
-assert.throws(
-  () => resolveBranchCreationTarget("/foo"),
-  /Refusing to create top-level branch \/foo.*allowRootBranch=true/,
-);
-assert.throws(
-  () => resolveBranchCreationTarget("foo"),
-  /relative branch name requires a parent branch/,
-);
-
-console.log("PASS: Plastic branch query normalization tests passed");

package/tests/plastic-branch-status.test.ts

@@ -1,241 +0,0 @@
-import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import { createPlasticBranchStatusExtension } from "../extensions/plastic-branch-status.ts";
-
-type Handler = (event: any, ctx: any) => Promise<void> | void;
-type FakeTimer = { callback: () => void; delay: number; cleared: boolean };
-
-class FooterHarness {
-  handlers = new Map<string, Handler[]>();
-  statuses = new Map<string, string>();
-  statusCalls: Array<[string, string | undefined]> = [];
-  setFooterCalls = 0;
-  readonly ctx = {
-    cwd: "/workspace/nested/project",
-    hasUI: true,
-    ui: {
-      theme: { fg: (color: string, text: string) => `<${color}>${text}</${color}>` },
-      setStatus: (key: string, value: string | undefined) => {
-        this.statusCalls.push([key, value]);
-        if (value === undefined) this.statuses.delete(key);
-        else this.statuses.set(key, value);
-      },
-      setFooter: () => { this.setFooterCalls++; },
-    },
-  };
-  readonly api = {
-    on: (event: string, handler: Handler) => {
-      const handlers = this.handlers.get(event) ?? [];
-      handlers.push(handler);
-      this.handlers.set(event, handlers);
-    },
-    exec: async () => ({ stdout: "", stderr: "", code: 0, killed: false }),
-  };
-
-  async emit(event: string, payload: any = {}): Promise<void> {
-    for (const handler of this.handlers.get(event) ?? []) await handler(payload, this.ctx);
-  }
-}
-
-const workspace = (root: string) => ({
-  kind: "found" as const,
-  value: { root, plasticDir: `${root}/.plastic`, markerPath: `${root}/.plastic/plastic.workspace` },
-});
-
-const timers: FakeTimer[] = [];
-const schedule = (callback: () => void, delay: number): any => {
-  const timer = { callback, delay, cleared: false };
-  timers.push(timer);
-  return timer;
-};
-const clear = (timer: any): void => { timer.cleared = true; };
-const runTimers = async (delay: number): Promise<void> => {
-  const pending = timers.filter((timer) => !timer.cleared && timer.delay === delay);
-  for (const timer of pending) {
-    timer.cleared = true;
-    timer.callback();
-  }
-  await new Promise((resolve) => setImmediate(resolve));
-};
-
-{
-  timers.length = 0;
-  const harness = new FooterHarness();
-  harness.statuses.set("foreign-status", "keep me");
-  let confirmation = "/main/from-cm@repo@server\n";
-  let confirmCount = 0;
-  let watcherClosed = 0;
-  let watcherChange: (() => void) | undefined;
-  let watcherError: (() => void) | undefined;
-
-  createPlasticBranchStatusExtension({
-    discoverWorkspace: async (cwd) => cwd.startsWith("/sibling") ? workspace("/sibling") : workspace("/workspace"),
-    readSelector: async () => "repository repo@server\n  path /\n    smartbranch /main/from-selector\n",
-    watchDirectory: (_path, onChange, onError) => {
-      watcherChange = onChange;
-      watcherError = onError;
-      return { close: () => { watcherClosed++; } };
-    },
-    confirmBranch: async () => { confirmCount++; return confirmation; },
-    setTimeout: schedule,
-    clearTimeout: clear,
-    platform: "linux",
-  })(harness.api as any);
-
-  await harness.emit("session_start", { reason: "startup" });
-  assert.match(harness.statuses.get("plastic-branch") ?? "", /\/main\/from-cm/);
-  assert.equal(harness.statuses.get("foreign-status"), "keep me");
-  assert.equal(harness.setFooterCalls, 0);
-  assert.equal(confirmCount, 1);
-
-  confirmation = "/main/after-selector-replacement@repo@server\n";
-  watcherChange?.();
-  watcherChange?.();
-  await runTimers(150);
-  assert.equal(confirmCount, 2, "coalesced watcher events should run one refresh");
-  assert.match(harness.statuses.get("plastic-branch") ?? "", /after-selector-replacement/);
-  assert.ok(watcherClosed >= 1, "workspace watcher should be rebound after a directory event");
-
-  await harness.emit("tool_result", { toolCallId: "same", toolName: "plastic_switchBranch", input: { workdir: "." }, isError: false });
-  await harness.emit("tool_execution_end", { toolCallId: "same", toolName: "plastic_switchBranch", isError: false });
-  await runTimers(150);
-  assert.equal(confirmCount, 3, "same-workspace Plastic tools should refresh");
-
-  await harness.emit("tool_result", { toolCallId: "sibling", toolName: "plastic_status", input: { workdir: "/sibling" }, isError: false });
-  await harness.emit("tool_execution_end", { toolCallId: "sibling", toolName: "plastic_status", isError: false });
-  await runTimers(150);
-  assert.equal(confirmCount, 3, "sibling-workspace tools must not refresh this footer");
-
-  await harness.emit("tool_result", { toolCallId: "sibling-alias", toolName: "plastic_status", input: { cwd: "/sibling", workdir: "/sibling" }, isError: false });
-  await harness.emit("tool_execution_end", { toolCallId: "sibling-alias", toolName: "plastic_status", isError: false });
-  await runTimers(150);
-  assert.equal(confirmCount, 3, "normalized effective workdir should control sibling filtering");
-
-  watcherError?.();
-  await runTimers(150);
-  assert.equal(confirmCount, 4, "watcher errors should trigger bounded revalidation");
-
-  await harness.emit("session_shutdown", { reason: "reload" });
-  assert.equal(harness.statuses.has("plastic-branch"), false);
-  assert.equal(harness.statuses.get("foreign-status"), "keep me");
-}
-
-{
-  timers.length = 0;
-  const harness = new FooterHarness();
-  createPlasticBranchStatusExtension({
-    discoverWorkspace: async () => workspace("/workspace"),
-    readSelector: async () => "smartbranch /main/selector-only\n",
-    watchDirectory: () => ({ close() {} }),
-    confirmBranch: async () => { throw new Error("cm unavailable"); },
-    setTimeout: schedule,
-    clearTimeout: clear,
-    platform: "linux",
-  })(harness.api as any);
-  await harness.emit("session_start");
-  assert.match(harness.statuses.get("plastic-branch") ?? "", /selector-only/, "selector fallback should survive cm failure");
-}
-
-{
-  timers.length = 0;
-  const harness = new FooterHarness();
-  let aborted = false;
-  createPlasticBranchStatusExtension({
-    discoverWorkspace: async () => workspace("/workspace"),
-    readSelector: async () => "smartbranch \n",
-    watchDirectory: () => ({ close() {} }),
-    confirmBranch: async (_cwd, signal) => new Promise((_resolve, reject) => {
-      signal.addEventListener("abort", () => { aborted = true; reject(new Error("aborted")); }, { once: true });
-    }),
-    setTimeout: schedule,
-    clearTimeout: clear,
-    platform: "win32",
-  })(harness.api as any);
-  const startup = harness.emit("session_start");
-  await new Promise((resolve) => setImmediate(resolve));
-  assert.match(harness.statuses.get("plastic-branch") ?? "", /unavailable/);
-  await harness.emit("session_shutdown", { reason: "quit" });
-  await startup;
-  assert.equal(aborted, true, "shutdown should abort in-flight cm confirmation");
-  assert.equal(harness.statuses.has("plastic-branch"), false);
-}
-
-{
-  timers.length = 0;
-  const harness = new FooterHarness();
-  let markerPresent = true;
-  const watched: Array<{ path: string; change: () => void; closed: boolean }> = [];
-  createPlasticBranchStatusExtension({
-    discoverWorkspace: async () => markerPresent ? workspace("/workspace") : { kind: "not_found" },
-    readSelector: async () => "smartbranch /main/recreated\n",
-    watchDirectory: (path, onChange) => {
-      const handle = { path, change: onChange, closed: false };
-      watched.push(handle);
-      return { close: () => { handle.closed = true; } };
-    },
-    confirmBranch: async () => "/main/recreated@repo@server\n",
-    setTimeout: schedule,
-    clearTimeout: clear,
-    platform: "linux",
-  })(harness.api as any);
-
-  await harness.emit("session_start");
-  markerPresent = false;
-  watched.find((entry) => entry.path.endsWith("/.plastic") && !entry.closed)?.change();
-  await runTimers(150);
-  assert.equal(harness.statuses.has("plastic-branch"), false);
-  const recoveryWatcher = watched.find((entry) => entry.path === "/workspace" && !entry.closed);
-  assert.ok(recoveryWatcher, "workspace root should remain watched while .plastic is temporarily absent");
-
-  markerPresent = true;
-  recoveryWatcher?.change();
-  await runTimers(150);
-  assert.match(harness.statuses.get("plastic-branch") ?? "", /recreated/);
-  assert.ok(watched.some((entry) => entry.path.endsWith("/.plastic") && !entry.closed), "recreated .plastic directory should be rebound");
-  await harness.emit("session_shutdown");
-  assert.ok(watched.every((entry) => entry.closed), "all primary and recovery watchers should close on shutdown");
-}
-
-{
-  timers.length = 0;
-  const harness = new FooterHarness();
-  let innerPresent = true;
-  const watched: Array<{ path: string; change: () => void; closed: boolean }> = [];
-  createPlasticBranchStatusExtension({
-    discoverWorkspace: async () => innerPresent ? workspace("/workspace/inner") : workspace("/workspace"),
-    readSelector: async (path) => path.includes("/inner/") ? "smartbranch /main/inner\n" : "smartbranch /main/outer\n",
-    watchDirectory: (path, onChange) => {
-      const handle = { path, change: onChange, closed: false };
-      watched.push(handle);
-      return { close: () => { handle.closed = true; } };
-    },
-    confirmBranch: async (cwd) => cwd.endsWith("/inner") ? "/main/inner@repo@server\n" : "/main/outer@repo@server\n",
-    setTimeout: schedule,
-    clearTimeout: clear,
-    platform: "linux",
-  })(harness.api as any);
-
-  await harness.emit("session_start");
-  innerPresent = false;
-  watched.find((entry) => entry.path === "/workspace/inner/.plastic" && !entry.closed)?.change();
-  await runTimers(150);
-  assert.match(harness.statuses.get("plastic-branch") ?? "", /\/main\/outer/);
-  const nestedRecovery = watched.find((entry) => entry.path === "/workspace/inner" && !entry.closed);
-  assert.ok(nestedRecovery, "former nested workspace root should remain watched during outer fallback");
-
-  innerPresent = true;
-  nestedRecovery?.change();
-  await runTimers(150);
-  assert.match(harness.statuses.get("plastic-branch") ?? "", /\/main\/inner/);
-  assert.ok(watched.some((entry) => entry.path === "/workspace/inner/.plastic" && !entry.closed));
-  assert.equal(watched.some((entry) => entry.path === "/workspace/inner" && !entry.closed), false);
-  await harness.emit("session_shutdown");
-  assert.ok(watched.every((entry) => entry.closed));
-}
-
-{
-  const source = await readFile(new URL("../extensions/plastic-branch-status.ts", import.meta.url), "utf8");
-  assert.doesNotMatch(source, /\.setFooter\s*\(/, "additive branch extension must never replace Pi's footer");
-}
-
-console.log("PASS: Plastic branch footer lifecycle and composition tests passed");

package/tests/plastic-checkin-path-resolution.ts

@@ -1,219 +0,0 @@
-import { __plasticCheckinInternals, __plasticSwitchInternals } from "../src/plastic-core.ts";
-
-const assert = (condition: boolean, message: string): void =>
-{
-    if (!condition)
-    {
-        throw new Error(message);
-    }
-};
-
-const normalizePath = (pathValue: string): string => pathValue.replace(/\\/g, "/").replace(/^[A-Za-z]:/, "");
-const pathMatches = (actualPath: string, expectedPath: string): boolean =>
-{
-    const actual = normalizePath(actualPath);
-    const expected = normalizePath(expectedPath);
-    return actual === expected || actual.endsWith(`/${expected}`);
-};
-
-const main = (): void =>
-{
-    const cwd = "/repo/ws";
-    const machineOutput = [
-        "STATUS 123 Normandie/Repo server",
-        "CH /repo/ws/Assets/Gameplay/Movement.cs False NO_MERGES",
-        "LD /repo/ws/Assets/Gameplay/FakeModifierService.cs False NO_MERGES",
-        "MV /repo/ws/Assets/Gameplay/MockModifierService.cs False NO_MERGES",
-        "CH /repo/ws/ProjectSettings/ProjectSettings.asset False NO_MERGES",
-    ].join("\n");
-
-    const pendingItems = __plasticCheckinInternals.parseMachineReadablePendingItems(machineOutput, cwd);
-    assert(pendingItems.length === 4, "Expected parser to return four pending items.");
-    assert(pendingItems.some((item) => item.kind === "deleted"), "Expected at least one deleted pending item.");
-    assert(pendingItems.some((item) => item.kind === "moved"), "Expected at least one moved pending item.");
-    assert(__plasticCheckinInternals.inferPendingItemKind("CO+RP") === "changed", "Expected CO+RP to classify as changed.");
-
-    const pendingSummary = __plasticCheckinInternals.summarizePendingItems(pendingItems, cwd);
-    assert(pendingSummary.totalPending === 4, "Expected pending summary total count to match parsed items.");
-    assert(pendingSummary.tracked === 4, "Expected tracked count to equal total when no private items exist.");
-    assert(pendingSummary.private === 0, "Expected no private items in initial sample summary.");
-
-    const changedOnly = __plasticCheckinInternals.resolveCheckinPaths([
-        "Assets/Gameplay/Movement.cs",
-    ], pendingItems, cwd);
-    assert(changedOnly.includedPaths.length === 1, "Expected one included path for changed file scope.");
-    assert(pathMatches(changedOnly.includedPaths[0], "Assets/Gameplay/Movement.cs"), "Expected changed file path to be preserved.");
-    assert(changedOnly.shouldApplyChanged === false, "Expected changed-only scope to avoid auto --applychanged.");
-
-    const deletedOnly = __plasticCheckinInternals.resolveCheckinPaths([
-        "Assets/Gameplay/FakeModifierService.cs",
-    ], pendingItems, cwd);
-    assert(deletedOnly.includedPaths.length === 1, "Expected one included path for deleted file scope.");
-    assert(pathMatches(deletedOnly.includedPaths[0], "Assets/Gameplay/FakeModifierService.cs"), "Expected deleted-file scope to preserve the requested path before fallback retry.");
-    assert(deletedOnly.shouldApplyChanged, "Expected deleted-file scope to enable --applychanged.");
-    assert(deletedOnly.fallbackPaths.length === 1 && pathMatches(deletedOnly.fallbackPaths[0], "Assets/Gameplay"),
-           "Expected deleted-file fallback scope to target the parent directory.");
-
-    const directoryScope = __plasticCheckinInternals.resolveCheckinPaths([
-        "Assets/Gameplay",
-    ], pendingItems, cwd);
-    assert(directoryScope.includedPaths.length === 1, "Expected one included path for directory scope.");
-    assert(pathMatches(directoryScope.includedPaths[0], "Assets/Gameplay"), "Expected directory scope to remain stable.");
-    assert(directoryScope.shouldApplyChanged, "Expected directory scope with deleted/moved items to enable --applychanged.");
-
-    const noMatch = __plasticCheckinInternals.resolveCheckinPaths([
-        "Assets/UI/Nope.cs",
-    ], pendingItems, cwd);
-    assert(noMatch.includedPaths.length === 0, "Expected no included paths for unmatched scope.");
-    assert(noMatch.excludedPaths.length === 1, "Expected one excluded path for unmatched scope.");
-    assert(noMatch.excludedPaths[0].reason === "no_pending_changes", "Expected unmatched scope reason to be no_pending_changes.");
-
-    const windowsCwd = "C:/Workspaces/GameProject/ws3";
-    const windowsMachineOutput = [
-        "STATUS 1147 ExampleRepo/game-unity example@server",
-        "CH c:/Workspaces/GameProject/ws3/game-unity/Assets/Game/code/Runtime/Paths.cs False NO_MERGES",
-        "CH c:/Workspaces/GameProject/ws3/game-unity/Assets/Game/code/Editor/Validation/MapGraphValidationBatchTools.cs False NO_MERGES",
-    ].join("\n");
-    const windowsPendingItems = __plasticCheckinInternals.parseMachineReadablePendingItems(windowsMachineOutput, windowsCwd);
-    assert(windowsPendingItems.length === 2, "Expected Windows parser sample to return two pending items.");
-
-    const windowsRelativeScope = __plasticCheckinInternals.resolveCheckinPaths([
-        "game-unity/Assets/Game/code/Runtime/Paths.cs",
-    ], windowsPendingItems, windowsCwd);
-    assert(windowsRelativeScope.includedPaths.length === 1, "Expected Windows relative scope to match pending file despite drive-letter case mismatch.");
-    assert(pathMatches(windowsRelativeScope.includedPaths[0], "game-unity/Assets/Game/code/Runtime/Paths.cs"), "Expected Windows relative scope to keep workspace-relative command path.");
-
-    const windowsAbsoluteScope = __plasticCheckinInternals.resolveCheckinPaths([
-        "C:/Workspaces/GameProject/ws3/game-unity/Assets/Game/code/Runtime/Paths.cs",
-    ], windowsPendingItems, windowsCwd);
-    assert(windowsAbsoluteScope.includedPaths.length === 1, "Expected Windows absolute scope to match pending file despite drive-letter case mismatch.");
-    assert(pathMatches(windowsAbsoluteScope.includedPaths[0], "game-unity/Assets/Game/code/Runtime/Paths.cs"), "Expected Windows absolute scope to collapse back to workspace-relative command path.");
-
-    const windowsDirectoryScope = __plasticCheckinInternals.resolveCheckinPaths([
-        "GAME-UNITY/Assets/Game/code/Editor",
-    ], windowsPendingItems, windowsCwd);
-    assert(windowsDirectoryScope.includedPaths.length === 1, "Expected Windows directory scope to match pending children despite path case differences.");
-    assert(pathMatches(windowsDirectoryScope.includedPaths[0], "GAME-UNITY/Assets/Game/code/Editor"), "Expected Windows directory scope to preserve the requested command path casing.");
-
-    const windowsDuplicateScope = __plasticCheckinInternals.resolveCheckinPaths([
-        "GAME-UNITY/Assets/Game/code/Runtime/Paths.cs",
-        "game-unity/Assets/Game/code/Runtime/Paths.cs",
-    ], windowsPendingItems, windowsCwd);
-    assert(windowsDuplicateScope.includedPaths.length === 1, "Expected Windows duplicate scopes that differ only by case to dedupe to one command path.");
-
-    assert(__plasticCheckinInternals.isSameFilesystemDevice(100, 100), "Expected Darwin case probing to remain on the target filesystem device.");
-    assert(!__plasticCheckinInternals.isSameFilesystemDevice(100, 200), "Expected Darwin case probing to stop before crossing a mount-device boundary.");
-
-    const comparisonPath = "/Volumes/Workspace/Assets/Player.cs";
-    const darwinInsensitiveKey = __plasticCheckinInternals.toPathComparisonKeyFromAbsolutePath(comparisonPath, {
-        platform: "darwin",
-        isDarwinCaseInsensitiveVolume: () => true,
-    });
-    const darwinSensitiveKey = __plasticCheckinInternals.toPathComparisonKeyFromAbsolutePath(comparisonPath, {
-        platform: "darwin",
-        isDarwinCaseInsensitiveVolume: () => false,
-    });
-    assert(darwinInsensitiveKey === comparisonPath.toLowerCase(), "Expected a detected case-insensitive Darwin volume to normalize comparison keys.");
-    assert(darwinSensitiveKey === comparisonPath, "Expected a case-sensitive APFS volume to preserve comparison-key casing.");
-    assert(__plasticCheckinInternals.toPathComparisonKeyFromAbsolutePath("C:/Workspace/Assets/Player.cs", {
-        platform: "darwin",
-        isDarwinCaseInsensitiveVolume: () => false,
-    }) === "c:/workspace/assets/player.cs", "Expected Windows drive paths to remain case-insensitive on every host platform.");
-
-    const gameplayScope = pendingItems.find((item) => item.workspacePath.endsWith("Movement.cs"))?.normalizedPath.replace(/\/Movement\.cs$/, "") ?? "";
-    const scopedPendingItems = __plasticCheckinInternals.filterPendingItemsByScope(
-        pendingItems,
-        gameplayScope.length > 0 ? [gameplayScope] : [],
-    );
-    assert(scopedPendingItems.length === 3, "Expected scope-filter helper to return only pending items under the requested path.");
-
-    const fallbackPaths = __plasticCheckinInternals.buildFallbackScopePaths([
-        "/repo/ws/Assets/Gameplay/Movement.cs",
-        "/repo/ws/Assets/Gameplay/FakeModifierService.cs",
-    ], cwd);
-    assert(fallbackPaths.length === 1 && pathMatches(fallbackPaths[0], "Assets/Gameplay"), "Expected fallback paths to collapse to the common parent scope.");
-
-    const normalizedDiffRevision = __plasticCheckinInternals.normalizeDiffFileRevisionSpec(
-        "Assets/Gameplay/Movement.cs",
-        "cs:947",
-    );
-    assert(normalizedDiffRevision === "Assets/Gameplay/Movement.cs#cs:947", "Expected diff-file revision shorthand to be expanded with path scope.");
-
-    const numericDiffRevision = __plasticCheckinInternals.normalizeDiffFileRevisionSpec(
-        "Assets/Gameplay/Movement.cs",
-        "947",
-    );
-    assert(numericDiffRevision === "Assets/Gameplay/Movement.cs#cs:947", "Expected numeric diff-file revision shorthand to normalize to cs: selector.");
-
-    const scopedRevision = __plasticCheckinInternals.normalizeDiffFileRevisionSpec(
-        "Assets/Gameplay/Movement.cs",
-        "Assets/Gameplay/Movement.cs#cs:947",
-    );
-    assert(scopedRevision === "Assets/Gameplay/Movement.cs#cs:947", "Expected already scoped revision to remain unchanged.");
-
-    assert(__plasticCheckinInternals.isUnscopedDiffRevisionSpec("cs:947"), "Expected cs selector without file scope to be detected as unscoped.");
-    assert(__plasticCheckinInternals.isUnscopedDiffRevisionSpec("947"), "Expected numeric selector without file scope to be detected as unscoped.");
-    assert(!__plasticCheckinInternals.isUnscopedDiffRevisionSpec("Assets/Gameplay/Movement.cs#cs:947"), "Expected file-qualified selector not to be treated as unscoped.");
-
-    assert(__plasticCheckinInternals.isGitUnknownOptionLabelError("error: unknown option `label'"), "Expected backtick-style git unknown-option error to be detected.");
-    assert(__plasticCheckinInternals.isGitUnknownOptionLabelError("error: unknown option 'label'"), "Expected single-quote-style git unknown-option error to be detected.");
-    assert(!__plasticCheckinInternals.isGitUnknownOptionLabelError("fatal: unrelated error"), "Expected unrelated git errors not to match label-option detector.");
-
-    assert(__plasticCheckinInternals.isRevisionNotFoundError("The specified revision was not found foo#cs:1"), "Expected revision-not-found detector to match Plastic cat errors.");
-    assert(!__plasticCheckinInternals.isRevisionNotFoundError("fatal: unrelated error"), "Expected unrelated errors not to match revision-not-found detector.");
-
-    const branchSelectorFromRevision = __plasticCheckinInternals.extractBranchSelectorFromRevision("Assets/Gameplay/Movement.cs#br:/dev/task-123");
-    assert(branchSelectorFromRevision === "br:/dev/task-123", "Expected branch selector extraction from file-qualified revision.");
-    assert(__plasticCheckinInternals.extractBranchSelectorFromRevision("Assets/Gameplay/Movement.cs#cs:947") === null, "Expected no branch selector extraction for non-branch revisions.");
-
-    const branchName = __plasticCheckinInternals.extractBranchNameFromSelector("br:/dev/task-123@Repo@server");
-    assert(branchName === "/dev/task-123", "Expected branch selector repository suffix to be removed.");
-    assert(__plasticCheckinInternals.extractBranchNameFromSelector("br:") === null, "Expected invalid branch selector to return null branch name.");
-
-    assert(__plasticSwitchInternals.normalizeBranchSpecForComparison("br:/dev/task-123@Repo@server") === "/dev/task-123", "Expected switch branch normalization to remove br: prefix and repository suffix.");
-    assert(__plasticSwitchInternals.isSameBranchSpec("/dev/task-123", "br:/dev/task-123@Repo@server"), "Expected branch comparison helper to treat equivalent branch specs as equal.");
-    assert(!__plasticSwitchInternals.isSameBranchSpec("/dev/task-123", "/dev/task-124"), "Expected branch comparison helper to detect different branches.");
-
-    const machineOutputWithPrivate = [
-        "STATUS 123 Normandie/Repo server",
-        "PR /repo/ws/todos/059-ready.md False NO_MERGES",
-        "PR /repo/ws/.env.local False NO_MERGES",
-        "PR /repo/ws/src/id_rsa False NO_MERGES",
-    ].join("\n");
-    const pendingItemsWithPrivate = __plasticCheckinInternals.parseMachineReadablePendingItems(machineOutputWithPrivate, cwd);
-    const privateSummary = __plasticCheckinInternals.summarizePendingItems(pendingItemsWithPrivate, cwd);
-    assert(privateSummary.private === 3, "Expected private summary to count private pending items.");
-    assert(privateSummary.tracked === 0, "Expected tracked count to be zero for private-only sample.");
-    assert(privateSummary.privatePaths.some((path) => pathMatches(path, "todos/059-ready.md")), "Expected summary private paths to include the expected markdown file.");
-
-    const privateOnlyProfile = __plasticSwitchInternals.buildSwitchPendingProfile(privateSummary);
-    assert(privateOnlyProfile.hasPrivateOnlyPendingChanges, "Expected switch pending profile to classify private-only pending state.");
-    assert(__plasticSwitchInternals.canSwitchDirectWithPrivateOnlyPending("bring", false, privateOnlyProfile), "Expected private-only bring policy to allow direct unattended switch.");
-    assert(__plasticSwitchInternals.canSwitchDirectWithPrivateOnlyPending("shelve", false, privateOnlyProfile), "Expected private-only shelve policy to allow direct unattended switch.");
-    assert(__plasticSwitchInternals.canSwitchDirectWithPrivateOnlyPending("cancel", true, privateOnlyProfile), "Expected defaulted cancel policy to allow direct private-only switch.");
-    assert(!__plasticSwitchInternals.canSwitchDirectWithPrivateOnlyPending("cancel", false, privateOnlyProfile), "Expected explicit cancel policy to keep private-only switch blocked.");
-
-    assert(__plasticCheckinInternals.getSensitivePrivatePathReason(".env.local") === "sensitive_path:dotenv", "Expected dotenv path to be blocked as sensitive.");
-    assert(__plasticCheckinInternals.getSensitivePrivatePathReason("src/id_rsa") === "sensitive_path:ssh-key", "Expected SSH key path to be blocked as sensitive.");
-    assert(__plasticCheckinInternals.getSensitivePrivatePathReason("todos/059-ready.md") === null, "Expected normal markdown path not to be blocked as sensitive.");
-
-    const autoAddSelection = __plasticCheckinInternals.selectPrivatePathsForAutoAdd(pendingItemsWithPrivate, [], cwd);
-    assert(autoAddSelection.candidatePaths.length === 1, "Expected one safe private auto-add candidate.");
-    assert(pathMatches(autoAddSelection.candidatePaths[0], "todos/059-ready.md"), "Expected private auto-add candidate to keep relative file path.");
-    assert(autoAddSelection.blockedPaths.length === 2, "Expected two sensitive private paths to be blocked from auto-add.");
-
-    const trackedPendingProfile = __plasticSwitchInternals.buildSwitchPendingProfile(pendingSummary);
-    assert(__plasticSwitchInternals.isSwitchBringBlockedForUnattended("bring", trackedPendingProfile), "Expected bring policy to be blocked when tracked pending changes exist.");
-    assert(!__plasticSwitchInternals.isSwitchBringBlockedForUnattended("bring", privateOnlyProfile), "Expected bring policy not to be blocked for private-only pending changes.");
-
-    const legacyPendingSummary = __plasticSwitchInternals.toLegacyPendingSummary(privateSummary);
-    assert(legacyPendingSummary.totalPending === privateSummary.totalPending, "Expected legacy pending summary total count to match detailed summary.");
-    assert(legacyPendingSummary.other >= privateSummary.private, "Expected legacy pending summary to account for private items in other count.");
-
-    assert(__plasticCheckinInternals.isNoChangesWorkspaceCheckinError("Error: There are no changes in the workspace c:/repo/ws"), "Expected no-changes detector to match workspace no-changes errors.");
-    assert(!__plasticCheckinInternals.isNoChangesWorkspaceCheckinError("Error: path is not changed in current workspace"), "Expected no-changes detector not to match path-scope errors.");
-
-    console.log("PASS: plastic checkin path resolution tests passed");
-};
-
-main();

package/tests/plastic-constrained-sampling.test.ts

@@ -1,77 +0,0 @@
-import assert from "node:assert/strict";
-import { loadRegisteredTools } from "./pi-tool-harness.ts";
-
-type JsonSchema = {
-  type?: string;
-  properties?: Record<string, JsonSchema>;
-  required?: string[];
-  additionalProperties?: boolean | JsonSchema;
-  items?: JsonSchema;
-  anyOf?: JsonSchema[];
-};
-
-const collectOpenAiStrictIssues = (schema: JsonSchema, path = "$", issues: string[] = []): string[] => {
-  if (schema.type === "object") {
-    if (schema.additionalProperties !== false) {
-      issues.push(`${path} must set additionalProperties to false`);
-    }
-
-    const propertyNames = Object.keys(schema.properties ?? {});
-    const required = new Set(schema.required ?? []);
-    for (const propertyName of propertyNames) {
-      if (!required.has(propertyName)) {
-        issues.push(`${path}.${propertyName} is optional`);
-      }
-      collectOpenAiStrictIssues(schema.properties![propertyName], `${path}.${propertyName}`, issues);
-    }
-  }
-
-  if (schema.items) {
-    collectOpenAiStrictIssues(schema.items, `${path}[]`, issues);
-  }
-  for (const [index, variant] of (schema.anyOf ?? []).entries()) {
-    collectOpenAiStrictIssues(variant, `${path}.anyOf[${index}]`, issues);
-  }
-
-  return issues;
-};
-
-const main = async (): Promise<void> => {
-  const tools = await loadRegisteredTools();
-  const report = [...tools.values()].map((tool) => {
-    const schema = tool.parameters as JsonSchema;
-    return {
-      name: tool.name,
-      issues: collectOpenAiStrictIssues(schema),
-      constrainedSampling: tool.constrainedSampling,
-    };
-  });
-
-  assert(report.length > 0, "Expected registered Plastic tools to audit.");
-
-  const optedIn = report.filter((entry) => entry.constrainedSampling !== undefined && entry.constrainedSampling !== false);
-  for (const entry of optedIn) {
-    if (entry.constrainedSampling && entry.constrainedSampling.type === "json_schema") {
-      assert.deepEqual(entry.issues, [], `${entry.name} must be OpenAI strict-schema compatible before opting in`);
-    }
-  }
-
-  // Pi 0.82 forwards a strict tool's schema without normalizing it. Every current
-  // Plastic schema has optional fields (at minimum workdir), and TypeBox objects
-  // currently allow unspecified additional properties. Enabling strict sampling
-  // would therefore make direct OpenAI requests fail or require a breaking public
-  // argument-schema redesign.
-  assert.equal(optedIn.length, 0, "No Plastic tool should opt in until its ordinary public schema is strict-compatible.");
-  assert.equal(report.filter((entry) => entry.issues.length === 0).length, 0, "The current catalog should be classified as blocked, not strict-ready.");
-
-  for (const pilotName of ["plastic_status", "plastic_branchExists", "plastic_branchCreate"]) {
-    const pilot = report.find((entry) => entry.name === pilotName);
-    assert(pilot, `Missing pilot tool ${pilotName}`);
-    assert(pilot.issues.some((issue) => issue.includes("additionalProperties")), `${pilotName} should report its closed-object blocker`);
-    assert(pilot.issues.some((issue) => issue.endsWith("workdir is optional")), `${pilotName} should report its optional workdir blocker`);
-  }
-
-  console.log(`PASS: audited ${report.length} Plastic schemas; 0 are currently OpenAI strict-ready`);
-};
-
-void main();