@selesai/code 0.9.15 → 0.10.1

package/dist/extensions/pi-zentui/test/package-version.test.ts

@@ -0,0 +1,321 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+	__test__,
+	PACKAGE_VERSION_ECOSYSTEMS,
+	readPackageVersion,
+} from "../extensions/zentui/package-version";
+
+function makeProject(files: Record<string, string>): string {
+	const cwd = mkdtempSync(join(tmpdir(), "zentui-package-version-"));
+	for (const [name, content] of Object.entries(files)) {
+		const full = join(cwd, name);
+		if (name.includes("/")) {
+			mkdirSync(join(cwd, name.slice(0, name.indexOf("/"))), { recursive: true });
+		}
+		writeFileSync(full, content, "utf8");
+	}
+	return cwd;
+}
+
+function expectEcosystem(cwd: string, ecosystem: string, version: string) {
+	const result = readPackageVersion(cwd);
+	expect(result).not.toBeNull();
+	if (result === null) throw new Error("expected package version result");
+	expect(result.ecosystem).toBe(ecosystem);
+	expect(result.version).toBe(version);
+}
+
+describe("readPackageVersion", () => {
+	it("returns null when no manifest is present", () => {
+		const cwd = makeProject({});
+		expect(readPackageVersion(cwd)).toBeNull();
+	});
+
+	it("parses package.json for npm/bun projects (top-level `version`)", () => {
+		const cwd = makeProject({
+			"package.json": JSON.stringify({ name: "demo", version: "1.2.3" }),
+		});
+		expectEcosystem(cwd, "nodejs", "1.2.3");
+	});
+
+	it("strips surrounding quotes from package.json values", () => {
+		const cwd = makeProject({
+			"package.json": JSON.stringify({ name: "demo", version: '"2.0.0"' }, null, 2),
+		});
+		expect(readPackageVersion(cwd)?.version).toBe("2.0.0");
+	});
+
+	it("returns null for malformed package.json JSON without throwing", () => {
+		const cwd = makeProject({ "package.json": "{ this is not json" });
+		expect(readPackageVersion(cwd)).toBeNull();
+	});
+
+	it("rejects terminal controls in a JSON-decoded package version", () => {
+		const cwd = makeProject({
+			"package.json": JSON.stringify({ version: "1.2.3\x1b]52;c;c2VjcmV0\x07" }),
+		});
+		expect(readPackageVersion(cwd)).toBeNull();
+	});
+
+	it("parses deno.json and deno.jsonc", () => {
+		const denoJson = makeProject({ "deno.json": JSON.stringify({ version: "0.1.0" }) });
+		const denoJsonc = makeProject({
+			"deno.jsonc": `// leading comment\n${JSON.stringify({ version: "0.2.0" })}`,
+		});
+		expect(readPackageVersion(denoJson)?.version).toBe("0.1.0");
+		expect(readPackageVersion(denoJsonc)?.version).toBe("0.2.0");
+	});
+
+	it("parses Maven pom.xml first child <version>", () => {
+		const cwd = makeProject({
+			"pom.xml":
+				"<project><modelVersion>4.0.0</modelVersion><version>3.1.4</version><artifactId>x</artifactId></project>",
+		});
+		expectEcosystem(cwd, "maven", "3.1.4");
+	});
+
+	it("parses Gradle gradle.properties", () => {
+		const cwd = makeProject({ "gradle.properties": "version=4.5.6\ngroup=com.example\n" });
+		expectEcosystem(cwd, "gradle", "4.5.6");
+	});
+
+	it("parses Python pyproject.toml [project].version", () => {
+		const cwd = makeProject({
+			"pyproject.toml": `[project]\nname = "x"\nversion = "1.0.0"\n`,
+		});
+		expectEcosystem(cwd, "python", "1.0.0");
+	});
+
+	it("parses Python pyproject.toml poetry fallback", () => {
+		const cwd = makeProject({
+			"pyproject.toml": `[tool.poetry]\nname = "x"\nversion = "2.0.0"\n`,
+		});
+		expectEcosystem(cwd, "python", "2.0.0");
+	});
+
+	it("parses Python setup.cfg [metadata].version", () => {
+		const cwd = makeProject({
+			"setup.cfg": "[metadata]\nname = x\nversion = 3.2.1\n[options]\ninstall_requires = []\n",
+		});
+		expectEcosystem(cwd, "python", "3.2.1");
+	});
+
+	it("parses Rust Cargo.toml [package].version", () => {
+		const cwd = makeProject({
+			"Cargo.toml": `[package]\nname = "x"\nversion = "0.4.2"\nedition = "2021"\n`,
+		});
+		expectEcosystem(cwd, "rust", "0.4.2");
+	});
+
+	it("parses Rust Cargo.toml workspace-inherited version", () => {
+		const cwd = makeProject({
+			"Cargo.toml": `[package]\nname = "x"\nversion.workspace = true\n\n[workspace]\nversion = "0.9.0"\n`,
+		});
+		expectEcosystem(cwd, "rust", "0.9.0");
+	});
+
+	it("parses PHP composer.json version", () => {
+		const cwd = makeProject({
+			"composer.json": JSON.stringify({ name: "demo/demo", version: "1.4.0" }),
+		});
+		expectEcosystem(cwd, "php", "1.4.0");
+	});
+
+	it("parses Crystal shard.yml top-level version", () => {
+		const cwd = makeProject({
+			"shard.yml": `name: x\nversion: 0.3.0\n\ndependencies:\n  yaml: ~> 1.0\n`,
+		});
+		expectEcosystem(cwd, "crystal", "0.3.0");
+	});
+
+	it("parses Dart pubspec.yaml version", () => {
+		const cwd = makeProject({
+			"pubspec.yaml": `name: x\nversion: 2.5.0\nenvironment:\n  sdk: ">=3.0.0"\n`,
+		});
+		expectEcosystem(cwd, "dart", "2.5.0");
+	});
+
+	it("parses Dart pubspec.yml fallback", () => {
+		const cwd = makeProject({
+			"pubspec.yml": `name: x\nversion: 2.6.0\n`,
+		});
+		expectEcosystem(cwd, "dart", "2.6.0");
+	});
+
+	it("parses Elixir mix.exs project version literal", () => {
+		const cwd = makeProject({
+			"mix.exs":
+				'defmodule Demo.MixProject do\n  use Mix.Project\n\n  def project do\n    [\n      app: :demo,\n      version: "1.7.3",\n      elixir: "~> 1.14"\n    ]\n  end\nend\n',
+		});
+		expectEcosystem(cwd, "elixir", "1.7.3");
+	});
+
+	it("parses elm.json top-level version", () => {
+		const cwd = makeProject({
+			"elm.json": JSON.stringify({
+				type: "application",
+				"source-directories": ["src"],
+				"elm-version": "0.19.1",
+				version: "1.0.0",
+				dependencies: { direct: {}, indirect: {} },
+				"test-dependencies": { direct: {}, indirect: {} },
+			}),
+		});
+		expectEcosystem(cwd, "elm", "1.0.0");
+	});
+
+	it("parses Fortran fpm.toml version", () => {
+		const cwd = makeProject({
+			"fpm.toml": `[package]\nname = "x"\nversion = "0.2.1"\n`,
+		});
+		expectEcosystem(cwd, "fortran", "0.2.1");
+	});
+
+	it("parses Gleam gleam.toml top-level version", () => {
+		const cwd = makeProject({
+			"gleam.toml": `name = "x"\nversion = "1.0.0"\ndescription = "demo"\n`,
+		});
+		expectEcosystem(cwd, "gleam", "1.0.0");
+	});
+
+	it("parses Haskell *.cabal version in package stanza", () => {
+		const cwd = makeProject({
+			"x.cabal": `cabal-version: 2.4\nname: x\nversion: 0.6.0\n\nlibrary\n  exposed-modules: X\n  build-depends: base >= 4.14\n`,
+		});
+		expectEcosystem(cwd, "haskell", "0.6.0");
+	});
+
+	it("parses Helm Chart.yaml chart version", () => {
+		const cwd = makeProject({
+			"Chart.yaml":
+				'apiVersion: v2\nname: x\ndescription: demo\nversion: 0.1.2\nappVersion: "1.0.0"\n',
+		});
+		expectEcosystem(cwd, "helm", "0.1.2");
+	});
+
+	it("parses Julia Project.toml top-level version", () => {
+		const cwd = makeProject({
+			"Project.toml": `name = "X"\nversion = "0.5.2"\n\n[deps]\n\n[compat]\n`,
+		});
+		expectEcosystem(cwd, "julia", "0.5.2");
+	});
+
+	it("parses Meson meson.build static project() version literal", () => {
+		const cwd = makeProject({
+			"meson.build":
+				"project('x', 'c', version: '0.3.0', license: 'MIT')\n\n executable('x', 'main.c')\n",
+		});
+		expectEcosystem(cwd, "meson", "0.3.0");
+	});
+
+	it("parses Nim *.nimble top-level version", () => {
+		const cwd = makeProject({
+			"x.nimble": `# Package\nversion       = "0.2.1"\nauthor        = "x"\ndescription   = "demo"\nlicense       = "MIT"\n\nrequires "nim >= 1.6"\n`,
+		});
+		expectEcosystem(cwd, "nim", "0.2.1");
+	});
+
+	it("parses Ruby *.gemspec spec.version assignment", () => {
+		const cwd = makeProject({
+			"x.gemspec": `Gem::Specification.new do |s|\n  s.name = 'x'\n  s.version = '1.2.0'\n  s.summary = 'demo'\nend\n`,
+		});
+		expectEcosystem(cwd, "ruby", "1.2.0");
+	});
+
+	it("parses Vlang v.mod module version", () => {
+		const cwd = makeProject({
+			"v.mod": `Module {\n\tname: 'x'\n\tversion: '0.4.0'\n\tdescription: 'demo'\n\tauthor: 'x'\n}\n`,
+		});
+		expectEcosystem(cwd, "vlang", "0.4.0");
+	});
+
+	it("parses Xmake xmake.lua static set_version literal", () => {
+		const cwd = makeProject({
+			"xmake.lua": `add_rules("mode.debug", "mode.release")\nset_version("1.6.0")\n\ntarget("demo")\n`,
+		});
+		expectEcosystem(cwd, "xmake", "1.6.0");
+	});
+
+	it("returns null for manifests without a parseable version (silent fallback)", () => {
+		const cases: Array<[string, string]> = [
+			["package.json", JSON.stringify({ name: "demo" })],
+			["deno.json", JSON.stringify({ name: "demo" })],
+			["Cargo.toml", `[package]\nname = "x"\nedition = "2021"\n`],
+			["pyproject.toml", `[project]\nname = "x"\n`],
+			["meson.build", "project('x', 'c')\n"],
+			["xmake.lua", "add_rules('mode.debug')\n"],
+		];
+		for (const [file, content] of cases) {
+			const cwd = makeProject({ [file]: content });
+			expect(readPackageVersion(cwd)).toBeNull();
+		}
+	});
+
+	it("prefers package.json over Chart.yaml when both exist (deterministic priority)", () => {
+		const cwd = makeProject({
+			"package.json": JSON.stringify({ version: "1.0.0" }),
+			"Chart.yaml": "apiVersion: v2\nversion: 2.0.0\n",
+		});
+		const result = readPackageVersion(cwd);
+		expect(result).not.toBeNull();
+		expect(result?.ecosystem).toBe("nodejs");
+		expect(result?.version).toBe("1.0.0");
+	});
+
+	it("strips a single leading 'v' from semver versions", () => {
+		const cwd = makeProject({
+			"package.json": JSON.stringify({ version: "v3.2.1" }),
+		});
+		expect(readPackageVersion(cwd)?.version).toBe("3.2.1");
+	});
+
+	it("does not shell out and survives missing manifests silently", () => {
+		const cwd = mkdtempSync(join(tmpdir(), "zentui-empty-project-"));
+		expect(readPackageVersion(cwd)).toBeNull();
+	});
+
+	it("exposes PACKAGE_VERSION_ECOSYSTEMS as a stable, sorted-ish list", () => {
+		expect(PACKAGE_VERSION_ECOSYSTEMS).toContain("bun");
+		expect(PACKAGE_VERSION_ECOSYSTEMS).toContain("nodejs");
+		expect(PACKAGE_VERSION_ECOSYSTEMS).toContain("python");
+		expect(PACKAGE_VERSION_ECOSYSTEMS).toContain("rust");
+		expect(PACKAGE_VERSION_ECOSYSTEMS).toContain("haskell");
+		expect(PACKAGE_VERSION_ECOSYSTEMS).toContain("ruby");
+		expect(PACKAGE_VERSION_ECOSYSTEMS).toContain("nim");
+	});
+});
+
+describe("cleanVersion", () => {
+	const { cleanVersion } = __test__;
+
+	it.each([
+		["1.2.3", "1.2.3"],
+		['"1.2.3"', "1.2.3"],
+		["'1.2.3'", "1.2.3"],
+		["  1.2.3  ", "1.2.3"],
+		["v3.2.1", "3.2.1"],
+		["0.0.1-alpha", "0.0.1-alpha"],
+	])("cleans %j -> %j", (input, expected) => {
+		expect(cleanVersion(input)).toBe(expected);
+	});
+
+	it.each(["", "   ", "not a version", "1.2.3 with spaces", "{1.2.3}"])("rejects %j", (input) => {
+		expect(cleanVersion(input)).toBeUndefined();
+	});
+
+	it.each([
+		"1.2.3\x07",
+		"1.2.3\x1b",
+		"1.2.3\x7f",
+		"1.2.3\x9d",
+		"1.2.3\x9c",
+		"1.2.3\x1b[31m",
+		"1.2.3\n",
+		"1.2.3\t",
+	])("rejects terminal control input %j", (input) => {
+		expect(cleanVersion(input)).toBeUndefined();
+	});
+});

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

