@selesai/code 0.9.15 → 0.10.1

package/dist/extensions/pi-zentui/test/project-state.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it } from "vitest";
+import { emptyGitStatus } from "../extensions/zentui/git";
+import { applyProjectRefreshToState } from "../extensions/zentui/project-state";
+import { createInitialState } from "../extensions/zentui/state";
+
+describe("applyProjectRefreshToState", () => {
+	it("keeps last-good git and runtime on transient errors", () => {
+		const state = createInitialState({
+			...emptyGitStatus(),
+			branch: "main",
+			modified: 2,
+		});
+		state.runtime = { name: "nodejs", symbol: "n", style: "bold green", version: "v22" };
+
+		applyProjectRefreshToState(state, {
+			cwd: "/repo",
+			previousCwd: "/repo",
+			git: { kind: "error" },
+			runtime: { kind: "error" },
+		});
+
+		expect(state.branch).toBe("main");
+		expect(state.modified).toBe(2);
+		expect(state.runtime?.name).toBe("nodejs");
+	});
+
+	it("clears git when not a repo", () => {
+		const state = createInitialState({
+			...emptyGitStatus(),
+			branch: "main",
+			dirty: true,
+			modified: 1,
+		});
+
+		applyProjectRefreshToState(state, {
+			cwd: "/tmp",
+			previousCwd: "/tmp",
+			git: { kind: "not_a_repo" },
+			runtime: { kind: "ok", runtime: undefined },
+		});
+
+		expect(state.branch).toBeUndefined();
+		expect(state.modified).toBe(0);
+		expect(state.dirty).toBe(false);
+	});
+
+	it("clears previous project state on cwd change before applying results", () => {
+		const state = createInitialState({
+			...emptyGitStatus(),
+			branch: "old-branch",
+			modified: 3,
+		});
+		state.runtime = { name: "python", symbol: "p", style: "yellow bold", version: "v3" };
+
+		applyProjectRefreshToState(state, {
+			cwd: "/new",
+			previousCwd: "/old",
+			git: { kind: "error" },
+			runtime: { kind: "error" },
+		});
+
+		expect(state.branch).toBeUndefined();
+		expect(state.modified).toBe(0);
+		expect(state.runtime).toBeUndefined();
+	});
+
+	it("applies ok git/runtime results", () => {
+		const state = createInitialState(emptyGitStatus());
+		const nextCwd = applyProjectRefreshToState(state, {
+			cwd: "/repo",
+			previousCwd: undefined,
+			git: {
+				kind: "ok",
+				status: {
+					...emptyGitStatus(),
+					branch: "feat",
+					gitState: "REBASING",
+					gitStateLabel: "REBASING 1/2",
+				},
+			},
+			runtime: {
+				kind: "ok",
+				runtime: { name: "bun", symbol: "b", style: "bold red", version: "v1" },
+			},
+		});
+
+		expect(nextCwd).toBe("/repo");
+		expect(state.branch).toBe("feat");
+		expect(state.gitStateLabel).toBe("REBASING 1/2");
+		expect(state.runtime?.name).toBe("bun");
+	});
+
+	it("applies ok packageVersion result and clears it when manifest disappears", () => {
+		const state = createInitialState(emptyGitStatus());
+
+		applyProjectRefreshToState(state, {
+			cwd: "/repo",
+			previousCwd: "/repo",
+			git: { kind: "ok", status: emptyGitStatus() },
+			runtime: { kind: "ok", runtime: undefined },
+			packageVersion: {
+				kind: "ok",
+				result: { ecosystem: "nodejs", version: "1.2.3" },
+			},
+		});
+		expect(state.packageVersion).toEqual({ ecosystem: "nodejs", version: "1.2.3" });
+
+		applyProjectRefreshToState(state, {
+			cwd: "/repo",
+			previousCwd: "/repo",
+			git: { kind: "ok", status: emptyGitStatus() },
+			runtime: { kind: "ok", runtime: undefined },
+			packageVersion: { kind: "ok", result: null },
+		});
+		expect(state.packageVersion).toBeUndefined();
+	});
+
+	it("keeps last-good packageVersion on transient error", () => {
+		const state = createInitialState(emptyGitStatus());
+		state.packageVersion = { ecosystem: "rust", version: "0.4.2" };
+
+		applyProjectRefreshToState(state, {
+			cwd: "/repo",
+			previousCwd: "/repo",
+			git: { kind: "ok", status: emptyGitStatus() },
+			runtime: { kind: "ok", runtime: undefined },
+			packageVersion: { kind: "error" },
+		});
+		expect(state.packageVersion).toEqual({ ecosystem: "rust", version: "0.4.2" });
+	});
+
+	it("clears packageVersion on cwd change even when no result is provided", () => {
+		const state = createInitialState(emptyGitStatus());
+		state.packageVersion = { ecosystem: "python", version: "2.0.0" };
+
+		applyProjectRefreshToState(state, {
+			cwd: "/new",
+			previousCwd: "/old",
+			git: { kind: "error" },
+			runtime: { kind: "error" },
+		});
+		expect(state.packageVersion).toBeUndefined();
+	});
+
+	it("clears commit and metrics on cwd change", () => {
+		const state = createInitialState(emptyGitStatus());
+		state.commit = { oid: "abc123", detached: true, tag: "v1" };
+		state.metrics = { added: 10, deleted: 5 };
+
+		applyProjectRefreshToState(state, {
+			cwd: "/new",
+			previousCwd: "/old",
+			git: { kind: "error" },
+			runtime: { kind: "error" },
+		});
+		expect(state.commit).toBeUndefined();
+		expect(state.metrics).toBeUndefined();
+	});
+});

