gentle-pi 2.4.0 → 2.5.0

package/tests/codegraph-tools.test.ts

@@ -1,12 +1,14 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import codeGraphTools, {
 	createCodeGraphTool,
+	codeGraphNodeScript,
+	findCodeGraphNodeScriptOnPath,
 	type CodeGraphRunner,
 } from "../extensions/codegraph-tools.ts";
 
@@ -211,3 +213,110 @@ test("CodeGraph tool registration exposes a single constrained custom tool", ()
 		},
 	});
 });
+
+function writeCodeGraphPackage(binDir: string, scriptSource = "#!/usr/bin/env node\n"): string {
+	const pkgRoot = join(binDir, "node_modules", "@colbymchenry", "codegraph");
+	mkdirSync(pkgRoot, { recursive: true });
+	const scriptTarget = join(pkgRoot, "npm-shim.js");
+	writeFileSync(scriptTarget, scriptSource);
+	writeFileSync(
+		join(pkgRoot, "package.json"),
+		JSON.stringify({
+			name: "@colbymchenry/codegraph",
+			version: "1.0.0",
+			bin: { codegraph: "npm-shim.js" },
+		}),
+	);
+	writeFileSync(
+		join(binDir, "codegraph.cmd"),
+		"@ECHO off\nnode \"%~dp0\\node_modules\\@colbymchenry\\codegraph\\npm-shim.js\" %*\n",
+	);
+	return scriptTarget;
+}
+
+function withWindowsPath(t: test.TestContext, path: string): void {
+	const previousPath = process.env.PATH;
+	const previousWindowsPath = process.env.Path;
+	const windowsPath = process.platform === "win32"
+		? `${path};${previousWindowsPath ?? previousPath ?? ""}`
+		: path;
+	process.env.Path = windowsPath;
+	process.env.PATH = windowsPath;
+	t.after(() => {
+		if (previousPath === undefined) delete process.env.PATH;
+		else process.env.PATH = previousPath;
+		if (previousWindowsPath === undefined) delete process.env.Path;
+		else process.env.Path = previousWindowsPath;
+	});
+}
+
+test("Windows shim helpers skip stale PATH shims before resolving the npm script", (t) => {
+	const staleBinDir = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-codegraph-stale-bin-")));
+	const validBinDir = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-codegraph-valid-bin-")));
+	t.after(() => rmSync(staleBinDir, { recursive: true, force: true }));
+	t.after(() => rmSync(validBinDir, { recursive: true, force: true }));
+	writeFileSync(join(staleBinDir, "codegraph.cmd"), "@ECHO off\n");
+	const stalePkgRoot = join(staleBinDir, "node_modules", "@colbymchenry", "codegraph");
+	mkdirSync(stalePkgRoot, { recursive: true });
+	writeFileSync(join(stalePkgRoot, "package.json"), JSON.stringify({ bin: { codegraph: "." } }));
+	const scriptTarget = writeCodeGraphPackage(validBinDir);
+
+	withWindowsPath(t, `${staleBinDir};${validBinDir}`);
+
+	assert.equal(codeGraphNodeScript(join(staleBinDir, "codegraph.cmd")), undefined);
+	assert.equal(findCodeGraphNodeScriptOnPath(), scriptTarget);
+});
+
+test("Windows shim helpers resolve quoted PATH entries in order without stripping unmatched quotes", (t) => {
+	const root = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-codegraph-quoted-bin-")));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const firstBin = join(root, "Program Files", "nodejs");
+	const secondBin = join(root, "other-bin");
+	const firstScript = writeCodeGraphPackage(firstBin);
+	const secondScript = writeCodeGraphPackage(secondBin);
+	withWindowsPath(t, `"${firstBin}";${secondBin}`);
+
+	assert.equal(findCodeGraphNodeScriptOnPath(), firstScript);
+	for (const [path, expected] of [
+		[`${firstBin};"${secondBin}"`, firstScript],
+		[`"${firstBin};${secondBin}`, secondScript],
+		[`${firstBin}";${secondBin}`, secondScript],
+		[`${secondBin};"${firstBin}"`, secondScript],
+	]) {
+		process.env.Path = path;
+		process.env.PATH = path;
+		assert.equal(findCodeGraphNodeScriptOnPath(), expected);
+	}
+});
+
+test("Windows launcher passes command metacharacters as one literal argv value", async (t) => {
+	const binDir = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-codegraph-bin-")));
+	t.after(() => rmSync(binDir, { recursive: true, force: true }));
+	writeCodeGraphPackage(binDir, "process.stdout.write(JSON.stringify(process.argv.slice(2)));\n");
+	const cwd = workspace(t);
+	if (process.platform !== "win32") {
+		const gitShim = join(binDir, "git");
+		writeFileSync(gitShim, "#!/bin/sh\nprintf '%s\\n' \"$PWD\"\n");
+		chmodSync(gitShim, 0o755);
+	}
+	withWindowsPath(t, binDir);
+
+	const previousPlatform = process.platform;
+	Object.defineProperty(process, "platform", { configurable: true, value: "win32" });
+	t.after(() => Object.defineProperty(process, "platform", { configurable: true, value: previousPlatform }));
+
+	const query = "literal & echo injected > shell-injection.txt";
+	const result = await createCodeGraphTool().execute(
+		"test",
+		{ operation: "query", query },
+		undefined,
+		undefined,
+		{ cwd } as ExtensionContext,
+	);
+
+	assert.deepEqual(result.content, [{
+		type: "text",
+		text: JSON.stringify(["query", "--path", cwd, "--limit", "10", "--", query]),
+	}]);
+	assert.equal(existsSync(join(cwd, "shell-injection.txt")), false);
+});