@@ -0,0 +1,250 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	createProjectRefreshScheduler,
+	startProjectRefreshInterval,
+} from "../extensions/zentui/project-refresh";
+
+async function flushPromises(): Promise<void> {
+	await Promise.resolve();
+	await Promise.resolve();
+}
+
+describe("startProjectRefreshInterval", () => {
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	it("runs the refresh callback at the configured interval", () => {
+		vi.useFakeTimers();
+		const refresh = vi.fn();
+
+		const stop = startProjectRefreshInterval(30_000, refresh);
+
+		vi.advanceTimersByTime(29_999);
+		expect(refresh).not.toHaveBeenCalled();
+
+		vi.advanceTimersByTime(1);
+		expect(refresh).toHaveBeenCalledTimes(1);
+
+		vi.advanceTimersByTime(30_000);
+		expect(refresh).toHaveBeenCalledTimes(2);
+
+		stop();
+		vi.advanceTimersByTime(30_000);
+		expect(refresh).toHaveBeenCalledTimes(2);
+	});
+
+	it("does not start a timer when polling is disabled", () => {
+		vi.useFakeTimers();
+		const refresh = vi.fn();
+
+		const stop = startProjectRefreshInterval(0, refresh);
+
+		vi.advanceTimersByTime(120_000);
+		expect(refresh).not.toHaveBeenCalled();
+		expect(() => stop()).not.toThrow();
+	});
+});
+
+describe("createProjectRefreshScheduler", () => {
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	it("throttles bursty project refresh requests", async () => {
+		vi.useFakeTimers();
+		const refresh = vi.fn<(...args: [string]) => Promise<void>>(() => Promise.resolve());
+		const afterRefresh = vi.fn();
+		const scheduler = createProjectRefreshScheduler(refresh, afterRefresh, 5_000);
+
+		scheduler.schedule("initial");
+		await flushPromises();
+
+		expect(refresh).toHaveBeenCalledTimes(1);
+		expect(refresh).toHaveBeenLastCalledWith("initial", expect.anything());
+		expect(afterRefresh).toHaveBeenCalledTimes(1);
+
+		scheduler.schedule("first-pending");
+		scheduler.schedule("latest-pending");
+		await flushPromises();
+
+		expect(refresh).toHaveBeenCalledTimes(1);
+
+		vi.advanceTimersByTime(4_999);
+		await flushPromises();
+		expect(refresh).toHaveBeenCalledTimes(1);
+
+		vi.advanceTimersByTime(1);
+		await flushPromises();
+
+		expect(refresh).toHaveBeenCalledTimes(2);
+		expect(refresh).toHaveBeenLastCalledWith("latest-pending", expect.anything());
+		expect(afterRefresh).toHaveBeenCalledTimes(2);
+	});
+
+	it("coalesces refreshes requested while a refresh is in flight", async () => {
+		vi.useFakeTimers();
+		let finishRefresh: (() => void) | undefined;
+		const refresh = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					finishRefresh = resolve;
+				}),
+		);
+		const afterRefresh = vi.fn();
+		const scheduler = createProjectRefreshScheduler(refresh, afterRefresh, 5_000);
+
+		scheduler.schedule("initial");
+		scheduler.schedule("pending");
+		await flushPromises();
+
+		expect(refresh).toHaveBeenCalledTimes(1);
+		expect(afterRefresh).not.toHaveBeenCalled();
+
+		finishRefresh?.();
+		await flushPromises();
+
+		expect(afterRefresh).toHaveBeenCalledTimes(1);
+		expect(refresh).toHaveBeenCalledTimes(1);
+
+		vi.advanceTimersByTime(5_000);
+		await flushPromises();
+
+		expect(refresh).toHaveBeenCalledTimes(2);
+		expect(refresh).toHaveBeenLastCalledWith("pending", expect.anything());
+	});
+
+	it("preserves force intent while a refresh is in flight", async () => {
+		vi.useFakeTimers();
+		let finishInitialRefresh: (() => void) | undefined;
+		const refresh = vi.fn((target: string) => {
+			if (target !== "initial") return Promise.resolve();
+			return new Promise<void>((resolve) => {
+				finishInitialRefresh = resolve;
+			});
+		});
+		const afterRefresh = vi.fn();
+		const scheduler = createProjectRefreshScheduler(refresh, afterRefresh, 5_000);
+
+		scheduler.schedule("initial");
+		scheduler.schedule("dependency-change", { force: true });
+		await flushPromises();
+
+		expect(refresh).toHaveBeenCalledTimes(1);
+
+		finishInitialRefresh?.();
+		await flushPromises();
+		await flushPromises();
+
+		expect(refresh).toHaveBeenCalledTimes(2);
+		expect(refresh).toHaveBeenLastCalledWith("dependency-change", expect.anything());
+		expect(afterRefresh).toHaveBeenCalledTimes(2);
+
+		scheduler.schedule("ordinary-follow-up");
+		await flushPromises();
+		expect(refresh).toHaveBeenCalledTimes(2);
+
+		vi.advanceTimersByTime(4_999);
+		await flushPromises();
+		expect(refresh).toHaveBeenCalledTimes(2);
+
+		vi.advanceTimersByTime(1);
+		await flushPromises();
+		expect(refresh).toHaveBeenCalledTimes(3);
+		expect(refresh).toHaveBeenLastCalledWith("ordinary-follow-up", expect.anything());
+	});
+
+	it("supports forced refreshes for initial status reads", async () => {
+		vi.useFakeTimers();
+		const refresh = vi.fn<(...args: [string]) => Promise<void>>(() => Promise.resolve());
+		const afterRefresh = vi.fn();
+		const scheduler = createProjectRefreshScheduler(refresh, afterRefresh, 5_000);
+
+		scheduler.schedule("initial");
+		await flushPromises();
+		scheduler.schedule("forced", { force: true });
+		await flushPromises();
+
+		expect(refresh).toHaveBeenCalledTimes(2);
+		expect(refresh).toHaveBeenLastCalledWith("forced", expect.anything());
+	});
+
+	it("recovers from failed refreshes", async () => {
+		vi.useFakeTimers();
+		const refresh = vi
+			.fn<(...args: [string]) => Promise<void>>()
+			.mockRejectedValueOnce(new Error("slow git command failed"))
+			.mockResolvedValue(undefined);
+		const afterRefresh = vi.fn();
+		const scheduler = createProjectRefreshScheduler(refresh, afterRefresh, 5_000);
+
+		scheduler.schedule("initial");
+		await flushPromises();
+		scheduler.schedule("next", { force: true });
+		await flushPromises();
+
+		expect(refresh).toHaveBeenCalledTimes(2);
+		expect(refresh).toHaveBeenLastCalledWith("next", expect.anything());
+		expect(afterRefresh).toHaveBeenCalledTimes(2);
+	});
+
+	it("invalidates an active run before starting a dependency replacement", async () => {
+		const resolvers = new Map<string, () => void>();
+		const applied: string[] = [];
+		const refresh = vi.fn(
+			(target: string, run: { isCurrent: () => boolean }) =>
+				new Promise<void>((resolve) => {
+					resolvers.set(target, () => {
+						if (run.isCurrent()) applied.push(target);
+						resolve();
+					});
+				}),
+		);
+		const afterRefresh = vi.fn();
+		const scheduler = createProjectRefreshScheduler(refresh, afterRefresh, 0);
+
+		scheduler.schedule("old");
+		scheduler.invalidate();
+		scheduler.schedule("replacement", { force: true });
+		expect(refresh).toHaveBeenCalledTimes(2);
+
+		resolvers.get("old")?.();
+		await flushPromises();
+		expect(applied).toEqual([]);
+		expect(afterRefresh).not.toHaveBeenCalled();
+
+		resolvers.get("replacement")?.();
+		await flushPromises();
+		expect(applied).toEqual(["replacement"]);
+		expect(afterRefresh).toHaveBeenCalledTimes(1);
+	});
+
+	it("makes stopped runs stale when a restarted run finishes first", async () => {
+		const resolvers = new Map<string, () => void>();
+		const applied: string[] = [];
+		const refresh = vi.fn(
+			(target: string, run: { isCurrent: () => boolean }) =>
+				new Promise<void>((resolve) => {
+					resolvers.set(target, () => {
+						if (run.isCurrent()) applied.push(target);
+						resolve();
+					});
+				}),
+		);
+		const afterRefresh = vi.fn();
+		const scheduler = createProjectRefreshScheduler(refresh, afterRefresh, 0);
+
+		scheduler.schedule("old");
+		scheduler.stop();
+		scheduler.schedule("new");
+		expect(refresh).toHaveBeenCalledTimes(2);
+
+		resolvers.get("new")?.();
+		await flushPromises();
+		resolvers.get("old")?.();
+		await flushPromises();
+
+		expect(applied).toEqual(["new"]);
+		expect(afterRefresh).toHaveBeenCalledTimes(1);
+	});
+});