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

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

package/tests/io/watch.spec.ts

@@ -0,0 +1,291 @@
+import path from "node:path";
+import { fs, vol } from "memfs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { watch } from "../../src/io/watch.js";
+
+vi.mock("fs");
+vi.mock("node:fs");
+vi.mock("fs/promises");
+vi.mock("node:fs/promises");
+
+describe("io.watch", () => {
+	beforeEach(() => {
+		vol.reset();
+	});
+
+	afterEach(() => {
+		vol.reset();
+	});
+
+	it("emits change for nested subdirectory files", async () => {
+		const rootPath = "/workspace/project/src";
+		const nestedDirectoryPath = path.join(rootPath, "nested", "deeper");
+		const nestedFilePath = path.join(nestedDirectoryPath, "index.ts");
+		const expectedRelativePath = path.posix.join("nested", "deeper", "index.ts");
+
+		fs.mkdirSync(nestedDirectoryPath, { recursive: true });
+		fs.writeFileSync(nestedFilePath, "export const v = 1;", { encoding: "utf8" });
+
+		await new Promise<void>((resolve, reject) => {
+			const watcher = watch(rootPath);
+
+			watcher.on("change", (file) => {
+				if (file.relativePath !== expectedRelativePath) {
+					return;
+				}
+
+				expect(file.fullPath).toBe(nestedFilePath);
+				watcher.close();
+				resolve();
+			});
+
+			setTimeout(() => {
+				fs.writeFileSync(nestedFilePath, "export const v = 2;", { encoding: "utf8" });
+			}, 30);
+
+			setTimeout(() => {
+				watcher.close();
+				reject(new Error("expected change event was not emitted for nested file"));
+			}, 800);
+		});
+	});
+
+	it("does not emit initial add events when ignoreInitial is true", async () => {
+		const rootPath = "/workspace/project/src";
+		const existingFilePath = path.join(rootPath, "index.ts");
+
+		fs.mkdirSync(rootPath, { recursive: true });
+		fs.writeFileSync(existingFilePath, "export const v = 1;", { encoding: "utf8" });
+
+		await new Promise<void>((resolve, reject) => {
+			const watcher = watch(rootPath, { ignoreInitial: true });
+
+			watcher.on("add", () => {
+				watcher.close();
+				reject(new Error("unexpected initial add event"));
+			});
+
+			setTimeout(() => {
+				watcher.close();
+				resolve();
+			}, 100);
+		});
+	});
+
+	it("emits add for a new file when ignoreInitial is true", async () => {
+		const rootPath = "/workspace/project/src";
+		const addedFilePath = path.join(rootPath, "new-file.ts");
+
+		fs.mkdirSync(rootPath, { recursive: true });
+		fs.writeFileSync(path.join(rootPath, "existing.ts"), "export const x = 1;", {
+			encoding: "utf8",
+		});
+
+		await new Promise<void>((resolve, reject) => {
+			const watcher = watch(rootPath, { ignoreInitial: true });
+
+			watcher.on("add", (file) => {
+				if (file.relativePath !== "new-file.ts") {
+					return;
+				}
+
+				expect(file.fullPath).toBe(addedFilePath);
+				watcher.close();
+				resolve();
+			});
+
+			watcher.ready.then(() => {
+				fs.writeFileSync(addedFilePath, "export const y = 2;", { encoding: "utf8" });
+			});
+
+			setTimeout(() => {
+				watcher.close();
+				reject(new Error("expected add event was not emitted for new file"));
+			}, 800);
+		});
+	});
+
+	it("emits unlink when a watched file is deleted", async () => {
+		const rootPath = "/workspace/project/src";
+		const removedFilePath = path.join(rootPath, "index.ts");
+
+		fs.mkdirSync(rootPath, { recursive: true });
+		fs.writeFileSync(removedFilePath, "export const v = 1;", { encoding: "utf8" });
+
+		await new Promise<void>((resolve, reject) => {
+			const watcher = watch(rootPath, { ignoreInitial: true });
+
+			watcher.on("unlink", (file) => {
+				if (file.relativePath !== "index.ts") {
+					return;
+				}
+
+				expect(file.fullPath).toBe(removedFilePath);
+				watcher.close();
+				resolve();
+			});
+
+			watcher.ready.then(() => {
+				fs.unlinkSync(removedFilePath);
+			});
+
+			setTimeout(() => {
+				watcher.close();
+				reject(new Error("expected unlink event was not emitted for removed file"));
+			}, 800);
+		});
+	});
+
+	it("applies include patterns to emitted events", async () => {
+		const rootPath = "/workspace/project/src";
+		const ignoredFilePath = path.join(rootPath, "ignored.js");
+		const includedFilePath = path.join(rootPath, "included.ts");
+
+		fs.mkdirSync(rootPath, { recursive: true });
+
+		await new Promise<void>((resolve, reject) => {
+			const watcher = watch(rootPath, { ignoreInitial: true, include: ["**/*.ts"] });
+
+			watcher.on("add", (file) => {
+				if (file.relativePath === "ignored.js") {
+					watcher.close();
+					reject(new Error("include filter emitted ignored.js unexpectedly"));
+					return;
+				}
+
+				if (file.relativePath !== "included.ts") {
+					return;
+				}
+
+				expect(file.fullPath).toBe(includedFilePath);
+				watcher.close();
+				resolve();
+			});
+
+			watcher.ready.then(() => {
+				fs.writeFileSync(ignoredFilePath, "export const ignored = true;", {
+					encoding: "utf8",
+				});
+				fs.writeFileSync(includedFilePath, "export const included = true;", {
+					encoding: "utf8",
+				});
+			});
+
+			setTimeout(() => {
+				watcher.close();
+				reject(new Error("include filter did not emit included.ts"));
+			}, 800);
+		});
+	});
+
+	it("applies ignore patterns to emitted events", async () => {
+		const rootPath = "/workspace/project/src";
+		const ignoredFilePath = path.join(rootPath, "index.spec.ts");
+		const includedFilePath = path.join(rootPath, "index.ts");
+
+		fs.mkdirSync(rootPath, { recursive: true });
+
+		await new Promise<void>((resolve, reject) => {
+			const watcher = watch(rootPath, {
+				ignoreInitial: true,
+				ignore: ["**/*.spec.ts"],
+			});
+
+			watcher.on("add", (file) => {
+				if (file.relativePath === "index.spec.ts") {
+					watcher.close();
+					reject(new Error("ignore filter emitted index.spec.ts unexpectedly"));
+					return;
+				}
+
+				if (file.relativePath !== "index.ts") {
+					return;
+				}
+
+				expect(file.fullPath).toBe(includedFilePath);
+				watcher.close();
+				resolve();
+			});
+
+			watcher.ready.then(() => {
+				fs.writeFileSync(ignoredFilePath, "export const ignored = true;", {
+					encoding: "utf8",
+				});
+				fs.writeFileSync(includedFilePath, "export const included = true;", {
+					encoding: "utf8",
+				});
+			});
+
+			setTimeout(() => {
+				watcher.close();
+				reject(new Error("ignore filter did not emit index.ts"));
+			}, 800);
+		});
+	});
+
+	it("emits ready after watcher initialization", async () => {
+		const rootPath = "/workspace/project/src";
+		fs.mkdirSync(rootPath, { recursive: true });
+		fs.writeFileSync(path.join(rootPath, "index.ts"), "export const v = 1;", {
+			encoding: "utf8",
+		});
+
+		await new Promise<void>((resolve, reject) => {
+			const watcher = watch(rootPath, { ignoreInitial: true });
+
+			watcher.on("ready", () => {
+				watcher.close();
+				resolve();
+			});
+
+			setTimeout(() => {
+				watcher.close();
+				reject(new Error("watcher did not emit ready event"));
+			}, 200);
+		});
+	});
+
+	it("resolves watcher.ready after initialization", async () => {
+		const rootPath = "/workspace/project/src";
+		fs.mkdirSync(rootPath, { recursive: true });
+		const watcher = watch(rootPath, { ignoreInitial: true });
+
+		await expect(watcher.ready).resolves.toBeUndefined();
+		watcher.close();
+	});
+
+	it("emits change only once for a single write", async () => {
+		const rootPath = "/workspace/project/src";
+		const filePath = path.join(rootPath, "index.ts");
+
+		fs.mkdirSync(rootPath, { recursive: true });
+		fs.writeFileSync(filePath, "export const v = 1;", { encoding: "utf8" });
+
+		await new Promise<void>((resolve, reject) => {
+			const watcher = watch(rootPath, { ignoreInitial: true });
+			let changeCount = 0;
+
+			watcher.on("change", (file) => {
+				if (file.relativePath !== "index.ts") {
+					return;
+				}
+
+				changeCount += 1;
+			});
+
+			watcher.ready.then(() => {
+				fs.writeFileSync(filePath, "export const v = 2;", { encoding: "utf8" });
+			});
+
+			setTimeout(() => {
+				watcher.close();
+				try {
+					expect(changeCount).toBeLessThanOrEqual(1);
+					resolve();
+				} catch (error) {
+					reject(error);
+				}
+			}, 300);
+		});
+	});
+});

