@decohere/core 0.0.1-dev.126 → 0.0.1-dev.5

package/tests/extensibility/pipeline.spec.ts

@@ -0,0 +1,379 @@
+import { describe, expect, it, vi } from "vitest";
+import { Pipeline, type PipelineStep } from "../../src/extensibility/pipeline.js";
+
+type TestCtx = { log: string[] };
+
+function makeStep(_name: string, sideEffect?: (ctx: TestCtx) => void): PipelineStep<TestCtx> {
+	return {
+		async run(ctx, next) {
+			sideEffect?.(ctx);
+			await next();
+		},
+	};
+}
+
+describe("Pipeline", () => {
+	describe("step execution", () => {
+		it("runs a single step", async () => {
+			const ctx: TestCtx = { log: [] };
+			const pipeline = new Pipeline<TestCtx>(["A", makeStep("A", (c) => c.log.push("A"))]);
+
+			await pipeline.start(ctx);
+
+			expect(ctx.log).toEqual(["A"]);
+		});
+
+		it("runs multiple steps in order", async () => {
+			const ctx: TestCtx = { log: [] };
+			const pipeline = new Pipeline<TestCtx>(
+				["A", makeStep("A", (c) => c.log.push("A"))],
+				["B", makeStep("B", (c) => c.log.push("B"))],
+				["C", makeStep("C", (c) => c.log.push("C"))],
+			);
+
+			await pipeline.start(ctx);
+
+			expect(ctx.log).toEqual(["A", "B", "C"]);
+		});
+
+		it("completes with no steps without error", async () => {
+			const pipeline = new Pipeline<TestCtx>();
+			await expect(pipeline.start({ log: [] })).resolves.toBeUndefined();
+		});
+
+		it("passes the same context object to every step", async () => {
+			const ctx: TestCtx = { log: [] };
+			const received: TestCtx[] = [];
+
+			const capturingStep = (_name: string): PipelineStep<TestCtx> => ({
+				async run(c, next) {
+					received.push(c);
+					await next();
+				},
+			});
+
+			const pipeline = new Pipeline<TestCtx>(
+				["A", capturingStep("A")],
+				["B", capturingStep("B")],
+			);
+			await pipeline.start(ctx);
+
+			expect(received).toHaveLength(2);
+			expect(received[0]).toBe(ctx);
+			expect(received[1]).toBe(ctx);
+		});
+	});
+
+	describe("next() control flow", () => {
+		it("stops at a step that does not call next()", async () => {
+			const ctx: TestCtx = { log: [] };
+			const blocker: PipelineStep<TestCtx> = {
+				async run(c, _next) {
+					c.log.push("blocker");
+					// intentionally does not call next()
+				},
+			};
+			const pipeline = new Pipeline<TestCtx>(
+				["Blocker", blocker],
+				["After", makeStep("After", (c) => c.log.push("After"))],
+			);
+
+			await pipeline.start(ctx);
+
+			expect(ctx.log).toEqual(["blocker"]);
+		});
+
+		it("allows a step to do work after calling next() (onion model)", async () => {
+			const ctx: TestCtx = { log: [] };
+			const wrapStep: PipelineStep<TestCtx> = {
+				async run(c, next) {
+					c.log.push("before");
+					await next();
+					c.log.push("after");
+				},
+			};
+			const pipeline = new Pipeline<TestCtx>(
+				["Wrap", wrapStep],
+				["Inner", makeStep("Inner", (c) => c.log.push("inner"))],
+			);
+
+			await pipeline.start(ctx);
+
+			expect(ctx.log).toEqual(["before", "inner", "after"]);
+		});
+	});
+
+	describe("step skip predicate (when)", () => {
+		it("runs a step when `when` returns true", async () => {
+			const ctx: TestCtx = { log: [] };
+			const runSpy = vi.fn();
+			const step = makeStep("A", (c) => {
+				c.log.push("A");
+				runSpy();
+			});
+			const pipeline = new Pipeline<TestCtx>(["A", step, () => true]);
+
+			await pipeline.start(ctx);
+
+			expect(runSpy).toHaveBeenCalledOnce();
+			expect(ctx.log).toEqual(["A"]);
+		});
+
+		it("skips a step when `when` returns false", async () => {
+			const ctx: TestCtx = { log: [] };
+			const runSpy = vi.fn();
+			const step = makeStep("A", () => runSpy());
+			const pipeline = new Pipeline<TestCtx>(["A", step, () => false]);
+
+			await pipeline.start(ctx);
+
+			expect(runSpy).not.toHaveBeenCalled();
+			expect(ctx.log).toEqual([]);
+		});
+
+		it("continues to downstream steps after a skipped step", async () => {
+			const ctx: TestCtx = { log: [] };
+			const pipeline = new Pipeline<TestCtx>(
+				["A", makeStep("A", (c) => c.log.push("A"))],
+				["B", makeStep("B", (c) => c.log.push("B")), () => false],
+				["C", makeStep("C", (c) => c.log.push("C"))],
+			);
+
+			await pipeline.start(ctx);
+
+			expect(ctx.log).toEqual(["A", "C"]);
+		});
+
+		it("evaluates `when` against the live context at run time", async () => {
+			const ctx: TestCtx & { flag: boolean } = { log: [], flag: false };
+			const toggle: PipelineStep<typeof ctx> = {
+				async run(c, next) {
+					c.flag = true;
+					await next();
+				},
+			};
+			const conditional = makeStep("Conditional", (c) => c.log.push("conditional"));
+			const pipeline = new Pipeline<typeof ctx>(
+				["Toggle", toggle],
+				["Conditional", conditional, (c) => c.flag],
+			);
+
+			await pipeline.start(ctx);
+
+			expect(ctx.log).toEqual(["conditional"]);
+		});
+
+		it("steps without a `when` predicate always run (backward compat)", async () => {
+			const ctx: TestCtx = { log: [] };
+			const pipeline = new Pipeline<TestCtx>(["A", makeStep("A", (c) => c.log.push("A"))]);
+
+			await pipeline.start(ctx);
+
+			expect(ctx.log).toEqual(["A"]);
+		});
+	});
+
+	describe("error handling", () => {
+		it("propagates errors thrown inside a step", async () => {
+			const thrower: PipelineStep<TestCtx> = {
+				async run(_c, _next) {
+					throw new Error("step failed");
+				},
+			};
+			const pipeline = new Pipeline<TestCtx>(["Thrower", thrower]);
+
+			await expect(pipeline.start({ log: [] })).rejects.toThrow("step failed");
+		});
+
+		it("propagates errors from inner steps back through outer steps", async () => {
+			const ctx: TestCtx = { log: [] };
+			const outer: PipelineStep<TestCtx> = {
+				async run(c, next) {
+					try {
+						await next();
+					} catch {
+						c.log.push("caught-by-outer");
+						throw new Error("re-thrown");
+					}
+				},
+			};
+			const inner: PipelineStep<TestCtx> = {
+				async run(_c, _next) {
+					throw new Error("inner error");
+				},
+			};
+			const pipeline = new Pipeline<TestCtx>(["Outer", outer], ["Inner", inner]);
+
+			await expect(pipeline.start(ctx)).rejects.toThrow("re-thrown");
+			expect(ctx.log).toEqual(["caught-by-outer"]);
+		});
+
+		it("does not suppress errors even when step has a finally block", async () => {
+			const ctx: TestCtx = { log: [] };
+			const step: PipelineStep<TestCtx> = {
+				async run(c, next) {
+					try {
+						await next();
+					} finally {
+						c.log.push("finally");
+					}
+				},
+			};
+			const thrower: PipelineStep<TestCtx> = {
+				async run(_c, _next) {
+					throw new Error("boom");
+				},
+			};
+			const pipeline = new Pipeline<TestCtx>(["Step", step], ["Thrower", thrower]);
+
+			await expect(pipeline.start(ctx)).rejects.toThrow("boom");
+			expect(ctx.log).toEqual(["finally"]);
+		});
+	});
+
+	describe("async steps", () => {
+		it("awaits async steps before proceeding", async () => {
+			const ctx: TestCtx = { log: [] };
+			const asyncStep: PipelineStep<TestCtx> = {
+				async run(c, next) {
+					await new Promise<void>((resolve) => setTimeout(resolve, 5));
+					c.log.push("async");
+					await next();
+				},
+			};
+			const pipeline = new Pipeline<TestCtx>(
+				["Async", asyncStep],
+				["Sync", makeStep("Sync", (c) => c.log.push("sync"))],
+			);
+
+			await pipeline.start(ctx);
+
+			expect(ctx.log).toEqual(["async", "sync"]);
+		});
+	});
+
+	describe("dispose behavior", () => {
+		it("pipeline[Symbol.dispose]() calls disposers on steps that have them", async () => {
+			let disposedA = false;
+			let disposedB = false;
+
+			const stepA: PipelineStep<TestCtx> & Disposable = {
+				async run(ctx, next) {
+					ctx.log.push("A");
+					await next();
+				},
+				[Symbol.dispose]() {
+					disposedA = true;
+				},
+			};
+			const stepB: PipelineStep<TestCtx> = {
+				async run(ctx, next) {
+					ctx.log.push("B");
+					await next();
+				},
+			};
+			const stepC: PipelineStep<TestCtx> & Disposable = {
+				async run(ctx, next) {
+					ctx.log.push("C");
+					await next();
+				},
+				[Symbol.dispose]() {
+					disposedB = true;
+				},
+			};
+
+			const pipeline = new Pipeline<TestCtx>(["A", stepA], ["B", stepB], ["C", stepC]);
+			await pipeline.start({ log: [] });
+
+			expect(disposedA).toBe(false);
+			expect(disposedB).toBe(false);
+
+			pipeline[Symbol.dispose]();
+
+			expect(disposedA).toBe(true);
+			expect(disposedB).toBe(true);
+		});
+
+		it("does not call [Symbol.dispose]() when the step reference is popped from the stack", async () => {
+			let disposed = false;
+
+			class DisposableStep implements PipelineStep<TestCtx> {
+				public async run(ctx: TestCtx, next: () => Promise<void>) {
+					ctx.log.push("ran");
+					await next();
+				}
+
+				public [Symbol.dispose]() {
+					disposed = true;
+				}
+			}
+
+			const step = new DisposableStep();
+			const ctx: TestCtx = { log: [] };
+			const pipeline = new Pipeline<TestCtx>(["Disposable", step]);
+
+			await pipeline.start(ctx);
+			expect(ctx.log).toEqual(["ran"]);
+
+			// Simulate popping the step from the stack (dropping the Pipeline's reference)
+			(pipeline as any).stack.length = 0;
+
+			// [Symbol.dispose]() is NOT a GC finalizer — dropping the ref does not invoke it
+			expect(disposed).toBe(false);
+		});
+
+		it("calls [Symbol.dispose]() only when explicitly invoked", async () => {
+			let disposed = false;
+
+			class DisposableStep implements PipelineStep<TestCtx> {
+				public async run(ctx: TestCtx, next: () => Promise<void>) {
+					ctx.log.push("ran");
+					await next();
+				}
+
+				public [Symbol.dispose]() {
+					disposed = true;
+				}
+			}
+
+			const step = new DisposableStep();
+			const pipeline = new Pipeline<TestCtx>(["Disposable", step]);
+
+			await pipeline.start({ log: [] });
+
+			(pipeline as any).stack.length = 0;
+			expect(disposed).toBe(false);
+
+			// Only an explicit call triggers the disposer
+			step[Symbol.dispose]();
+			expect(disposed).toBe(true);
+		});
+
+		it("calls [Symbol.dispose]() automatically when the 'using' keyword is in scope", async () => {
+			let disposed = false;
+
+			class DisposableStep implements PipelineStep<TestCtx> {
+				public async run(ctx: TestCtx, next: () => Promise<void>) {
+					ctx.log.push("ran");
+					await next();
+				}
+
+				public [Symbol.dispose]() {
+					disposed = true;
+				}
+			}
+
+			const ctx: TestCtx = { log: [] };
+
+			{
+				using step = new DisposableStep();
+				const pipeline = new Pipeline<TestCtx>(["Disposable", step]);
+				await pipeline.start(ctx);
+				expect(disposed).toBe(false); // not yet — block hasn't exited
+			} // <-- [Symbol.dispose]() fires here automatically
+
+			expect(ctx.log).toEqual(["ran"]);
+			expect(disposed).toBe(true);
+		});
+	});
+});

