@aefree/pi-plastic 0.4.0 → 0.5.1

package/tests/plastic-process-lifecycle.test.ts

@@ -1,148 +0,0 @@
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
-import { __plasticProcessInternals } from "../src/plastic-core.ts";
-
-const assert = (condition: boolean, message: string): void =>
-{
-    if (!condition)
-    {
-        throw new Error(message);
-    }
-};
-
-class FakeChildProcess extends EventEmitter
-{
-    readonly stdout = new PassThrough();
-    readonly stderr = new PassThrough();
-    readonly stdin = new PassThrough();
-    readonly signals: string[] = [];
-    killed = false;
-
-    kill(signal?: NodeJS.Signals): boolean
-    {
-        this.killed = true;
-        this.signals.push(signal ?? "SIGTERM");
-        return true;
-    }
-
-    close(code = 0): void
-    {
-        this.stdout.end();
-        this.stderr.end();
-        this.emit("close", code, null);
-    }
-}
-
-const fakeSpawn = (proc: FakeChildProcess): typeof import("node:child_process").spawn =>
-    (() => proc as unknown as ReturnType<typeof import("node:child_process").spawn>) as typeof import("node:child_process").spawn;
-
-const testExecutableResolutionAndDiagnostics = async (): Promise<void> =>
-{
-    assert(__plasticProcessInternals.resolveCmExecutable({}) === "cm", "Expected cm to be the default Plastic executable.");
-    assert(__plasticProcessInternals.resolveCmExecutable({ PI_PLASTIC_CM_EXECUTABLE: " /tools/cm " }) === "/tools/cm", "Expected PI_PLASTIC_CM_EXECUTABLE to override cm.");
-    assert(__plasticProcessInternals.resolveGitExecutable({ PI_PLASTIC_GIT_EXECUTABLE: "C:/Tools/git.exe" }) === "C:/Tools/git.exe", "Expected PI_PLASTIC_GIT_EXECUTABLE to override git.");
-
-    const proc = new FakeChildProcess();
-    const missingCm = __plasticProcessInternals.spawnAndCollect("cm", ["status"], process.cwd(), undefined, undefined, {
-        spawn: fakeSpawn(proc),
-    });
-    const error = Object.assign(new Error("spawn cm ENOENT"), { code: "ENOENT" });
-    proc.emit("error", error);
-
-    await missingCm.then(
-        () => { throw new Error("Expected a missing executable to reject."); },
-        (reason: unknown) =>
-        {
-            assert(reason instanceof Error && reason.message.includes("PI_PLASTIC_CM_EXECUTABLE"), "Expected missing cm guidance to name PI_PLASTIC_CM_EXECUTABLE.");
-        },
-    );
-
-    const gitProc = new FakeChildProcess();
-    const missingGit = __plasticProcessInternals.spawnAndCollect("git", ["--version"], process.cwd(), undefined, undefined, {
-        spawn: fakeSpawn(gitProc),
-    });
-    gitProc.emit("error", Object.assign(new Error("spawn git ENOENT"), { code: "ENOENT" }));
-    await missingGit.then(
-        () => { throw new Error("Expected a missing Git executable to reject."); },
-        (reason: unknown) =>
-        {
-            assert(reason instanceof Error && reason.message.includes("PI_PLASTIC_GIT_EXECUTABLE"), "Expected missing git guidance to name PI_PLASTIC_GIT_EXECUTABLE.");
-        },
-    );
-};
-
-const testAbortEscalatesUntilTerminalSettlement = async (): Promise<void> =>
-{
-    const proc = new FakeChildProcess();
-    const controller = new AbortController();
-    let scheduledKill: (() => void) | undefined;
-    let clearedTimerCount = 0;
-
-    const resultPromise = __plasticProcessInternals.spawnAndCollect("fake", [], process.cwd(), undefined, controller.signal, {
-        spawn: fakeSpawn(proc),
-        setTimeout: (callback) =>
-        {
-            scheduledKill = callback;
-            return {} as NodeJS.Timeout;
-        },
-        clearTimeout: () =>
-        {
-            clearedTimerCount += 1;
-        },
-    });
-
-    controller.abort();
-    assert(proc.killed, "Expected SIGTERM to mark the fake child as killed.");
-    assert(proc.signals.join(",") === "SIGTERM", "Expected abort to send SIGTERM first.");
-    assert(scheduledKill !== undefined, "Expected abort to schedule escalation.");
-
-    // ChildProcess.killed means only that SIGTERM was sent; a still-running child needs SIGKILL.
-    scheduledKill?.();
-    assert(proc.signals.join(",") === "SIGTERM,SIGKILL", "Expected a non-settled child to receive SIGKILL even after SIGTERM was sent.");
-
-    proc.close();
-    const result = await resultPromise;
-    assert(result.aborted, "Expected abort state to be reported after terminal close.");
-    assert(clearedTimerCount === 1, "Expected the escalation timer to be cleared during cleanup.");
-
-    controller.abort();
-    assert(proc.signals.join(",") === "SIGTERM,SIGKILL", "Expected abort listener cleanup after terminal settlement.");
-};
-
-const testTerminalListenersExistBeforeStdinWrite = async (): Promise<void> =>
-{
-    const proc = new FakeChildProcess();
-    proc.stdin.write = ((_chunk: unknown, _callback?: (error?: Error | null) => void): boolean =>
-    {
-        proc.stdout.end();
-        proc.stderr.end();
-        // Deliberately do not invoke the write callback: terminal error must still settle.
-        proc.emit("error", new Error("stdin-triggered process failure"));
-        return true;
-    }) as typeof proc.stdin.write;
-
-    let thrown: unknown;
-    try
-    {
-        await __plasticProcessInternals.spawnAndCollect("fake", [], process.cwd(), "input", undefined, {
-            spawn: fakeSpawn(proc),
-        });
-    }
-    catch (error)
-    {
-        thrown = error;
-    }
-
-    assert(thrown instanceof Error && thrown.message === "stdin-triggered process failure", "Expected process error raised during stdin write to reject cleanly.");
-    assert(proc.listenerCount("error") === 0 && proc.listenerCount("close") === 0, "Expected terminal listeners to be removed after rejection.");
-};
-
-const main = async (): Promise<void> =>
-{
-    await testExecutableResolutionAndDiagnostics();
-    await testAbortEscalatesUntilTerminalSettlement();
-    await testTerminalListenersExistBeforeStdinWrite();
-    console.log("PASS: plastic process lifecycle tests passed");
-};
-
-void main();

