@aefree/pi-plastic 0.4.0 → 0.5.1

package/tests/plastic-diff-workflow.test.ts

@@ -1,86 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { __plasticDiffInternals, __plasticProcessInternals } from "../src/plastic-core.ts";
-
-const root = await mkdtemp(join(tmpdir(), "pi-plastic-diff-"));
-
-try {
-    const { resolveDiffFileRevision, isUnscopedDiffRevisionSpec, runPortableTextDiff, DIFF_OUTPUT_MAX_CHARS, safeTempExtension } = __plasticDiffInternals;
-
-    assert.deepEqual(
-        resolveDiffFileRevision("Assets/Scene.unity"),
-        { supplied: null, kind: "workspace-base", resolved: "Assets/Scene.unity" },
-        "omitting revision should select the workspace-base path",
-    );
-    assert.deepEqual(
-        resolveDiffFileRevision("Assets/Scene.unity", "42"),
-        { supplied: "42", kind: "changeset", resolved: "Assets/Scene.unity#cs:42" },
-        "a number must be a changeset selector, not an item revision",
-    );
-    assert.equal(resolveDiffFileRevision("Assets/Scene.unity", "br:/dev/diff").kind, "branch");
-    assert.equal(resolveDiffFileRevision("Assets/Scene.unity", "revid:123").kind, "global-revision");
-    assert.throws(() => resolveDiffFileRevision("Assets/Scene.unity", "base"), /Unsupported revision 'base'/);
-    assert.throws(() => resolveDiffFileRevision("Assets/Scene.unity", "cs:head"), /Unsupported revision 'cs:head'/);
-    assert.throws(() => resolveDiffFileRevision("Assets/Scene.unity", "cs:br:\/main"), /Unsupported revision/);
-    assert.equal(isUnscopedDiffRevisionSpec("base"), true);
-    assert.equal(isUnscopedDiffRevisionSpec("head"), true);
-    assert.equal(isUnscopedDiffRevisionSpec("cs:42"), true);
-    assert.equal(isUnscopedDiffRevisionSpec("42"), true);
-    assert.equal(isUnscopedDiffRevisionSpec("rev:"), true);
-    assert.equal(isUnscopedDiffRevisionSpec("arbitrary"), true);
-    assert.equal(isUnscopedDiffRevisionSpec("Assets/Scene.unity#cs:42"), false);
-    assert.equal(isUnscopedDiffRevisionSpec("Assets/Scene.unity#br:/main"), false);
-    assert.equal(isUnscopedDiffRevisionSpec("revid:123"), false);
-    assert.equal(safeTempExtension("Assets/My Scene.unity"), ".unity");
-    assert.equal(safeTempExtension("revid:99"), ".tmp");
-    assert.equal(__plasticProcessInternals.resolveDiffExecutable({ PI_PLASTIC_DIFF_EXECUTABLE: "D:/tools/diff.exe" }), "D:/tools/diff.exe");
-
-    const left = join(root, "Unity Scene ünicode.unity");
-    const right = join(root, "Unity Scene ünicode copy.unity");
-    await writeFile(left, "%YAML 1.1\n--- !u!1 &1\nGameObject:\n  m_Name: Before\n", "utf8");
-    await writeFile(right, "%YAML 1.1\n--- !u!1 &1\nGameObject:\n  m_Name: After\n", "utf8");
-    const yamlResult = await runPortableTextDiff(left, right, root, "Assets/Scene.unity (Plastic base)", "Assets/Scene.unity (workspace)");
-    assert.equal(yamlResult.backend, "diff");
-    assert.equal(yamlResult.changed, true);
-    assert.equal(yamlResult.binary, false, "Unity YAML must be treated as text based on bytes, not extension/attributes");
-    assert.match(yamlResult.output, /^--- Assets\/Scene\.unity \(Plastic base\)\n\+\+\+ Assets\/Scene\.unity \(workspace\)/);
-    assert.doesNotMatch(yamlResult.output, new RegExp(root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")), "temporary/local paths must not appear in normalized headers");
-
-    const sameResult = await runPortableTextDiff(left, left, root, "left", "right");
-    assert.equal(sameResult.changed, false);
-    assert.equal(sameResult.binary, false);
-
-    const binaryLeft = join(root, "fixture.asset");
-    const binaryRight = join(root, "fixture-copy.asset");
-    await writeFile(binaryLeft, Buffer.from([0, 1, 2, 3]));
-    await writeFile(binaryRight, Buffer.from([0, 1, 4, 3]));
-    const binaryResult = await runPortableTextDiff(binaryLeft, binaryRight, root, "base", "workspace");
-    assert.equal(binaryResult.changed, true);
-    assert.equal(binaryResult.binary, true);
-    assert.equal(binaryResult.output, "");
-
-    const invalidUtf8Left = join(root, "invalid-utf8-left.asset");
-    const invalidUtf8Right = join(root, "invalid-utf8-right.asset");
-    await writeFile(invalidUtf8Left, Buffer.from([0xff, 0x81, 0x41]));
-    await writeFile(invalidUtf8Right, Buffer.from([0xff, 0x81, 0x42]));
-    const invalidUtf8Result = await runPortableTextDiff(invalidUtf8Left, invalidUtf8Right, root, "base", "workspace");
-    assert.equal(invalidUtf8Result.changed, true);
-    assert.equal(invalidUtf8Result.binary, true, "non-UTF-8 bytes must be reported as binary instead of replacement-decoded text");
-    assert.equal(invalidUtf8Result.output, "");
-
-    const largeLeft = join(root, "large-left.txt");
-    const largeRight = join(root, "large-right.txt");
-    await writeFile(largeLeft, `${"before\n".repeat(12_000)}`, "utf8");
-    await writeFile(largeRight, `${"after\n".repeat(12_000)}`, "utf8");
-    const largeResult = await runPortableTextDiff(largeLeft, largeRight, root, "large base", "large workspace");
-    assert.equal(largeResult.changed, true);
-    assert.equal(largeResult.truncated, true);
-    assert.ok(largeResult.totalChars > DIFF_OUTPUT_MAX_CHARS);
-    assert.match(largeResult.output, /Diff output truncated/);
-
-    console.log("PASS: plastic diff workflow tests passed");
-} finally {
-    await rm(root, { recursive: true, force: true });
-}

package/tests/plastic-dynamic-tool-loading.test.ts

@@ -1,224 +0,0 @@
-import assert from "node:assert/strict";
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { PiToolHarness, type RegisteredTool, type ToolSourceInfo } from "./pi-tool-harness.ts";
-import {
-  BALANCED_ACTIVE_PLASTIC_TOOL_NAMES,
-  PLASTIC_SEARCH_CATALOG,
-  PLASTIC_TOOL_LOADING_MODE_ENV,
-  PLASTIC_TOOL_NAMES,
-  PLASTIC_TOOL_SEARCH_NAME,
-  searchPlasticTools,
-} from "../src/plastic-tool-loading.ts";
-
-const publicToolNames = [...PLASTIC_TOOL_NAMES];
-const foreignSource: ToolSourceInfo = { path: "/extensions/foreign.ts", source: "extension", scope: "project", origin: "package" };
-
-async function withMode<T>(mode: string | undefined, action: () => Promise<T>): Promise<T> {
-  const previous = process.env[PLASTIC_TOOL_LOADING_MODE_ENV];
-  if (mode === undefined) delete process.env[PLASTIC_TOOL_LOADING_MODE_ENV];
-  else process.env[PLASTIC_TOOL_LOADING_MODE_ENV] = mode;
-  try {
-    return await action();
-  } finally {
-    if (previous === undefined) delete process.env[PLASTIC_TOOL_LOADING_MODE_ENV];
-    else process.env[PLASTIC_TOOL_LOADING_MODE_ENV] = previous;
-  }
-}
-
-async function loadHarness(activeTools: string[], branchEntries: unknown[] = [], options: ConstructorParameters<typeof PiToolHarness>[0] = {}): Promise<PiToolHarness> {
-  const harness = new PiToolHarness({ activeTools, branchEntries, ...options });
-  await harness.load();
-  await harness.startSession();
-  return harness;
-}
-
-async function main(): Promise<void> {
-  await withMode(undefined, async () => {
-    const harness = await loadHarness(["read", "foreign_tool", ...publicToolNames]);
-    assert.equal(harness.registry.size, 29, "all 28 public Plastic tools plus the loader should be registered");
-    assert(harness.registry.has(PLASTIC_TOOL_SEARCH_NAME));
-    assert.deepEqual(new Set(harness.getActiveTools()), new Set(["read", "foreign_tool", PLASTIC_TOOL_SEARCH_NAME, ...BALANCED_ACTIVE_PLASTIC_TOOL_NAMES]));
-  });
-
-  await withMode("loader-only", async () => {
-    const harness = await loadHarness(["read", "foreign_tool", ...publicToolNames]);
-    assert.deepEqual(new Set(harness.getActiveTools()), new Set(["read", "foreign_tool", PLASTIC_TOOL_SEARCH_NAME]));
-  });
-
-  await withMode("all-active", async () => {
-    const harness = await loadHarness(["read", "foreign_tool", ...publicToolNames]);
-    assert.deepEqual(new Set(harness.getActiveTools()), new Set(["read", "foreign_tool", ...publicToolNames]), "all-active should expose all 28 current Plastic tools without the new loader");
-  });
-
-  await withMode("balanced", async () => {
-    const extensionPath = fileURLToPath(new URL("../index.ts", import.meta.url));
-    const relativeSource: ToolSourceInfo = {
-      path: "./index.ts",
-      source: "local",
-      scope: "project",
-      origin: "cli",
-      baseDir: dirname(extensionPath),
-    };
-    const harness = await loadHarness(["read", ...publicToolNames], [], { extensionSourceInfo: relativeSource });
-    assert.deepEqual(new Set(harness.getActiveTools()), new Set(["read", PLASTIC_TOOL_SEARCH_NAME, ...BALANCED_ACTIVE_PLASTIC_TOOL_NAMES]), "relative configured extension paths should resolve to the package-owned source");
-    const result = await harness.registry.get(PLASTIC_TOOL_SEARCH_NAME)!.execute("loader", { toolNames: ["plastic_branchList"] });
-    assert.deepEqual(result.details.added, ["plastic_branchList"], "relative-path provenance should still allow deferred activation");
-  });
-
-  assert.deepEqual(searchPlasticTools({ toolNames: ["plastic_branchDelete"] }).map((match) => match.name), ["plastic_branchDelete"], "exact public names should select one known tool");
-  assert(searchPlasticTools({ query: "shelveset" }).every((match) => match.name.includes("shelveset")), "keyword search should find the requested capability");
-  assert.equal(searchPlasticTools({ query: "branch", limit: 99 }).length, 4, "search results should have a hard upper bound");
-  assert.deepEqual(searchPlasticTools({ query: "branch", limit: 3 }).map((match) => match.name), ["plastic_branchList", "plastic_branchExists", "plastic_currentBranch"], "ambiguous branch searches should prioritize inspection and query tools when multiple results are requested");
-  assert.deepEqual(searchPlasticTools({ query: "list available branches" }).map((match) => match.name), ["plastic_branchList"], "multi-term branch discovery should not activate unrelated list tools");
-  assert.deepEqual(searchPlasticTools({ query: "list branches in a specified workspace read-only", limit: 1 }).map((match) => match.name), ["plastic_branchList"], "the first capability domain should outrank incidental workspace context");
-  assert.deepEqual(searchPlasticTools({ query: "find existing code reviews" }).map((match) => match.name), ["plastic_codeReviewFind"], "contextual review discovery should select the smallest sufficient query tool");
-  assert.deepEqual(searchPlasticTools({ query: "what changed" }).map((match) => match.name), ["plastic_status"], "changed-file questions should route to status rather than GUI-capable diff commands");
-  const diffMatches = searchPlasticTools({ query: "diff" }).map((match) => match.name);
-  assert(!diffMatches.includes("plastic_diff"), "the disabled compatibility diff alias must never be executable through search");
-  assert.deepEqual(diffMatches.slice(0, 2), ["plastic_diffFile", "plastic_diffRevisions"], "generic diff searches should prefer the common workspace-file route before advanced revision comparison");
-  assert.deepEqual(searchPlasticTools({ query: "workspace diff" }).map((match) => match.name), ["plastic_diffFile"], "workspace diff intent should select the file diff tool");
-  assert.deepEqual(searchPlasticTools({ query: "compare revisions" }).map((match) => match.name), ["plastic_diffRevisions"], "explicit revision comparison should select the advanced tool");
-  assert.deepEqual(searchPlasticTools({ toolNames: ["plastic_diff"] }).map((match) => match.name), [], "the disabled diff alias must not be exactly selectable");
-  assert.deepEqual(searchPlasticTools({ toolNames: ["plastic_workspaceCreate"] }).map((match) => match.name), [], "workspace creation must not be discoverable until paired cleanup is available");
-  assert.deepEqual(searchPlasticTools({ toolNames: ["foreign_tool"] }).map((match) => match.name), [], "unknown names must not be selectable");
-  assert.equal(searchPlasticTools({ toolNames: ["plastic_branchDelete", "plastic_branchCreate", "plastic_branchList", "plastic_currentBranch"] }).length, 4, "up to four exact names should all be selected when no limit is supplied");
-
-  await withMode("loader-only", async () => {
-    const harness = await loadHarness(["read", "foreign_tool"]);
-    const loader = harness.registry.get(PLASTIC_TOOL_SEARCH_NAME)!;
-
-    const browseCallsBefore = harness.setActiveToolsCalls.length;
-    for (const query of [undefined, "Unity Version Control", "version control", "UVCS", "VCS"]) {
-      const browse = await loader.execute("loader", query === undefined ? {} : { query });
-      assert.equal(browse.details.browse, true, `${String(query)} should provide a browse response`);
-      assert.match(browse.content[0].text, /Browse Plastic capabilities/, "browse output should give concise recovery categories");
-    }
-    assert.equal(harness.setActiveToolsCalls.length, browseCallsBefore, "browse and recovery responses must not activate tools");
-
-    const setCallsBefore = harness.setActiveToolsCalls.length;
-    const result = await loader.execute("loader", { toolNames: ["plastic_branchDelete", "plastic_branchCreate", "plastic_branchList", "plastic_currentBranch"] });
-    assert.equal(result.details.added.length, 4, "all requested exact tools should activate by default");
-    assert(harness.getActiveTools().includes("read") && harness.getActiveTools().includes("foreign_tool"), "activation must preserve foreign tools");
-    assert.equal(harness.setActiveToolsCalls.length, setCallsBefore + 1, "new matches should be activated once");
-    assert.match(result.content[0].text, /Confirm the full branch path/, "loader results should return selected safety guidance");
-
-    const repeatCallsBefore = harness.setActiveToolsCalls.length;
-    const repeat = await loader.execute("loader", { toolNames: ["plastic_branchDelete"] });
-    assert.deepEqual(repeat.details.alreadyActive, ["plastic_branchDelete"]);
-    assert.equal(harness.setActiveToolsCalls.length, repeatCallsBefore, "already-active matches must not replace the active set");
-
-    const noMatchCallsBefore = harness.setActiveToolsCalls.length;
-    const noMatch = await loader.execute("loader", { toolNames: ["unknown_tool"] });
-    assert.deepEqual(noMatch.details.matches, []);
-    assert.deepEqual(noMatch.details.unknownToolNames, ["unknown_tool"]);
-    assert.match(noMatch.content[0].text, /unknown_tool/, "unknown exact requests must be reported clearly");
-    assert.equal(harness.setActiveToolsCalls.length, noMatchCallsBefore, "no-match searches must not change active tools");
-
-    const disabledDiff = await loader.execute("loader", { toolNames: ["plastic_diff"] });
-    assert.deepEqual(disabledDiff.details.matches, []);
-    assert.deepEqual(disabledDiff.details.unavailableToolNames, ["plastic_diff"], "the compatibility diff alias must be reported as unavailable rather than activated");
-  });
-
-  await withMode("loader-only", async () => {
-    const activeBranch = [
-      { type: "message", message: { role: "toolResult", addedToolNames: ["plastic_diff", "plastic_merge", "plastic_branchList", "foreign_tool", "removed_tool"] } },
-    ];
-    const harness = await loadHarness(["read", "foreign_tool", ...publicToolNames], activeBranch);
-    assert(harness.getActiveTools().includes("plastic_diff"), "the disabled compatibility diff alias should remain restorable from active history");
-    assert(harness.getActiveTools().includes("plastic_merge") && harness.getActiveTools().includes("plastic_branchList"), "valid active-branch loader additions should be restored");
-    assert(!harness.getActiveTools().includes("removed_tool"), "unknown historical names must not be restored");
-    assert(harness.getActiveTools().includes("foreign_tool"), "foreign active tools must survive restoration");
-  });
-
-  await withMode("loader-only", async () => {
-    const foreignBranchCreate: RegisteredTool = {
-      name: "plastic_branchCreate",
-      label: "Foreign branch create",
-      description: "Foreign collision",
-      sourceInfo: foreignSource,
-      execute: () => ({}),
-    };
-    const harness = await loadHarness(["read", "plastic_branchCreate"], [], { sourceInfoAvailable: true, foreignTools: [foreignBranchCreate] });
-    assert(harness.getActiveTools().includes("plastic_branchCreate"), "sourceInfo ownership must preserve a name-colliding foreign active tool");
-
-    const loader = harness.registry.get(PLASTIC_TOOL_SEARCH_NAME)!;
-    const callsBefore = harness.setActiveToolsCalls.length;
-    const collision = await loader.execute("loader", { toolNames: ["plastic_branchCreate", "plastic_branchList"] });
-    assert.deepEqual(collision.details.added, ["plastic_branchList"], "only the same-source effective tool may be activated");
-    assert.deepEqual(collision.details.unavailableToolNames, ["plastic_branchCreate"], "foreign collisions should be reported as unavailable from this extension");
-    assert.equal(harness.setActiveToolsCalls.length, callsBefore + 1);
-
-    const restoredHarness = await loadHarness(["read"], [
-      { type: "message", message: { role: "toolResult", addedToolNames: ["plastic_branchCreate", "plastic_branchList"] } },
-    ], { sourceInfoAvailable: true, foreignTools: [foreignBranchCreate] });
-    assert(!restoredHarness.getActiveTools().includes("plastic_branchCreate"), "foreign same-name tools must not be restored from this loader's history");
-    assert(restoredHarness.getActiveTools().includes("plastic_branchList"), "same-source historical loader additions should still restore");
-  });
-
-  await withMode("loader-only", async () => {
-    const compatibilityHarness = await loadHarness(["read", ...publicToolNames], [], { sourceInfoAvailable: false });
-    assert.deepEqual(
-      compatibilityHarness.getActiveTools(),
-      ["read", ...publicToolNames],
-      "without sourceInfo, loader-only mode must preserve the active legacy set exactly",
-    );
-    assert.equal(compatibilityHarness.setActiveToolsCalls.length, 0, "unproven loader ownership must not rewrite the active set");
-
-    const foreignBranchCreate: RegisteredTool = {
-      name: "plastic_branchCreate",
-      label: "Foreign branch create without provenance",
-      description: "Foreign collision",
-      sourceInfo: foreignSource,
-      execute: () => ({}),
-    };
-    const initiallyActive = ["read", "foreign_tool", PLASTIC_TOOL_SEARCH_NAME, "plastic_status", "plastic_branchCreate"];
-    const harness = await loadHarness(initiallyActive, [], { sourceInfoAvailable: false, foreignTools: [foreignBranchCreate] });
-    assert.deepEqual(harness.getActiveTools(), initiallyActive, "without sourceInfo, startup must preserve every active Plastic-named tool");
-    assert.equal(harness.setActiveToolsCalls.length, 0, "without sourceInfo, startup must not defer or otherwise rewrite the active set when the loader is already active");
-
-    const loader = harness.registry.get(PLASTIC_TOOL_SEARCH_NAME)!;
-    const collision = await loader.execute("loader", { toolNames: ["plastic_branchCreate", "plastic_branchList"] });
-    assert.deepEqual(collision.details.matches, ["plastic_branchCreate"], "without provenance, the loader may report only already-active known matches");
-    assert.deepEqual(collision.details.added, [], "without provenance, the loader must not activate inactive Plastic names");
-    assert.deepEqual(collision.details.unavailableToolNames, ["plastic_branchList"]);
-    assert.deepEqual(harness.getActiveTools(), initiallyActive, "a foreign colliding plastic_* tool must not cause deactivation or activation without sourceInfo");
-    assert.equal(harness.setActiveToolsCalls.length, 0, "a no-sourceInfo loader request must not change the active set");
-  });
-
-  for (const mode of ["loader-only", "all-active"] as const) await withMode(mode, async () => {
-    const foreignLoader: RegisteredTool = {
-      name: PLASTIC_TOOL_SEARCH_NAME,
-      label: "Foreign Plastic loader",
-      description: "Foreign collision",
-      sourceInfo: foreignSource,
-      execute: () => ({}),
-    };
-    const foreignBranchList: RegisteredTool = {
-      name: "plastic_branchList",
-      label: "Foreign branch list",
-      description: "Foreign collision from the same source as the foreign loader",
-      sourceInfo: foreignSource,
-      execute: () => ({}),
-    };
-    const active = ["read", PLASTIC_TOOL_SEARCH_NAME, "plastic_branchList", "plastic_status"];
-    const harness = await loadHarness(active, [], { sourceInfoAvailable: true, foreignTools: [foreignLoader, foreignBranchList] });
-    assert.deepEqual(harness.getActiveTools(), active, `${mode} must preserve an active foreign loader and same-source Plastic collision`);
-    assert.equal(harness.setActiveToolsCalls.length, 0, `${mode} must not rewrite tools when this extension does not own the effective loader`);
-  });
-
-  await withMode("loader-only", async () => {
-    const harness = await loadHarness(["read"]);
-    for (const name of PLASTIC_SEARCH_CATALOG.map((entry) => entry.name)) {
-      const tool = harness.registry.get(name)!;
-      assert.equal(tool.promptSnippet, undefined, `${name} should not rebuild the prompt after deferred activation`);
-      assert.equal(tool.promptGuidelines, undefined, `${name} should not add deferred prompt guidance`);
-    }
-    assert(harness.registry.get(PLASTIC_TOOL_SEARCH_NAME)?.promptSnippet, "the always-active loader should explain discovery");
-    assert(harness.registry.get(PLASTIC_TOOL_SEARCH_NAME)?.promptGuidelines?.length, "the always-active loader should retain universal safety guidance");
-  });
-
-  console.log("PASS: plastic dynamic tool loading test succeeded");
-}
-
-void main();

package/tests/plastic-extension-registration.test.ts

@@ -1,34 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-
-function main(): void {
-  const indexText = readFileSync(new URL("../index.ts", import.meta.url), "utf8");
-  const packageManifest = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-  const branchStatusText = readFileSync(new URL("../extensions/plastic-branch-status.ts", import.meta.url), "utf8");
-
-  assert.match(indexText, /parameters:\s*buildParameters\(coreTool\.args\)/, "plastic tools should derive schemas from core args without approval-only parameters");
-  assert.match(indexText, /prepareArguments:\s*config\.prepareArguments/, "plastic tools should wire prepareArguments");
-  assert.match(indexText, /core\.runWithAbortSignal\(signal, async \(\) => coreTool\.execute\(normalizedParams\)\)/, "plastic tools should propagate abort signals into core execution");
-  assert.doesNotMatch(indexText, /authorizationToken|authorizationProvenance|ctx\.ui\.confirm/, "Plastic tool registration must not implement token or UI-confirmation approvals");
-
-  assert.match(indexText, /assignAlias\(input, "message", \["comment", "comments"\]\);/, "plastic_checkin should normalize comment aliases");
-  assert.match(indexText, /assignAlias\(input, "pendingChanges", \["pending_changes"\]\);/, "plastic_switchBranch should normalize pending_changes");
-  assert.match(indexText, /"patch",/, "plastic_patch should be included in registered exports");
-  assert.match(indexText, /"mergeToBranch",/, "plastic_mergeToBranch should be included in registered exports");
-  assert.doesNotMatch(indexText, /"workspaceCreate",/, "plastic_workspaceCreate should remain unregistered until paired cleanup is available");
-  assert.match(indexText, /assignAlias\(input, "toolPath", \["tool_path", "tool"\]\);/, "plastic_patch should normalize toolPath aliases");
-  assert.match(indexText, /assignAlias\(input, "output", \["output_file", "outputFile"\]\);/, "plastic_patch should normalize output aliases");
-  assert.match(indexText, /assignAlias\(input, "titleLike", \["title_like"\]\);/, "plastic_codeReviewFind should normalize title_like");
-  assert.match(indexText, /assignAlias\(input, "keepOnDisk", \["keep_on_disk", "keepOnDisk", "nodisk"\]\);/, "plastic_resolveDeleteChangeConflict should normalize keepOnDisk aliases");
-  assert.match(indexText, /assignAlias\(input, "source", \["sourceBranch", "source_branch", "branch"\]\);/, "plastic_mergeToBranch should normalize source branch aliases");
-  assert.match(indexText, /assignAlias\(input, "cardRef", \["card", "cardCode", "card_code", "codecksCard", "codecks_card"\]\);/, "plastic_mergeToBranch should normalize card aliases");
-  assert.match(indexText, /assignAlias\(input, "source", \["mergeSource", "merge_source"\]\);/, "plastic_finalizeMerge should normalize merge source aliases");
-  assert.match(indexText, /assignAlias\(input, "workdir", \["cwd", "workingDirectory", "working_directory"\]\);/, "plastic tools should normalize workdir aliases");
-  assert.match(indexText, /const enumSchema =/, "plastic tools should expose explicit enum schemas");
-  assert.ok(packageManifest.pi.extensions.includes("./extensions/plastic-branch-status.ts"), "package should register the Plastic branch status extension");
-  assert.doesNotMatch(branchStatusText, /\.setFooter\s*\(/, "Plastic branch status must compose through setStatus rather than replace the footer");
-
-  console.log("PASS: plastic extension registration test succeeded");
-}
-
-main();

package/tests/plastic-live-smoke.test.ts

@@ -1,37 +0,0 @@
-import assert from "node:assert/strict";
-import { resolve } from "node:path";
-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 configuredWorkspace = process.env.PI_PLASTIC_TEST_WORKSPACE?.trim();
-
-if (!configuredWorkspace) {
-  console.log("SKIP: set PI_PLASTIC_TEST_WORKSPACE to run opt-in Plastic live smoke tests");
-  process.exit(0);
-}
-
-const workspace = resolve(configuredWorkspace);
-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 smoke tests require a clean workspace.");
-assert.equal(mergeState?.hasMergeInProgress, false, "Live smoke tests require no merge in progress.");
-
-const currentBranch = parseToolEnvelope(await invokeRegisteredTool("plastic_currentBranch", { format: "json" }, workspace));
-assert.equal(currentBranch.data?.branch, "/main", "Live sandbox must be on /main.");
-
-const mainExists = await invokeRegisteredTool("plastic_branchExists", { branch: "/main" }, workspace);
-assert.equal(mainExists.trim(), "true", "Expected plastic_branchExists to find the full /main path.");
-
-console.log("PASS: read-only Plastic live smoke tests passed for the configured sandbox");

package/tests/plastic-mutation-execution.test.ts

@@ -1,61 +0,0 @@
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { Readable } from "node:stream";
-import { runWithAbortSignal, update } from "../src/plastic-core.ts";
-import { loadRegisteredTools } from "./pi-tool-harness.ts";
-
-const registeredTools = await loadRegisteredTools();
-for (const [name, registeredTool] of registeredTools) {
-  if (!name.startsWith("plastic_") || name === "plastic_tool_search") continue;
-  assert.equal(
-    (registeredTool.parameters as any)?.properties?.authorizationToken,
-    undefined,
-    `${name} must not expose mutation authorization tokens`,
-  );
-}
-
-type SpawnCall = {
-  command: string;
-  args: string[];
-  cwd: string;
-};
-
-function makeSpawn(calls: SpawnCall[], exitCode: number, stderr = "") {
-  return ((command: string, args: readonly string[], options: { cwd: string }) => {
-    calls.push({ command, args: [...args], cwd: options.cwd });
-    const child = new EventEmitter() as any;
-    child.stdout = Readable.from(exitCode === 0 ? ["Updated successfully"] : []);
-    child.stderr = Readable.from(stderr ? [stderr] : []);
-    child.stdin = undefined;
-    child.kill = () => true;
-    process.nextTick(() => child.emit("close", exitCode));
-    return child;
-  }) as any;
-}
-
-const workdir = process.cwd();
-const successfulCalls: SpawnCall[] = [];
-const output = await runWithAbortSignal(
-  undefined,
-  () => update.execute({ workdir }),
-  { spawn: makeSpawn(successfulCalls, 0) },
-);
-assert.equal(output, "Updated successfully");
-assert.deepEqual(successfulCalls, [{
-  command: process.env.PI_PLASTIC_CM_EXECUTABLE?.trim() || "cm",
-  args: ["update", "--dontmerge", "--noinput"],
-  cwd: workdir,
-}], "a directly invoked mutation tool must make one exact cm spawn without approval context");
-
-const failedCalls: SpawnCall[] = [];
-await assert.rejects(
-  runWithAbortSignal(
-    undefined,
-    () => update.execute({ workdir }),
-    { spawn: makeSpawn(failedCalls, 1, "fixture mutation failure") },
-  ),
-  /fixture mutation failure/,
-);
-assert.equal(failedCalls.length, 1, "a failed mutation process must not be retried implicitly");
-
-console.log("PASS: Plastic direct mutation execution tests passed");

package/tests/plastic-patch-command.test.ts

@@ -1,118 +0,0 @@
-import { __plasticPatchInternals } from "../src/plastic-core.ts";
-
-const assert = (condition: boolean, message: string): void =>
-{
-    if (!condition)
-    {
-        throw new Error(message);
-    }
-};
-
-const assertArgs = (actual: string[], expected: string[], message: string): void =>
-{
-    assert(JSON.stringify(actual) === JSON.stringify(expected), `${message}. Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}.`);
-};
-
-const assertThrows = (fn: () => void, expectedMessage: string, message: string): void =>
-{
-    try
-    {
-        fn();
-    }
-    catch (error)
-    {
-        assert(error instanceof Error, `${message}: expected an Error instance.`);
-        assert(error.message.includes(expectedMessage), `${message}: expected message to include '${expectedMessage}', got '${error.message}'.`);
-        return;
-    }
-
-    throw new Error(`${message}: expected function to throw.`);
-};
-
-const main = (): void =>
-{
-    const { buildPatchCommandArgs, resolvePatchToolPath } = __plasticPatchInternals;
-
-    assert(resolvePatchToolPath() === "diff", "Expected patch backend to share the portable diff PATH default.");
-    assert(resolvePatchToolPath(" C:\\gnu\\diff.exe ") === "C:\\gnu\\diff.exe", "Expected an explicit patch backend to override the default.");
-
-    assertArgs(
-        buildPatchCommandArgs({ source: "br:/main/task001" }),
-        ["patch", "br:/main/task001"],
-        "Expected one-spec patch command",
-    );
-
-    assertArgs(
-        buildPatchCommandArgs({ source: "br:/main/task001", clean: true }),
-        ["patch", "br:/main/task001", "--clean"],
-        "Expected clean flag to be included",
-    );
-
-    assertArgs(
-        buildPatchCommandArgs({ source: "br:/main/task001", integration: true }),
-        ["patch", "br:/main/task001", "--integration"],
-        "Expected integration flag to be included",
-    );
-
-    assertArgs(
-        buildPatchCommandArgs({ source: "br:/main/task001", clean: true, integration: true }),
-        ["patch", "br:/main/task001", "--clean", "--integration"],
-        "Expected clean and integration flags in stable order",
-    );
-
-    assertArgs(
-        buildPatchCommandArgs({ source: "cs:2", destination: "cs:4", output: "review.patch" }),
-        ["patch", "cs:2", "cs:4", "--output=review.patch"],
-        "Expected destination before output flag",
-    );
-
-    assertArgs(
-        buildPatchCommandArgs({ source: "br:/main/task001", toolPath: "C:\\gnu\\diff.exe" }),
-        ["patch", "br:/main/task001", "--tool=C:\\gnu\\diff.exe"],
-        "Expected custom diff tool path flag",
-    );
-
-    assertArgs(
-        buildPatchCommandArgs({ source: "br:/main/task001", clean: false, integration: false }),
-        ["patch", "br:/main/task001"],
-        "Expected false booleans to be omitted",
-    );
-
-    assertThrows(
-        () => buildPatchCommandArgs({ source: "" }),
-        "source must be non-empty",
-        "Expected blank source to be rejected",
-    );
-
-    assertThrows(
-        () => buildPatchCommandArgs({ source: "br:/main/task001", destination: "   " }),
-        "destination must be non-empty",
-        "Expected blank destination to be rejected",
-    );
-
-    assertThrows(
-        () => buildPatchCommandArgs({ source: "br:/main/task001", output: "   " }),
-        "output must be non-empty",
-        "Expected blank output to be rejected",
-    );
-
-    assertThrows(
-        () => buildPatchCommandArgs({ source: "br:/main/task001", toolPath: "   " }),
-        "toolPath must be non-empty",
-        "Expected blank toolPath to be rejected",
-    );
-
-    const allArgs = buildPatchCommandArgs({
-        source: "br:/main/task001",
-        destination: "br:/main",
-        output: "review.patch",
-        toolPath: "C:\\gnu\\diff.exe",
-        clean: true,
-        integration: true,
-    });
-    assert(!allArgs.some((arg) => arg === "--apply" || arg.startsWith("--apply=")), "Patch generation helper must not emit --apply.");
-
-    console.log("PASS: plastic patch command tests succeeded");
-};
-
-main();