package/tests/mock-prototype.ts

@@ -0,0 +1,12 @@
+import { vi } from "vitest";
+import type { Constructable } from "../src/reflection/index.js";
+
+export function mockPrototype<T extends object>(obj: Constructable<T>): T {
+	const funcs = Object.entries(Object.getOwnPropertyDescriptors(obj.prototype)).filter(
+		([, prop]) => typeof prop.value === "function",
+	);
+	const mock = Object.fromEntries(funcs.map(([key]) => [key, vi.fn()]));
+	const instance = new obj();
+	Object.assign(instance, mock);
+	return instance;
+}

package/tests/semver/semver.spec.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { Semver, SemverError } from "../../src/semver/index.js";
+
+describe("Semver", () => {
+	it("bumps major versions", () => {
+		expect(new Semver("1.2.3").increment("major").toString()).toBe("2.0.0");
+	});
+
+	it("bumps minor versions", () => {
+		expect(new Semver("1.2.3").increment("minor").toString()).toBe("1.3.0");
+	});
+
+	it("bumps patch versions", () => {
+		expect(new Semver("1.2.3").increment("patch").toString()).toBe("1.2.4");
+	});
+
+	it("starts prerelease when none exists", () => {
+		expect(new Semver("1.2.3").increment("prerelease", "dev").toString()).toBe("1.2.4-dev.0");
+	});
+
+	it("increments prerelease counter when identifier matches", () => {
+		expect(new Semver("1.2.3-dev.4").increment("prerelease", "dev").toString()).toBe(
+			"1.2.3-dev.5",
+		);
+	});
+
+	it("resets prerelease counter when identifier differs", () => {
+		expect(new Semver("1.2.3-rc.4").increment("prerelease", "dev").toString()).toBe(
+			"1.2.3-dev.0",
+		);
+	});
+
+	it("preserves prerelease dotted segments before counter", () => {
+		expect(new Semver("1.2.3-dev.feature.7").increment("prerelease", "dev").toString()).toBe(
+			"1.2.3-dev.feature.8",
+		);
+	});
+
+	it("allows chained increments", () => {
+		expect(
+			new Semver("1.2.3").increment("patch").increment("prerelease", "dev").toString(),
+		).toBe("1.2.5-dev.0");
+	});
+
+	it("throws SemverError for invalid semantic version", () => {
+		expect(() => new Semver("not-a-version")).toThrow(SemverError);
+		expect(() => new Semver("not-a-version")).toThrow(
+			"Invalid semantic version: not-a-version",
+		);
+	});
+});