package/tests/devbinary/native-review-parity.devtest.ts

@@ -5,6 +5,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
 import { __testing } from "../../extensions/gentle-ai.ts";
+import { CandidateViewRegistry } from "../../lib/review-candidate-view.ts";
 import {
 	NATIVE_REVIEW_ERROR_CODE,
 	NativeReviewCliError,
@@ -13,6 +14,7 @@ import {
 	createNodeExecFileAdapter,
 	type ExecFileAdapter,
 } from "../../lib/native-review-cli.ts";
+import type { ReviewStatusV3 } from "../../lib/review-integration-v2.ts";
 import { requireDevBinary } from "../support/native-binary-gate.ts";
 
 // Organic RDD Parity: candidate-bound dev-binary journeys.
@@ -43,6 +45,35 @@ function bridgeAdapter(binary: string, calls: NativeCall[]): ExecFileAdapter {
 	};
 }
 
+function selectedStatusFieldNames(stdout: string): string {
+	try {
+		const status = JSON.parse(stdout) as Record<string, unknown>;
+		const projection = status.projection as Record<string, unknown> | undefined;
+		const transition = status.next_transition as Record<string, unknown> | undefined;
+		const execute = transition?.execute as Record<string, unknown> | undefined;
+		const argument = Array.isArray(execute?.arguments) ? execute.arguments[0] as Record<string, unknown> | undefined : undefined;
+		const names = (prefix: string, value?: Record<string, unknown>) => value === undefined ? [] : Object.keys(value).sort().map((key) => `${prefix}.${key}`);
+		return [...names("status", status), ...names("status.projection", projection), ...names("status.next_transition", transition), ...names("status.next_transition.execute", execute), ...names("status.next_transition.execute.arguments[]", argument)].join(", ");
+	} catch {
+		return "status JSON";
+	}
+}
+
+function controllerResultStructure(result: Record<string, unknown>): string {
+	const diagnostics = typeof result.diagnostics === "object" && result.diagnostics !== null && !Array.isArray(result.diagnostics)
+		? result.diagnostics as Record<string, unknown>
+		: undefined;
+	const safeCode = (name: string, value: unknown) => typeof value === "string" && /^[a-z0-9][a-z0-9._-]*$/.test(value) ? `${name}=${value}` : undefined;
+	const safeBooleanNames = ["candidate_view_created", "candidate_view_pre_native", "native_invocation_attempted", "lineage_created", "mutation_performed", "reset_eligible"];
+	return [
+		`keys=[${Object.keys(result).sort().join(",")}]`,
+		...(diagnostics === undefined ? [] : [`diagnostics.keys=[${Object.keys(diagnostics).sort().join(",")}]`]),
+		safeCode("operation", result.operation), safeCode("status", result.status), safeCode("outcome", result.outcome), safeCode("reason", result.reason),
+		safeCode("diagnostics.error_code", diagnostics?.error_code), safeCode("diagnostics.code", diagnostics?.code), safeCode("diagnostics.reason", diagnostics?.reason),
+		...safeBooleanNames.flatMap((name) => typeof result[name] === "boolean" ? [`${name}=${String(result[name])}`] : []),
+	].filter((value): value is string => value !== undefined).join("; ");
+}
+
 function journeyNative(binary: string): { native: NativeReviewCliV216; calls: NativeCall[] } {
 	const calls: NativeCall[] = [];
 	return { native: new NativeReviewCliV216(bridgeAdapter(binary, calls), binary), calls };
@@ -202,6 +233,83 @@ test("dev-binary: an empty candidate exposes the current STATUS refusal and neve
 	assert.equal(calls.filter((arguments_) => arguments_.at(0) === "review" && arguments_.at(1) === "start").length, 0);
 });
 
