@oisincoveney/pipeline 2.8.0 → 2.8.2

package/dist/runtime/builtins/builtins.js

@@ -1,70 +1,357 @@
-import { runFallow, runJscpd, runLint, runSemgrep, runTests, runTypecheck } from "../../gates.js";
+import { parseJson } from "../../safe-json.js";
+import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
 import { executeDrainMergeBuiltin } from "../drain-merge/drain-merge.js";
 import "../drain-merge/index.js";
 import { executeSelectCandidateBuiltin } from "../select-candidate/select-candidate.js";
+import { Effect } from "effect";
+import { existsSync, readFileSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { resolveCommand } from "package-manager-detector/commands";
+import { detect } from "package-manager-detector/detect";
 //#region src/runtime/builtins/builtins.ts
-async function executeBuiltin(builtin, context, node) {
-	switch (builtin) {
-		case "drain-merge": return executeDrainMergeBuiltin(context, node);
-		case "select-candidate": return executeSelectCandidateBuiltin(context, node);
-		case "test": {
-			const result = await runTests(context.worktreePath, context.signal);
-			return {
-				evidence: [...builtinCommandEvidence("test", result), ...result.failingTests],
-				exitCode: result.exitCode,
-				output: result.output
-			};
-		}
-		case "typecheck": {
-			const result = await runTypecheck(context.worktreePath, context.signal);
-			return {
-				evidence: builtinCommandEvidence("typecheck", result),
-				exitCode: result.exitCode,
-				output: result.output
-			};
-		}
-		case "lint": {
-			const result = await runLint(context.worktreePath, context.signal);
-			return {
-				evidence: builtinCommandEvidence("lint", result),
-				exitCode: result.exitCode,
-				output: result.output
-			};
-		}
-		case "fallow": {
-			const result = await runFallow(context.worktreePath, context.signal);
-			return {
-				evidence: builtinCommandEvidence("fallow", result),
-				exitCode: result.exitCode,
-				output: result.output
-			};
-		}
-		case "duplication": {
-			const result = await runJscpd(context.worktreePath, context.signal);
-			return {
-				evidence: result.violations.map((violation) => violation.message),
-				exitCode: result.violations.length === 0 ? 0 : 1,
-				output: JSON.stringify(result.violations)
-			};
-		}
-		case "semgrep": {
-			const result = await runSemgrep(context.worktreePath, context.signal, runtimeChangedFiles(context));
-			return {
-				evidence: builtinCommandEvidence("semgrep", result),
-				exitCode: result.exitCode,
-				output: result.output
-			};
-		}
-		default: return {
-			evidence: [`unsupported builtin '${builtin}'`],
-			exitCode: 1,
-			output: ""
+const JSCPD_DEFAULT_IGNORES = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/dist/**",
+	"**/coverage/**",
+	"**/.next/**",
+	"**/.turbo/**",
+	"**/.cache/**",
+	"**/.serena/**",
+	"**/.opencode/**",
+	"**/.pipeline/host-resources/**",
+	"**/.pipeline/skills/**",
+	"**/.agents/skills/**"
+];
+const WHITESPACE_RE = /\s/;
+const BUILTIN_HANDLERS = {
+	"drain-merge": (context, node) => Effect.tryPromise(() => executeDrainMergeBuiltin(context, node)),
+	duplication: (context) => executeDuplicationBuiltinEffect(context),
+	fallow: (context) => executeFallowBuiltinEffect(context),
+	lint: (context) => executeScriptBuiltinEffect(context, "lint"),
+	"select-candidate": (context, node) => Effect.tryPromise(() => executeSelectCandidateBuiltin(context, node)),
+	semgrep: (context) => executeSemgrepBuiltinEffect(context),
+	test: (context) => executeTestBuiltinEffect(context),
+	typecheck: (context) => executeScriptBuiltinEffect(context, "typecheck")
+};
+function executeBuiltin(builtin, context, node) {
+	const program = executeBuiltinEffect(builtin, context, node);
+	return Effect.runPromise(Effect.provide(program, CommandExecutorLive));
+}
+function executeBuiltinEffect(builtin, context, node) {
+	const handler = BUILTIN_HANDLERS[builtin];
+	return handler ? handler(context, node) : Effect.succeed(unsupportedBuiltin(builtin));
+}
+function unsupportedBuiltin(builtin) {
+	return {
+		evidence: [`unsupported builtin '${builtin}'`],
+		exitCode: 1,
+		output: ""
+	};
+}
+function executeTestBuiltinEffect(context) {
+	return Effect.gen(function* () {
+		const command = yield* resolveRequiredScriptCommand(context.worktreePath, "PIPELINE_TEST_COMMAND", "test");
+		if (!command) return missingTestCommandResult();
+		const result = yield* executeProjectCommand(command, context);
+		return commandBuiltinResult("test", result, result.exitCode === 0 ? [] : parseFailingTests(result.output));
+	});
+}
+function executeScriptBuiltinEffect(context, builtin) {
+	return Effect.gen(function* () {
+		const command = yield* resolveRequiredScriptCommand(context.worktreePath, builtinEnvName(builtin), builtin);
+		return command ? yield* executeScriptCommandBuiltin(builtin, command, context) : skippedBuiltinResult(builtin);
+	});
+}
+function executeScriptCommandBuiltin(builtin, command, context) {
+	return executeProjectCommand(command, context, builtin === "lint").pipe(Effect.map((result) => commandBuiltinResult(builtin, result)));
+}
+function executeFallowBuiltinEffect(context) {
+	return Effect.gen(function* () {
+		return commandBuiltinResult("fallow", yield* executeProjectCommand(yield* resolveFallowCommand(context.worktreePath), context, true));
+	});
+}
+function executeSemgrepBuiltinEffect(context) {
+	return Effect.gen(function* () {
+		const command = yield* resolveSemgrepCommand(context);
+		if (!command) return semgrepNoChangedFilesResult();
+		return commandBuiltinResult("semgrep", yield* executeProjectCommand(command, context));
+	});
+}
+function executeDuplicationBuiltinEffect(context) {
+	return Effect.gen(function* () {
+		return duplicationBuiltinResult(parseJscpdOutput((yield* executeProjectCommand(jscpdCommand(), context)).output));
+	});
+}
+function executeProjectCommand(command, context, hidePipelineRuns = false) {
+	const run = executeVisibleProjectCommand(command, context);
+	return hidePipelineRuns ? withHiddenPipelineRuns(context.worktreePath, run) : run;
+}
+function executeVisibleProjectCommand(command, context) {
+	return Effect.gen(function* () {
+		const result = yield* (yield* CommandExecutor).execute(projectCommandArray(command), context);
+		return {
+			command: displayCommand(command),
+			...result
 		};
+	});
+}
+function withHiddenPipelineRuns(worktreePath, effect) {
+	return Effect.acquireUseRelease(Effect.sync(() => hidePipelineRunsDirectory(worktreePath)), () => effect, (hiddenRuns) => Effect.sync(() => hiddenRuns?.restore()));
+}
+function resolveRequiredScriptCommand(worktreePath, envName, scriptName) {
+	return Effect.gen(function* () {
+		return envCommand(envName) ?? (yield* resolvePackageScript(worktreePath, scriptName));
+	});
+}
+function resolveFallowCommand(worktreePath) {
+	return Effect.gen(function* () {
+		const script = yield* resolvePackageScript(worktreePath, "fallow");
+		const binary = yield* resolvePackageBinaryCommand(worktreePath, "fallow", ["audit"]);
+		return envCommand("PIPELINE_FALLOW_COMMAND") ?? script ?? binary ?? fallowCommand();
+	});
+}
+function resolveSemgrepCommand(context) {
+	return Effect.sync(() => {
+		const override = envCommand("PIPELINE_SEMGREP_COMMAND");
+		const targets = semgrepTargets(context);
+		return override ?? semgrepScanCommand(targets);
+	});
+}
+function resolvePackageScript(worktreePath, scriptName) {
+	return Effect.gen(function* () {
+		if (!readPackageScripts(worktreePath)[scriptName]) return null;
+		return packageManagerCommand(yield* detectPackageManagerAgent(worktreePath), [scriptName]);
+	});
+}
+function resolvePackageBinaryCommand(worktreePath, binary, args) {
+	return Effect.gen(function* () {
+		if (!existsSync(join(worktreePath, "package.json"))) return null;
+		return packageBinaryCommand(yield* detectPackageManagerAgent(worktreePath), binary, args);
+	});
+}
+function detectPackageManagerAgent(worktreePath) {
+	return Effect.tryPromise(async () => {
+		return (await detect({
+			cwd: worktreePath,
+			stopDir: worktreePath
+		}))?.agent ?? "npm";
+	});
+}
+function packageManagerCommand(agent, args) {
+	const resolved = resolveCommand(agent, "run", args);
+	return resolved ? {
+		args: resolved.args,
+		command: resolved.command
+	} : null;
+}
+function packageBinaryCommand(agent, binary, args) {
+	return {
+		bun: {
+			args: [
+				"x",
+				binary,
+				...args
+			],
+			command: "bun"
+		},
+		pnpm: {
+			args: [
+				"exec",
+				binary,
+				...args
+			],
+			command: "pnpm"
+		},
+		yarn: {
+			args: [
+				"exec",
+				binary,
+				...args
+			],
+			command: "yarn"
+		}
+	}[String(agent)] ?? {
+		args: [
+			"--yes",
+			binary,
+			...args
+		],
+		command: "npx"
+	};
+}
+function envCommand(envName) {
+	const raw = process.env[envName]?.trim();
+	return raw ? envProjectCommand(raw) : null;
+}
+function envProjectCommand(raw) {
+	return WHITESPACE_RE.test(raw) ? shellProjectCommand(raw) : executableProjectCommand(raw);
+}
+function executableProjectCommand(command) {
+	return {
+		args: [],
+		command
+	};
+}
+function shellProjectCommand(command) {
+	return {
+		args: ["-c", command],
+		command: "sh",
+		display: command
+	};
+}
+function readPackageScripts(worktreePath) {
+	const text = readPackageJsonText(worktreePath);
+	return text ? packageScriptsFromJson(text) : {};
+}
+function readPackageJsonText(worktreePath) {
+	try {
+		return readFileSync(join(worktreePath, "package.json"), "utf-8");
+	} catch {
+		return null;
 	}
 }
+function packageScriptsFromJson(text) {
+	return parseJson(text, "package.json").scripts ?? {};
+}
 function runtimeChangedFiles(context) {
 	return [...new Set(context.nodeStateStore.changedFilesForAllNodes())].sort();
 }
+function semgrepTargets(context) {
+	const targets = runtimeChangedFiles(context).filter((file) => existsSync(join(context.worktreePath, file)));
+	return targets.length === 0 ? void 0 : targets;
+}
+function semgrepScanCommand(targets) {
+	if (!targets) return null;
+	return {
+		args: [
+			"semgrep",
+			"scan",
+			"--config=p/ci",
+			"--error",
+			"--",
+			...targets
+		],
+		command: "uvx"
+	};
+}
+function jscpdCommand() {
+	return {
+		args: [
+			"jscpd",
+			"--min-tokens",
+			"50",
+			"--reporters",
+			"json",
+			"--gitignore",
+			"--ignore",
+			JSCPD_DEFAULT_IGNORES.join(","),
+			"."
+		],
+		command: "bunx"
+	};
+}
+function fallowCommand() {
+	return {
+		args: ["audit"],
+		command: "fallow"
+	};
+}
+function projectCommandArray(command) {
+	return [command.command, ...command.args];
+}
+function displayCommand(command) {
+	return command.display ?? projectCommandArray(command).join(" ");
+}
+function builtinEnvName(builtin) {
+	return `PIPELINE_${builtin.toUpperCase()}_COMMAND`;
+}
+function missingTestCommandResult() {
+	return {
+		evidence: ["No test command found. Set PIPELINE_TEST_COMMAND or define a package test script."],
+		exitCode: 1,
+		output: "No test command found. Set PIPELINE_TEST_COMMAND or define a package test script."
+	};
+}
+function skippedBuiltinResult(builtin) {
+	return {
+		evidence: builtinCommandEvidence(builtin, {
+			exitCode: 0,
+			output: "skipped"
+		}),
+		exitCode: 0,
+		output: "skipped"
+	};
+}
+function semgrepNoChangedFilesResult() {
+	return commandBuiltinResult("semgrep", {
+		command: "uvx semgrep scan --config=p/ci --error",
+		exitCode: 0,
+		output: "skipped: no changed files to scan"
+	});
+}
+function duplicationBuiltinResult(violations) {
+	return {
+		evidence: violations.map((violation) => violation.message),
+		exitCode: violations.length === 0 ? 0 : 1,
+		output: JSON.stringify(violations)
+	};
+}
+function commandBuiltinResult(builtin, result, extraEvidence = []) {
+	return {
+		evidence: [...builtinCommandEvidence(builtin, result), ...extraEvidence],
+		exitCode: result.exitCode,
+		output: result.output
+	};
+}
+function hidePipelineRunsDirectory(worktreePath) {
+	const paths = pipelineRunsPaths(worktreePath);
+	if (!existsSync(paths.runs)) return null;
+	renameSync(paths.runs, paths.hidden);
+	return { restore: () => restoreHiddenRuns(paths) };
+}
+function pipelineRunsPaths(worktreePath) {
+	const pipelineDir = join(worktreePath, ".pipeline");
+	return {
+		hidden: join(pipelineDir, `.runs-hidden-${process.pid}-${Date.now()}`),
+		runs: join(pipelineDir, "runs")
+	};
+}
+function restoreHiddenRuns(paths) {
+	if (existsSync(paths.hidden)) renameSync(paths.hidden, paths.runs);
+}
+const FAILING_TEST_RE = /^[✗×✕●]\s+(.+)$/;
+function parseFailingTests(output) {
+	return output.split("\n").flatMap(parseFailingTestLine);
+}
+function parseFailingTestLine(line) {
+	const match = FAILING_TEST_RE.exec(line);
+	return match ? [match[1].trim()] : [];
+}
+function parseJscpdOutput(output) {
+	try {
+		return (parseJson(output, "jscpd output").duplicates ?? []).map(jscpdDuplicateViolation);
+	} catch {
+		return [];
+	}
+}
+function jscpdDuplicateViolation(dup) {
+	const firstFile = jscpdFirstFileName(dup);
+	return {
+		file: firstFile ?? "unknown",
+		line: jscpdFirstFileStart(dup),
+		message: `Duplicate code block detected between ${firstFile} and ${jscpdSecondFileName(dup)}`
+	};
+}
+function jscpdFirstFileName(dup) {
+	return dup.firstFile?.name;
+}
+function jscpdFirstFileStart(dup) {
+	return dup.firstFile?.start;
+}
+function jscpdSecondFileName(dup) {
+	return dup.secondFile?.name;
+}
 function builtinCommandEvidence(builtin, result) {
 	const command = result.command ? `: ${result.command}` : "";
 	return [`builtin '${builtin}' exited ${result.exitCode}${command}`, result.output || `builtin '${builtin}' produced no output`];

package/dist/runtime/changed-files/changed-files.js

@@ -1,35 +1,23 @@
+import { GitPorcelainService, GitPorcelainServiceLive } from "../services/git-porcelain-service.js";
+import { Effect } from "effect";
 import { existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { join } from "node:path";
-import { execFileSync } from "node:child_process";
 //#region src/runtime/changed-files/changed-files.ts
 function snapshotChangedFiles(worktreePath) {
-	try {
-		const stdout = execFileSync("git", [
-			"status",
-			"--porcelain=v1",
-			"--untracked-files=all",
-			"-z"
-		], {
-			cwd: worktreePath,
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		});
-		const files = new Set(parsePorcelainStatus(stdout));
-		return {
-			files,
-			fingerprints: new Map([...files].map((file) => [file, fileFingerprint(worktreePath, file)]))
-		};
-	} catch {
-		return {
-			files: /* @__PURE__ */ new Set(),
-			fingerprints: /* @__PURE__ */ new Map()
-		};
-	}
+	return Effect.runSync(Effect.provide(snapshotChangedFilesEffect(worktreePath), GitPorcelainServiceLive));
+}
+function snapshotChangedFilesEffect(worktreePath) {
+	return Effect.gen(function* () {
+		const stdout = yield* (yield* GitPorcelainService).statusPorcelain(worktreePath).pipe(Effect.catchAll(() => Effect.succeed("")));
+		return changedFilesSnapshot(worktreePath, new Set(parsePorcelainStatus(stdout)));
+	});
+}
+function changedFilesSnapshot(worktreePath, files) {
+	return {
+		files,
+		fingerprints: new Map([...files].map((file) => [file, fileFingerprint(worktreePath, file)]))
+	};
 }
 function parsePorcelainStatus(stdout) {
 	const entries = stdout.split("\0").filter(Boolean);

package/dist/runtime/changed-files/index.js

@@ -0,0 +1,2 @@
+import "./changed-files.js";
+export {};