package/tests/interop/detect-package-manager.spec.ts

@@ -0,0 +1,70 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Npm } from "../../src/interop/npm/npm.js";
+import { Pnpm } from "../../src/interop/pnpm/pnpm.js";
+import {
+	detectPackageManager,
+	packageManagerFromString,
+} from "../../src/interop/types/detect-package-manager.js";
+import { Yarn } from "../../src/interop/yarn/yarn.js";
+
+vi.mock("node:fs", () => ({ existsSync: vi.fn().mockReturnValue(false) }));
+
+const { existsSync } = await import("node:fs");
+
+describe("detectPackageManager", () => {
+	beforeEach(() => {
+		delete process.env.npm_config_user_agent;
+	});
+
+	afterEach(() => {
+		vi.mocked(existsSync).mockReturnValue(false);
+	});
+
+	it("returns Pnpm when pnpm-lock.yaml exists", () => {
+		vi.mocked(existsSync).mockImplementation((p) => String(p).endsWith("pnpm-lock.yaml"));
+		expect(detectPackageManager("/project")).toBeInstanceOf(Pnpm);
+	});
+
+	it("returns Yarn when yarn.lock exists", () => {
+		vi.mocked(existsSync).mockImplementation((p) => String(p).endsWith("yarn.lock"));
+		expect(detectPackageManager("/project")).toBeInstanceOf(Yarn);
+	});
+
+	it("returns Npm when package-lock.json exists", () => {
+		vi.mocked(existsSync).mockImplementation((p) => String(p).endsWith("package-lock.json"));
+		expect(detectPackageManager("/project")).toBeInstanceOf(Npm);
+	});
+
+	it("prefers lockfile over user agent", () => {
+		vi.mocked(existsSync).mockImplementation((p) => String(p).endsWith("yarn.lock"));
+		process.env.npm_config_user_agent = "pnpm/9.0.0";
+		expect(detectPackageManager("/project")).toBeInstanceOf(Yarn);
+	});
+
+	it("falls back to user agent when no lockfile", () => {
+		process.env.npm_config_user_agent = "pnpm/9.0.0 node/v22.0.0";
+		expect(detectPackageManager("/project")).toBeInstanceOf(Pnpm);
+	});
+
+	it("returns undefined when no lockfile and no user agent", () => {
+		expect(detectPackageManager("/project")).toBeUndefined();
+	});
+});
+
+describe("packageManagerFromString", () => {
+	it("returns Yarn for 'yarn'", () => {
+		expect(packageManagerFromString("yarn")).toBeInstanceOf(Yarn);
+	});
+
+	it("returns Npm for 'npm'", () => {
+		expect(packageManagerFromString("npm")).toBeInstanceOf(Npm);
+	});
+
+	it("returns Pnpm for 'pnpm'", () => {
+		expect(packageManagerFromString("pnpm")).toBeInstanceOf(Pnpm);
+	});
+
+	it("defaults to Pnpm for unknown string", () => {
+		expect(packageManagerFromString("bun")).toBeInstanceOf(Pnpm);
+	});
+});