package/dist/extensions/pi-zentui/test/repository-root.test.ts

@@ -0,0 +1,108 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+	findRepositoryRoot,
+	RepositoryRootController,
+	repositoryRootForCwd,
+	updateRepositoryRootState,
+} from "../extensions/zentui/repository-root";
+
+function deferred(): { promise: Promise<void>; resolve: () => void } {
+	let resolve = () => {};
+	const promise = new Promise<void>((done) => {
+		resolve = done;
+	});
+	return { promise, resolve };
+}
+
+describe("repository root discovery", () => {
+	it.each(["directory", "file"] as const)("finds the nearest .git %s", (markerKind) => {
+		const parent = mkdtempSync(join(tmpdir(), "zentui-repository-root-"));
+		const root = join(parent, "repo");
+		const nested = join(root, "extensions", "zentui");
+		try {
+			mkdirSync(nested, { recursive: true });
+			if (markerKind === "directory") mkdirSync(join(root, ".git"));
+			else writeFileSync(join(root, ".git"), "gitdir: ../worktrees/repo\n");
+			expect(findRepositoryRoot(nested)).toBe(root);
+		} finally {
+			rmSync(parent, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("repository root state", () => {
+	it("keeps A invalid through A→B→A until the fresh A generation completes", async () => {
+		const parent = mkdtempSync(join(tmpdir(), "zentui-repository-transition-"));
+		const rootA = join(parent, "repo-a");
+		const cwdA = join(rootA, "src");
+		const rootB = join(parent, "repo-b");
+		const cwdB = join(rootB, "lib");
+		const controller = new RepositoryRootController();
+		try {
+			mkdirSync(join(rootA, ".git"), { recursive: true });
+			mkdirSync(cwdA, { recursive: true });
+			mkdirSync(join(rootB, ".git"), { recursive: true });
+			mkdirSync(cwdB, { recursive: true });
+
+			const initialA = controller.request(cwdA);
+			expect(controller.update(initialA, true)).toBe(rootA);
+			expect(controller.rootForCwd(cwdA)).toBe(rootA);
+
+			const oldAResult = deferred();
+			const oldARequest = controller.request(cwdA);
+			const oldARefresh = oldAResult.promise.then(() => controller.update(oldARequest, true));
+			const bResult = deferred();
+			const bRequest = controller.request(cwdB);
+			const bRefresh = bResult.promise.then(() => controller.update(bRequest, true));
+			const freshAResult = deferred();
+			const freshARequest = controller.request(cwdA);
+			const freshARefresh = freshAResult.promise.then(() => controller.update(freshARequest, true));
+
+			expect(controller.rootForCwd(cwdA)).toBeUndefined();
+			bResult.resolve();
+			expect(await bRefresh).toBeUndefined();
+			expect(controller.rootForCwd(cwdA)).toBeUndefined();
+			oldAResult.resolve();
+			expect(await oldARefresh).toBeUndefined();
+			expect(controller.rootForCwd(cwdA)).toBeUndefined();
+
+			freshAResult.resolve();
+			expect(await freshARefresh).toBe(rootA);
+			expect(controller.rootForCwd(cwdA)).toBe(rootA);
+			expect(controller.rootForCwd(cwdB)).toBeUndefined();
+		} finally {
+			rmSync(parent, { recursive: true, force: true });
+		}
+	});
+
+	it("updates and clears roots across repository and cwd transitions", () => {
+		let state = updateRepositoryRootState("/repo-a/src", true, () => "/repo-a");
+		expect(repositoryRootForCwd(state, "/repo-a/src", () => true)).toBe("/repo-a");
+		expect(repositoryRootForCwd(state, "/repo-b/lib", () => true)).toBeUndefined();
+
+		state = updateRepositoryRootState("/repo-b/lib", true, () => "/repo-b");
+		expect(repositoryRootForCwd(state, "/repo-b/lib", () => true)).toBe("/repo-b");
+
+		state = updateRepositoryRootState("/tmp", false);
+		expect(repositoryRootForCwd(state, "/tmp", () => true)).toBeUndefined();
+	});
+
+	it("clears missing roots and lookup failures instead of reusing stale state", () => {
+		const failed = updateRepositoryRootState("/repo/src", true, () => {
+			throw new Error("lookup failed");
+		});
+		expect(failed).toEqual({ cwd: "/repo/src" });
+		expect(repositoryRootForCwd(failed, "/repo/src", () => true)).toBeUndefined();
+
+		const missing = updateRepositoryRootState("/repo/src", true, () => "/repo");
+		expect(repositoryRootForCwd(missing, "/repo/src", () => false)).toBeUndefined();
+		expect(
+			repositoryRootForCwd(missing, "/repo/src", () => {
+				throw new Error("marker lookup failed");
+			}),
+		).toBeUndefined();
+	});
+});