@decohere/devkit 0.0.1-dev.125 → 0.0.1-dev.5

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");
+	});
+});

package/tests/io/find-file.spec.ts

@@ -0,0 +1,188 @@
+import * as glob from "glob";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { findFile, findFiles } from "../../src/io/find-file.js";
+
+vi.mock("glob");
+
+describe("findFile", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("should fail fast when glob is not explicitly overridden", async () => {
+		await expect(findFile("**/*.ts")).rejects.toThrow(
+			'Mocked "glob" was called without an explicit test override.',
+		);
+	});
+
+	it("should return file with relativePath when pattern matches", async () => {
+		vi.spyOn(glob, "glob").mockResolvedValue(["src/index.ts"]);
+
+		const result = await findFile("**/*.ts");
+
+		expect(result).toEqual({
+			relativePath: "src/index.ts",
+		});
+	});
+
+	it("should return undefined when no files match", async () => {
+		vi.spyOn(glob, "glob").mockResolvedValue([]);
+
+		const result = await findFile("**/*.ts");
+
+		expect(result).toBeUndefined();
+	});
+
+	it("should return only the first match", async () => {
+		vi.spyOn(glob, "glob").mockResolvedValue(["src/index.ts", "src/utils.ts"]);
+
+		const result = await findFile("**/*.ts");
+
+		expect(result).toEqual({
+			relativePath: "src/index.ts",
+		});
+	});
+});
+
+describe("findFiles", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("should transform glob Path objects to File objects with relativePath and fullPath", async () => {
+		// Mock glob Path objects
+		const mockGlobPaths = [
+			{
+				isFile: () => true,
+				relative: () => "src/index.ts",
+				fullpath: () => "/test/project/src/index.ts",
+			},
+			{
+				isFile: () => true,
+				relative: () => "src/utils.ts",
+				fullpath: () => "/test/project/src/utils.ts",
+			},
+		];
+
+		vi.spyOn(glob, "glob").mockResolvedValue(mockGlobPaths as unknown as string[]);
+
+		const result = await findFiles(["**/*.ts"], {
+			cwd: "/test/project",
+			ignore: [],
+		});
+
+		expect(result).toHaveLength(2);
+		expect(result[0]).toEqual({
+			relativePath: "src/index.ts",
+			fullPath: "/test/project/src/index.ts",
+		});
+		expect(result[1]).toEqual({
+			relativePath: "src/utils.ts",
+			fullPath: "/test/project/src/utils.ts",
+		});
+	});
+
+	it("should use p.relative() for relativePath, not p.name", async () => {
+		// This test verifies the bug fix where p.name was incorrectly used
+		const mockGlobPaths = [
+			{
+				isFile: () => true,
+				name: "index.ts", // This would be wrong to use
+				relative: () => "src/components/index.ts", // This is correct
+				fullpath: () => "/test/project/src/components/index.ts",
+			},
+		];
+
+		vi.spyOn(glob, "glob").mockResolvedValue(mockGlobPaths as unknown as string[]);
+
+		const result = await findFiles(["**/*.ts"], {
+			cwd: "/test/project",
+			ignore: [],
+		});
+
+		// Assert that we get the full relative path, not just the filename
+		expect(result[0].relativePath).toBe("src/components/index.ts");
+		expect(result[0].relativePath).not.toBe("index.ts");
+	});
+
+	it("should filter out directories and only return files", async () => {
+		const mockGlobPaths = [
+			{
+				isFile: () => true,
+				relative: () => "src/index.ts",
+				fullpath: () => "/test/project/src/index.ts",
+			},
+			{
+				isFile: () => false, // Directory
+				relative: () => "src/components",
+				fullpath: () => "/test/project/src/components",
+			},
+			{
+				isFile: () => true,
+				relative: () => "src/utils.ts",
+				fullpath: () => "/test/project/src/utils.ts",
+			},
+		];
+
+		vi.spyOn(glob, "glob").mockResolvedValue(mockGlobPaths as unknown as string[]);
+
+		const result = await findFiles(["**/*.ts"], {
+			cwd: "/test/project",
+			ignore: [],
+		});
+
+		expect(result).toHaveLength(2);
+		expect(result.map((f) => f.relativePath)).toEqual(["src/index.ts", "src/utils.ts"]);
+	});
+
+	it("should handle empty results", async () => {
+		vi.spyOn(glob, "glob").mockResolvedValue([]);
+
+		const result = await findFiles(["**/*.ts"], {
+			cwd: "/test/project",
+			ignore: [],
+		});
+
+		expect(result).toEqual([]);
+	});
+
+	it("should pass options to glob correctly", async () => {
+		const globSpy = vi.spyOn(glob, "glob").mockResolvedValue([]);
+
+		await findFiles(["**/*.ts", "**/*.js"], {
+			cwd: "/test/project",
+			ignore: ["**/*.spec.ts"],
+		});
+
+		expect(globSpy).toHaveBeenCalledWith(
+			["**/*.ts", "**/*.js"],
+			expect.objectContaining({
+				cwd: "/test/project",
+				ignore: ["**/*.spec.ts"],
+				withFileTypes: true,
+			}),
+		);
+	});
+
+	it("should work with nested directory structures", async () => {
+		const mockGlobPaths = [
+			{
+				isFile: () => true,
+				relative: () => "deep/nested/path/to/file.ts",
+				fullpath: () => "/test/project/deep/nested/path/to/file.ts",
+			},
+		];
+
+		vi.spyOn(glob, "glob").mockResolvedValue(mockGlobPaths as unknown as string[]);
+
+		const result = await findFiles(["**/*.ts"], {
+			cwd: "/test/project",
+			ignore: [],
+		});
+
+		expect(result[0]).toEqual({
+			relativePath: "deep/nested/path/to/file.ts",
+			fullPath: "/test/project/deep/nested/path/to/file.ts",
+		});
+	});
+});