package/tests/interop/npm.spec.ts

@@ -0,0 +1,129 @@
+import { mkdirSync } from "node:fs";
+import { vol } from "memfs";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { InteropError } from "../../src/interop/errors/interop.error.js";
+
+const run = vi.hoisted(() => vi.fn());
+
+vi.mock("../../src/interop/shell/shell.js", () => ({
+	Shell: class {
+		public run = run;
+	},
+}));
+
+import { Npm } from "../../src/interop/npm/npm.js";
+
+function seedPublishedPackage() {
+	vol.fromJSON({
+		"/pkg/package.json": JSON.stringify({
+			name: "@decohere/cli",
+			version: "0.0.1-dev.79",
+		}),
+	});
+	mkdirSync("/tmp", { recursive: true });
+}
+
+describe("Npm", () => {
+	const originalToken = process.env.NODE_AUTH_TOKEN;
+
+	afterEach(() => {
+		run.mockReset();
+		vol.reset();
+		if (originalToken == null) {
+			delete process.env.NODE_AUTH_TOKEN;
+		} else {
+			process.env.NODE_AUTH_TOKEN = originalToken;
+		}
+	});
+
+	it("calls install with no extra flags", async () => {
+		await new Npm().install({ cwd: "/workspace" });
+		expect(run).toHaveBeenCalledWith({ cwd: "/workspace" }, "install");
+	});
+
+	it("installs production dependencies as real folders, with no bin symlinks", async () => {
+		await new Npm().installProduction({ cwd: "/out" });
+		expect(run).toHaveBeenCalledWith(
+			{ cwd: "/out" },
+			"install",
+			"--omit=dev",
+			"--no-bin-links",
+			"--no-audit",
+			"--no-fund",
+			"--loglevel=error",
+		);
+	});
+
+	it("publish dry-run still packs via npm publish --dry-run", async () => {
+		await new Npm().publish("dist/release/pkg", {
+			channel: "dev",
+			dryRun: true,
+			skipIfPublished: true,
+		});
+		expect(run).toHaveBeenCalledWith(
+			expect.objectContaining({ cwd: undefined, env: expect.any(Object) }),
+			"publish",
+			"dist/release/pkg",
+			"--tag",
+			"dev",
+			"--dry-run",
+		);
+		const env = run.mock.calls[0][0].env as NodeJS.ProcessEnv;
+		expect(env.NODE_AUTH_TOKEN).toBeUndefined();
+		expect(env.NPM_CONFIG_USERCONFIG).toBe("/dev/null");
+	});
+
+	it("skipIfPublished uses ambient npm view (no token on argv)", async () => {
+		seedPublishedPackage();
+		process.env.NODE_AUTH_TOKEN = "read-token";
+		run.mockResolvedValueOnce({ message: "view", data: ["0.0.1-dev.79"] });
+		const result = await new Npm().publish("/pkg", { channel: "dev", skipIfPublished: true });
+		expect(result.message).toMatch(/Skipping publish/);
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(run.mock.calls[0][1]).toBe("view");
+		expect(run.mock.calls[0][2]).toBe("@decohere/cli@0.0.1-dev.79");
+		expect(run.mock.calls[0]).not.toContain("--userconfig");
+	});
+
+	it("treats E403 already-published as skip and does not forward NODE_AUTH_TOKEN to npm publish", async () => {
+		seedPublishedPackage();
+		process.env.NODE_AUTH_TOKEN = "read-token";
+		run.mockRejectedValueOnce(new InteropError("404 Not Found"));
+		run.mockRejectedValueOnce(
+			new InteropError(
+				"npm error 403 Forbidden - You cannot publish over the previously published versions: 0.0.1-dev.79",
+			),
+		);
+		const result = await new Npm().publish("/pkg", { channel: "dev", skipIfPublished: true });
+		expect(result.message).toMatch(/Skipping publish/);
+		expect(run).toHaveBeenCalledTimes(2);
+		const publishCall = run.mock.calls[1];
+		expect(publishCall[1]).toBe("publish");
+		expect(publishCall[0].env.NODE_AUTH_TOKEN).toBeUndefined();
+		expect(publishCall[0].env.NPM_TOKEN).toBeUndefined();
+		expect(publishCall[0].env.NPM_CONFIG_USERCONFIG).toBe("/dev/null");
+	});
+
+	it("publish passes otp via env, not argv", async () => {
+		await new Npm().publish("dist/release/pkg", {
+			channel: "beta",
+			dryRun: true,
+			otp: "123456",
+		});
+		expect(run).toHaveBeenCalledWith(
+			expect.objectContaining({ cwd: undefined, env: expect.any(Object) }),
+			"publish",
+			"dist/release/pkg",
+			"--tag",
+			"beta",
+			"--dry-run",
+		);
+		const env = run.mock.calls[0][0].env as NodeJS.ProcessEnv;
+		expect(env.NPM_CONFIG_OTP).toBe("123456");
+		expect(env.NODE_AUTH_TOKEN).toBeUndefined();
+		expect(env.NPM_CONFIG_USERCONFIG).toBe("/dev/null");
+		const argv = run.mock.calls[0]?.slice(1) ?? [];
+		expect(argv).not.toContain("--otp");
+		expect(argv).not.toContain("123456");
+	});
+});