package/tests/plastic-tool-rendering.test.ts

@@ -1,16 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-
-const indexText = readFileSync(new URL("../index.ts", import.meta.url), "utf8");
-
-assert.match(indexText, /const COLLAPSED_RESULT_LINES = 12;/, "plastic tool results should have a compact collapsed preview limit");
-assert.match(indexText, /function renderPlasticCall\(/, "plastic tools should provide custom call rendering");
-assert.match(indexText, /function renderPlasticResult\(/, "plastic tools should provide custom result rendering");
-assert.match(indexText, /renderCall\(args, theme\) \{/, "registered plastic tools should wire renderCall");
-assert.match(indexText, /renderResult\(result, options, theme\) \{/, "registered plastic tools should wire renderResult");
-assert.match(indexText, /options\?\.expanded \? lines\.length : COLLAPSED_RESULT_LINES/, "collapsed result rendering should limit visible output until expansion");
-assert.match(indexText, /ctrl\+o to expand/, "collapsed result rendering should advertise the Ctrl+O expansion shortcut");
-assert.match(indexText, /truncateAnsiLine/, "custom rendering should remain width-safe for long output lines");
-assert.match(indexText, /themed\(theme, "toolOutput", line\)/, "tool output lines should use the toolOutput theme color");
-
-console.log("PASS: plastic tool rendering test succeeded");

package/tests/plastic-tool-validation.ts

@@ -1,153 +0,0 @@
-import { readFileSync } from "fs";
-
-const pass = (msg: string): void => console.log(`PASS: ${msg}`);
-const fail = (msg: string): void => console.log(`FAIL: ${msg}`);
-
-const readText = (fileURL: URL): string => readFileSync(fileURL, "utf8");
-
-const checkRequired = (contents: string, target: string, snippets: string[]): number => {
-  let failures = 0;
-  for (const snippet of snippets) {
-    if (contents.includes(snippet)) {
-      pass(`${target} contains: ${snippet}`);
-    } else {
-      fail(`${target} missing required snippet: ${snippet}`);
-      failures += 1;
-    }
-  }
-  return failures;
-};
-
-const checkForbidden = (contents: string, target: string, patterns: RegExp[]): number => {
-  let failures = 0;
-  for (const pattern of patterns) {
-    if (pattern.test(contents)) {
-      fail(`${target} matched forbidden pattern: ${pattern}`);
-      failures += 1;
-    } else {
-      pass(`${target} does not match: ${pattern}`);
-    }
-  }
-  return failures;
-};
-
-const main = (): void => {
-  let failures = 0;
-
-  const plasticPath = new URL("../src/plastic-core.ts", import.meta.url);
-  const skillPath = new URL("../skills/using-plastic/SKILL.md", import.meta.url);
-  const reviewingPath = new URL("../skills/using-plastic/references/reviewing-changes.md", import.meta.url);
-  const changesetPath = new URL("../skills/using-plastic/references/changeset-operations.md", import.meta.url);
-  const troubleshootingPath = new URL("../skills/using-plastic/references/troubleshooting.md", import.meta.url);
-  const integrationPath = new URL("../skills/using-plastic/references/integration.md", import.meta.url);
-  const bashGuardPath = new URL("../extensions/bash-cm-diff-guard.ts", import.meta.url);
-  const bashMergeGuardPath = new URL("../extensions/bash-cm-merge-guard.ts", import.meta.url);
-
-  const plasticText = readText(plasticPath);
-  failures += checkRequired(plasticText, "pi-plastic/src/plastic-core.ts", [
-    "const BLOCKED_CM_DIFF_MESSAGE",
-    "ensureCmCommandAllowed(args);",
-    'command === "diff"',
-    "export const merge = tool({",
-    "export const mergeToBranch = tool({",
-  "resolveBranchParentName",
-    "export const finalizeMerge = tool({",
-    "export const resolveDeleteChangeConflict = tool({",
-    "export const patch = tool({",
-    "__plasticPatchInternals",
-    "buildPatchCommandArgs",
-    "export const diffRevisions = tool({",
-    "plastic_diff is disabled",
-    "parseMachineReadablePendingItems",
-    "summarizePendingItems",
-    "selectPrivatePathsForAutoAdd",
-    "filterPendingItemsByScope",
-    "isNoChangesWorkspaceCheckinError",
-    "SENSITIVE_PRIVATE_PATH_PATTERNS",
-    "auto-add-private-retry-success",
-    "__plasticSwitchInternals",
-    "normalizeBranchSpecForComparison",
-    "isSwitchBringBlockedForUnattended",
-    "canSwitchDirectWithPrivateOnlyPending",
-    "direct-switch-private-only",
-    "resolveCheckinPaths",
-    "buildFallbackScopePaths",
-    "--nointeractiveresolution",
-    "--mergetype=try",
-    "--automaticresolution=all-",
-    "FILE_CONFLICT",
-    "isMergeInProgressCheckinError",
-    "buildMergeInProgressCheckinMessage",
-    "updateAfter is disabled for unattended safety",
-    '["update", "--dontmerge", "--noinput"]',
-  ]);
-  failures += checkForbidden(plasticText, "pi-plastic/src/plastic-core.ts", [
-    /runCm\(\["diff"/,
-    /runCmRaw\(\["diff"/,
-    /runCm\(\["update"\]/,
-  ]);
-
-  const skillText = readText(skillPath);
-  failures += checkRequired(skillText, "pi-plastic/skills/using-plastic/SKILL.md", [
-    "Never run `cm diff` in Pi.",
-    "plastic_diffRevisions",
-    "plastic_patch",
-    "plastic_merge",
-    "plastic_mergeToBranch",
-  "source branch's Plastic parent branch",
-  ]);
-  failures += checkForbidden(skillText, "pi-plastic/skills/using-plastic/SKILL.md", [
-    /^\s*-\s+plastic_diff\s*$/m,
-  ]);
-
-  const refs = [
-    ["reviewing-changes.md", readText(reviewingPath)],
-    ["changeset-operations.md", readText(changesetPath)],
-    ["troubleshooting.md", readText(troubleshootingPath)],
-    ["integration.md", readText(integrationPath)],
-  ] as const;
-
-  for (const [name, text] of refs) {
-    failures += checkForbidden(text, `pi-plastic/skills/using-plastic/references/${name}`, [
-      /cm diff\s+br:/,
-      /cm diff\s+cs:/,
-      /cm diff\s+lb:/,
-      /cm diff\s+sh:/,
-      /cm diff\s+rev:/,
-      /plastic_diff\(source=/,
-      /list changed files/i,
-    ]);
-  }
-
-  const bashGuardText = readText(bashGuardPath);
-  failures += checkRequired(bashGuardText, "pi-plastic/extensions/bash-cm-diff-guard.ts", [
-    'pi.on("tool_call"',
-    "isBashToolCall",
-    "commandRunsCmDiff",
-    "__bashCmDiffGuardInternals",
-    "block: true",
-    "reason: BLOCK_MESSAGE",
-  ]);
-
-  const bashMergeGuardText = readText(bashMergeGuardPath);
-  failures += checkRequired(bashMergeGuardText, "pi-plastic/extensions/bash-cm-merge-guard.ts", [
-    'pi.on("tool_call"',
-    "isBashToolCall",
-    "commandRunsUnsafeCmMerge",
-    "__bashCmMergeGuardInternals",
-    "plastic_resolveDeleteChangeConflict",
-    "--nointeractiveresolution",
-    "--mergetype=try",
-    "block: true",
-    "reason: BLOCK_MESSAGE",
-  ]);
-
-  if (failures > 0) {
-    console.log(`FAIL: plastic validation failed with ${failures} issue(s)`);
-    process.exit(1);
-  }
-
-  console.log("PASS: plastic validation succeeded");
-};
-
-main();

package/tests/plastic-workspace.test.ts

@@ -1,62 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, mkdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-  discoverPlasticWorkspace,
-  parsePlasticSelector,
-  parsePlasticStatusBranch,
-  sanitizePlasticBranch,
-} from "../src/plastic-workspace.ts";
-
-const fixture = async (name: string): Promise<string> => readFile(new URL(`./fixtures/${name}`, import.meta.url), "utf8");
-
-const root = await mkdtemp(join(tmpdir(), "pi-plastic-workspace-"));
-try {
-  const outer = join(root, "outer");
-  const inner = join(outer, "nested", "inner");
-  const cwd = join(inner, "src", "feature");
-  await mkdir(join(outer, ".plastic"), { recursive: true });
-  await writeFile(join(outer, ".plastic", "plastic.workspace"), "sanitized workspace marker\n");
-  await mkdir(join(inner, ".plastic"), { recursive: true });
-  await writeFile(join(inner, ".plastic", "plastic.workspace"), "nested sanitized marker\n");
-  await mkdir(cwd, { recursive: true });
-
-  const nested = await discoverPlasticWorkspace(cwd);
-  assert.equal(nested.kind, "found");
-  if (nested.kind === "found") assert.equal(nested.value.root, await realpath(inner));
-
-  await rm(join(inner, ".plastic", "plastic.workspace"));
-  const outerResult = await discoverPlasticWorkspace(cwd);
-  assert.equal(outerResult.kind, "found");
-  if (outerResult.kind === "found") assert.equal(outerResult.value.root, await realpath(outer));
-
-  const gitOnly = join(root, "git-only", ".git");
-  await mkdir(gitOnly, { recursive: true });
-  assert.equal((await discoverPlasticWorkspace(join(root, "git-only"))).kind, "not_found");
-
-  const selector = parsePlasticSelector(await fixture("plastic.selector"));
-  assert.deepEqual(selector, {
-    kind: "found",
-    value: { repository: "sanitized-repository@sanitized-server", branch: "/main/feature/footer" },
-  });
-  assert.equal(parsePlasticSelector("repository sample@server\n  path /\n").kind, "not_found");
-  assert.equal(parsePlasticSelector("smartbranch \n").kind, "malformed");
-  assert.equal(parsePlasticSelector("smartbranch /main/bad\u0007branch\n").kind, "malformed");
-
-  const normal = parsePlasticStatusBranch(await fixture("status-normal.txt"));
-  const compact = parsePlasticStatusBranch(await fixture("status-compact.txt"));
-  assert.deepEqual(normal, { kind: "found", value: { branch: "/main/feature/footer" } });
-  assert.deepEqual(compact, normal, "normal and compact status forms should yield the same branch path");
-  assert.deepEqual(parsePlasticStatusBranch("status cs:731\n"), { kind: "found", value: { changesetId: "731" } });
-  assert.equal(parsePlasticStatusBranch("unexpected output\n").kind, "malformed");
-  assert.equal(parsePlasticStatusBranch("\n").kind, "not_found");
-
-  assert.equal(sanitizePlasticBranch(" /main/feature\u0007  footer "), "/main/feature footer");
-  assert.equal(sanitizePlasticBranch("x".repeat(81)), `${"x".repeat(79)}…`);
-  assert.equal(sanitizePlasticBranch("界".repeat(41)), `${"界".repeat(39)}…`);
-} finally {
-  await rm(root, { recursive: true, force: true });
-}
-
-console.log("PASS: Plastic workspace discovery and parser tests passed");

package/tests/repository-search-provider-registration.test.ts

@@ -1,37 +0,0 @@
-import assert from "node:assert/strict";
-import { createPlasticRepositoryProviderExtension, isMissingRepoSearchRuntime } from "../extensions/repository-search-provider.ts";
-
-const records = new WeakMap<object, Map<string, { token: { id: string; nonce: string }; policy: { id: string } }>>();
-let nonce = 0;
-const registry = {
-  register(scope: object, policy: { id: string }) {
-    const scoped = records.get(scope) ?? new Map();
-    if (scoped.has(policy.id)) throw new Error(`duplicate ${policy.id}`);
-    const token = { id: policy.id, nonce: String(++nonce) };
-    scoped.set(policy.id, { token, policy }); records.set(scope, scoped); return token;
-  },
-  unregister(token: { id: string; nonce: string }) {
-    for (const scoped of [records.get(scope)]) {
-      const current = scoped?.get(token.id);
-      if (current?.token.nonce === token.nonce) return scoped!.delete(token.id);
-    }
-    return false;
-  },
-};
-const runtime = { createRepositoryPolicyRegistryV1: () => registry };
-const handlers = new Map<string, Array<(_event: unknown, ctx: any) => Promise<void> | void>>();
-const pi = { on(event: string, handler: (_event: unknown, ctx: any) => Promise<void> | void) { handlers.set(event, [...(handlers.get(event) ?? []), handler]); } };
-createPlasticRepositoryProviderExtension(async () => runtime as any)(pi as any);
-const scope = {}; const ctx = { sessionManager: scope };
-for (const handler of handlers.get("session_start") ?? []) await handler({}, ctx);
-assert.deepEqual([...records.get(scope)!.keys()], ["plastic.ignore-files"]);
-for (const handler of handlers.get("session_shutdown") ?? []) await handler({}, ctx);
-assert.equal(records.get(scope)?.size ?? 0, 0);
-
-const absentHandlers = new Map<string, Array<(_event: unknown, ctx: any) => Promise<void> | void>>();
-createPlasticRepositoryProviderExtension(async () => { throw Object.assign(new Error("Cannot find package '@aefree/pi-repo-search'"), { code: "ERR_MODULE_NOT_FOUND" }); })({ on(event: string, handler: any) { absentHandlers.set(event, [...(absentHandlers.get(event) ?? []), handler]); } } as any);
-for (const handler of absentHandlers.get("session_start") ?? []) await handler({}, ctx);
-assert.equal(records.get(scope)?.size ?? 0, 0, "an absent optional package must leave pi-plastic usable without registration");
-assert.equal(isMissingRepoSearchRuntime({ code: "ERR_MODULE_NOT_FOUND", message: "Cannot find package '@aefree/pi-repo-search'" }), true);
-assert.equal(isMissingRepoSearchRuntime({ code: "ERR_MODULE_NOT_FOUND", message: "Cannot find package 'nested-defect'" }), false);
-console.log("PASS: optional Plastic repository-search policy registration");

package/tests/repository-search-provider.test.ts

@@ -1,27 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, mkdir, realpath, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { createPlasticRepositorySearchPolicyV1, loadPlasticOwnerV1 } from "../src/repository-search-provider.ts";
-
-const root = await mkdtemp(join(tmpdir(), "pi-plastic-repo-policy-"));
-try {
-  const plastic = join(root, "plastic"); const source = join(plastic, "Assets", "Code"); const gitOnly = join(root, "git-only");
-  await mkdir(join(plastic, ".plastic"), { recursive: true }); await writeFile(join(plastic, ".plastic", "plastic.workspace"), "fixture");
-  await mkdir(source, { recursive: true }); await writeFile(join(plastic, "ignore.conf"), "ignored.txt\n"); await writeFile(join(plastic, "Assets", "cloaked.conf"), "cache/**\n");
-  await mkdir(join(gitOnly, ".git"), { recursive: true });
-  const owner = await loadPlasticOwnerV1(new URL("../extensions/repository-search-provider.ts", import.meta.url).href);
-  assert.equal(owner.packageVersion, "0.4.0");
-  assert.equal(owner.packageRoot, await realpath(join(import.meta.dirname, "..")));
-  const policy = createPlasticRepositorySearchPolicyV1(owner);
-  const result = await policy.evaluate({ cwd: root, signal: new AbortController().signal }, { workspaceRoot: root, roots: [source], includeHidden: false, signal: new AbortController().signal });
-  assert.equal(result.outcome, "applied");
-  if (result.outcome === "applied") {
-    assert.equal(result.roots[0]?.policyOwnedRoot, plastic);
-    assert.deepEqual(result.roots[0]?.ignoreFiles.map((file) => file.slice(plastic.length + 1).replaceAll("\\", "/")), ["ignore.conf", "Assets/cloaked.conf"]);
-  }
-
-  const nonApplicable = await policy.evaluate({ cwd: root, signal: new AbortController().signal }, { workspaceRoot: root, roots: [gitOnly], includeHidden: false, signal: new AbortController().signal });
-  assert.equal(nonApplicable.outcome, "not_applicable");
-} finally { await rm(root, { recursive: true, force: true }); }
-console.log("PASS: Plastic repository-search policy");