package/tests/io/watch.real-fs.spec.ts

@@ -0,0 +1,76 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+// Atomic saves are a real-filesystem behaviour, so this suite opts out of the memfs mock.
+vi.unmock("fs");
+vi.unmock("node:fs");
+vi.unmock("fs/promises");
+vi.unmock("node:fs/promises");
+
+const { mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } = await import("node:fs");
+const { tmpdir } = await import("node:os");
+const { join } = await import("node:path");
+const { watch } = await import("../../src/io/watch.js");
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/** Wait until `predicate` holds, polling, or fail after `timeoutMs`. */
+async function eventually(predicate: () => boolean, timeoutMs = 2000) {
+	const start = Date.now();
+	while (!predicate()) {
+		if (Date.now() - start > timeoutMs) throw new Error("timed out waiting for watch events");
+		await sleep(20);
+	}
+}
+
+// #505: many editors (vim, sed -i, "safe write") and AI agents save by writing a temp file
+// and renaming it over the original. With Node's recursive fs.watch on Linux the watcher then
+// went silent for that file, so hot reload stopped reacting to it.
+describe("io.watch on a real filesystem", () => {
+	let dir: string | undefined;
+	let close: (() => void) | undefined;
+
+	afterEach(() => {
+		close?.();
+		if (dir) rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("keeps reporting changes to a file after it is replaced by an atomic save", async () => {
+		dir = mkdtempSync(join(tmpdir(), "decohere-watch-"));
+		mkdirSync(join(dir, "src"));
+		const file = join(dir, "src", "a.ts");
+		writeFileSync(file, "v0");
+
+		const changes: string[] = [];
+		const watcher = watch(dir, { ignoreInitial: true });
+		close = watcher.close;
+		watcher.on("change", (f) => changes.push(f.relativePath));
+		await watcher.ready;
+
+		for (let i = 1; i <= 3; i++) {
+			const tmp = join(dir, "src", `.a.ts.tmp${i}`);
+			writeFileSync(tmp, `v${i}`);
+			renameSync(tmp, file);
+			await eventually(() => changes.filter((p) => p === "src/a.ts").length >= i);
+		}
+
+		writeFileSync(file, "a plain save after the atomic ones");
+		await eventually(() => changes.filter((p) => p === "src/a.ts").length >= 4);
+		expect(changes.filter((p) => p === "src/a.ts").length).toBeGreaterThanOrEqual(4);
+	});
+
+	it("reports files in a directory created after the watch started", async () => {
+		dir = mkdtempSync(join(tmpdir(), "decohere-watch-"));
+		const added: string[] = [];
+		const watcher = watch(dir, { ignoreInitial: true });
+		close = watcher.close;
+		watcher.on("add", (f) => added.push(f.relativePath));
+		await watcher.ready;
+
+		mkdirSync(join(dir, "feature"));
+		await sleep(50);
+		writeFileSync(join(dir, "feature", "new.ts"), "x");
+
+		await eventually(() => added.includes("feature/new.ts"));
+		expect(added).toContain("feature/new.ts");
+	});
+});