+test("dev-binary: v7 intended-untracked selection decodes both selected statuses before START", { skip: !RUNNABLE }, async (t) => {
+	const cwd = repository(t);
+	writeFileSync(join(cwd, "app.ts"), "export const value = 1;\n");
+	git(cwd, "add", "app.ts");
+	git(cwd, "commit", "-qm", "test: base candidate");
+	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
+	writeFileSync(join(cwd, "chosen.md"), "# Chosen\n");
+
+	const calls: NativeCall[] = [], selectedWireFields: string[] = [];
+	let interceptedStarts = 0;
+	let delegatedStarts = 0;
+	const startIntercept = new Error("test-only native START intercept");
+	const real = createNodeExecFileAdapter();
+	const adapter: ExecFileAdapter = async (request) => {
+		calls.push([...request.arguments]);
+		if (request.arguments.at(0) === "review" && request.arguments.at(1) === "start") {
+			interceptedStarts += 1;
+			throw startIntercept;
+		}
+		if (request.arguments.at(0) === "review" && request.arguments.at(1) === "start") delegatedStarts += 1;
+		const result = await real({ ...request, file: DEV_BINARY! });
+		if (request.arguments.some((argument) => argument.startsWith("--intended-untracked-selection="))) selectedWireFields.push(selectedStatusFieldNames(result.stdout));
+		return result;
+	};
+	const native = new NativeReviewCliV216(adapter, DEV_BINARY!);
+	const targetStatus = native.targetStatus.bind(native);
+	const selectedStatuses: ReviewStatusV3[] = [];
+	const selectedFailures: Array<{ call: number; code: string }> = [];
+	let selectedStatusCalls = 0;
+	native.targetStatus = async (request) => {
+		if (request.intendedUntrackedSelection === undefined) return targetStatus(request);
+		selectedStatusCalls += 1;
+		try {
+			const status = await targetStatus(request);
+			selectedStatuses.push(status);
+			return status;
+		} catch (error) {
+			selectedFailures.push({ call: selectedStatusCalls, code: error instanceof NativeReviewCliError ? error.code : "unexpected-error" });
+			throw error;
+		}
+	};
+
+	const candidateViews = new CandidateViewRegistry(), retainedSelections = new Map();
+	await enableReview(native, cwd);
+	const initial = await __testing.executeReviewControllerOperation({ operation: "status" }, cwd, native, undefined, candidateViews, undefined, retainedSelections);
+	assert.equal((initial.result as Record<string, unknown> | undefined)?.schema, "gentle-ai.review-integration.status/v7", "initial status.schema");
+	assert.equal(typeof initial.selectionBinding, "string", "initial selectionBinding");
+	const result = await __testing.executeReviewControllerOperation({ operation: "select-intended-untracked", selectionBinding: initial.selectionBinding as string, intendedUntracked: ["chosen.md"] } as never, cwd, native, undefined, candidateViews, undefined, retainedSelections);
+
+	if (selectedStatusCalls !== 2) assert.fail(`intended-selection STATUS call count=${selectedStatusCalls}; ${controllerResultStructure(result)}`);
+	if (selectedFailures.length > 0) {
+		const failure = selectedFailures[0]!;
+		assert.fail(`selected STATUS call ${failure.call} decode failed at fields: ${selectedWireFields[failure.call - 1] ?? "status"}; error=${failure.code}`);
+	}
+	assert.equal(selectedStatusCalls, 2, "intended-selection STATUS call count");
+	assert.equal(selectedStatuses.length, 2, "decoded intended-selection STATUS count");
+	for (const [index, status] of selectedStatuses.entries()) {
+		assert.equal(status.raw.schema, "gentle-ai.review-integration.status/v7", `selected STATUS call ${index + 1} status.schema`);
+		assert.deepEqual(status.projection.intendedUntracked, ["chosen.md"], `selected STATUS call ${index + 1} status.projection.intended_untracked`);
+		assert.equal(status.nextTransition?.kind, "execute", `selected STATUS call ${index + 1} status.next_transition.kind`);
+		assert.equal(status.nextTransition?.execute?.operation, "review.start", `selected STATUS call ${index + 1} status.next_transition.execute.operation`);
+		assert.ok((status.nextTransition?.execute?.arguments.length ?? 0) > 0, `selected STATUS call ${index + 1} status.next_transition.execute.arguments`);
+		assert.equal(status.nextTransition?.execute?.arguments.every((argument) => typeof argument.token === "string" && argument.token.length > 0), true, `selected STATUS call ${index + 1} status.next_transition.execute.arguments[].token`);
+	}
+	assert.equal(interceptedStarts, 1, "adapter must intercept the one native review.start attempt");
+	assert.equal(delegatedStarts, 0, "intercepted native START must not reach the real adapter");
+	assert.equal(calls.filter((arguments_) => arguments_.at(0) === "review" && arguments_.at(1) === "start").length, 1, "native review.start adapter attempt count");
+	assert.equal(result.outcome, "native-mutation-status-reconciled", "controller result after intentional START intercept");
+	assert.equal("lineage_id" in result, false, "intercepted START must report no lineage binding");
+	assert.equal("authority" in result, false, "intercepted START must report no authority binding");
+	assert.equal("lineage_created" in result, false, "reconciled unknown mutation must not claim lineage creation");
+	assert.equal("mutation_performed" in result, false, "reconciled unknown mutation must not claim a mutation result");
+	assert.equal(result.mutation_outcome, "unknown", "the controller cannot prove mutation status after an intercepted launch");
+	const after = await native.targetStatus({ cwd, agent: "pi" });
+	assert.equal(after.authority, undefined, "post-intercept STATUS must not expose authority");
+});
+
 test("dev-binary: a low-risk START closes the review with no receipt or follow-up capture", { skip: !RUNNABLE }, async (t) => {
 	const cwd = repository(t);
 	writeFileSync(join(cwd, "guide.md"), "# Guide\n\nBase\n");

package/tests/fixtures/agents-process-child.mjs

@@ -0,0 +1,23 @@
+import { spawn } from "node:child_process";
+
+const descendant = spawn(process.execPath, ["-e", "process.on('SIGTERM', () => {}); process.stdout.write('ready'); setInterval(() => {}, 1000);"], { stdio: ["ignore", "pipe", "ignore"] });
+descendant.stdout.once("data", () => {
+	console.log(`DESCENDANT:${descendant.pid}`);
+	if (process.env.AGENTS_PROCESS_CHILD_EXIT_AFTER_READY === "1") process.exit(0);
+});
+process.on("SIGTERM", () => {
+	if (process.env.AGENTS_PROCESS_CHILD_EXIT_ON_TERM === "1") process.exit(0);
+});
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+	for (const line of chunk.split("\n")) {
+		if (!line) continue;
+		try {
+			const command = JSON.parse(line);
+			process.stdout.write(`${JSON.stringify({ type: "response", id: command.id, success: true })}\n`);
+		} catch {
+			// Ignore malformed input; the runner owns the RPC protocol.
+		}
+	}
+});
+setInterval(() => {}, 1000);