package/tests/interop/pnpm.spec.ts

@@ -0,0 +1,30 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const run = vi.hoisted(() => vi.fn());
+
+vi.mock("../../src/interop/shell/shell.js", () => ({
+	Shell: class {
+		public run = run;
+	},
+}));
+
+import { Pnpm } from "../../src/interop/pnpm/pnpm.js";
+
+describe("Pnpm", () => {
+	beforeEach(() => run.mockClear());
+
+	it("uses lockfile-only install flags when syncing lockfile", async () => {
+		await new Pnpm().syncLockFile({ cwd: "/workspace" });
+		expect(run).toHaveBeenCalledWith(
+			{ cwd: "/workspace" },
+			"install",
+			"--lockfile-only",
+			"--ignore-scripts",
+		);
+	});
+
+	it("calls install with no extra flags", async () => {
+		await new Pnpm().install({ cwd: "/workspace" });
+		expect(run).toHaveBeenCalledWith({ cwd: "/workspace" }, "install");
+	});
+});

package/tests/interop/shell.spec.ts

@@ -0,0 +1,47 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { describe, expect, it, vi } from "vitest";
+import { Shell } from "../../src/interop/shell/shell.js";
+
+vi.mock("node:child_process", () => ({
+	spawn: vi.fn(),
+}));
+
+class TestShell extends Shell {
+	protected program = "missing-program";
+
+	public runCommand() {
+		return this.run({}, "arg");
+	}
+}
+
+describe("Shell", () => {
+	it("rejects when spawn emits an error", async () => {
+		const childProcess = new EventEmitter() as EventEmitter & {
+			stdout: EventEmitter;
+		};
+		childProcess.stdout = new EventEmitter();
+
+		vi.mocked(spawn).mockReturnValue(childProcess as never);
+
+		const shell = new TestShell();
+		const runPromise = shell.runCommand();
+
+		let settled = false;
+		let rejected = false;
+		runPromise
+			.then(() => {
+				settled = true;
+			})
+			.catch(() => {
+				settled = true;
+				rejected = true;
+			});
+
+		childProcess.emit("error", new Error("spawn ENOENT"));
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(settled).toBe(true);
+		expect(rejected).toBe(true);
+	});
+});

package/tests/interop/yarn.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it, vi } from "vitest";
+
+const run = vi.hoisted(() => vi.fn());
+
+vi.mock("../../src/interop/shell/shell.js", () => ({
+	Shell: class {
+		public run = run;
+	},
+}));
+
+import { Yarn } from "../../src/interop/yarn/yarn.js";
+
+describe("Yarn", () => {
+	it("calls install with no extra flags", async () => {
+		await new Yarn().install({ cwd: "/workspace" });
+		expect(run).toHaveBeenCalledWith({ cwd: "/workspace" }, "install");
+	});
+});