@selesai/code 0.9.14 → 0.10.0

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

@@ -0,0 +1,212 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+	detectGitState,
+	emptyGitStatus,
+	parseGitNumstat,
+	parseGitStatusPorcelain,
+} from "../extensions/zentui/git";
+
+describe("parseGitStatusPorcelain", () => {
+	it("returns empty status for empty output", () => {
+		expect(parseGitStatusPorcelain("", 0)).toEqual(emptyGitStatus());
+	});
+
+	it("emptyGitStatus clears commit and metrics", () => {
+		const empty = emptyGitStatus();
+		expect(empty.commit).toBeUndefined();
+		expect(empty.metrics).toBeUndefined();
+	});
+
+	it("parses branch, ahead/behind, and file states", () => {
+		const status = parseGitStatusPorcelain(
+			[
+				"# branch.head main",
+				"# branch.ab +2 -1",
+				"1 .M N... 100644 100644 100644 abc abc file.txt",
+				"1 M. N... 100644 100644 100644 abc abc staged.txt",
+				"2 R. N... 100644 100644 100644 abc abc R100 old.ts\tnew.ts",
+				"? untracked.ts",
+				"u UU N... 100644 100644 100644 100644 abc abc conflict.ts",
+			].join("\n"),
+			1,
+		);
+
+		expect(status).toMatchObject({
+			branch: "main",
+			dirty: true,
+			ahead: 2,
+			behind: 1,
+			modified: 1,
+			staged: 1,
+			renamed: 1,
+			untracked: 1,
+			conflicted: 1,
+			stashed: 1,
+		});
+	});
+
+	it("hides detached head as no branch", () => {
+		const status = parseGitStatusPorcelain("# branch.head (detached)", 0);
+		expect(status.branch).toBeUndefined();
+	});
+
+	it("captures branch.oid and detached flag", () => {
+		const detached = parseGitStatusPorcelain(
+			["# branch.oid a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2", "# branch.head (detached)"].join(
+				"\n",
+			),
+			0,
+		);
+		expect(detached.branch).toBeUndefined();
+		expect(detached.commit).toEqual({
+			oid: "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2",
+			detached: true,
+			tag: null,
+		});
+	});
+
+	it("captures branch.oid on a normal branch and reports detached=false", () => {
+		const onBranch = parseGitStatusPorcelain(
+			["# branch.oid deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", "# branch.head main"].join("\n"),
+			0,
+		);
+		expect(onBranch.branch).toBe("main");
+		expect(onBranch.commit?.oid).toBe("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef");
+		expect(onBranch.commit?.detached).toBe(false);
+	});
+
+	it("treats unborn branch.oid (initial) as null and skips commit info without branch headers", () => {
+		const unborn = parseGitStatusPorcelain(
+			["# branch.oid (initial)", "# branch.head main (no commits)"].join("\n"),
+			0,
+		);
+		expect(unborn.commit?.oid).toBeNull();
+		// No branch headers at all → no commit info.
+		expect(parseGitStatusPorcelain("", 0).commit).toBeUndefined();
+	});
+});
+
+describe("detectGitState", () => {
+	function fixture(files: Record<string, string>) {
+		const root = mkdtempSync(join(tmpdir(), "zentui-git-state-"));
+		const paths: Record<string, string> = {};
+		for (const [name, content] of Object.entries(files)) {
+			const full = join(root, name);
+			const slash = name.indexOf("/");
+			if (slash > 0) {
+				mkdirSync(join(root, name.slice(0, slash)), { recursive: true });
+			}
+			writeFileSync(full, content, "utf8");
+			paths[name] = full;
+		}
+		return { root, paths };
+	}
+
+	function requirePath(paths: Record<string, string>, key: string): string {
+		const value = paths[key];
+		if (!value) throw new Error(`missing fixture path ${key}`);
+		return value;
+	}
+
+	it("detects REBASING with step counts from rebase-merge", () => {
+		const { paths } = fixture({
+			"rebase-merge/msgnum": "3\n",
+			"rebase-merge/end": "10\n",
+		});
+		const msgnum = requirePath(paths, "rebase-merge/msgnum");
+		const end = requirePath(paths, "rebase-merge/end");
+		const rebaseMerge = join(msgnum, "..");
+		expect(
+			detectGitState({
+				rebaseMerge,
+				rebaseMsgnum: msgnum,
+				rebaseEnd: end,
+			}),
+		).toEqual({ gitState: "REBASING", gitStateLabel: "REBASING 3/10" });
+	});
+
+	it("detects MERGING / CHERRY-PICKING / REVERTING / BISECTING", () => {
+		const { paths } = fixture({
+			MERGE_HEAD: "abc",
+			CHERRY_PICK_HEAD: "def",
+			REVERT_HEAD: "ghi",
+			BISECT_LOG: "log",
+		});
+		expect(detectGitState({ mergeHead: requirePath(paths, "MERGE_HEAD") })).toEqual({
+			gitState: "MERGING",
+			gitStateLabel: "MERGING",
+		});
+		expect(detectGitState({ cherryPickHead: requirePath(paths, "CHERRY_PICK_HEAD") })).toEqual({
+			gitState: "CHERRY-PICKING",
+			gitStateLabel: "CHERRY-PICKING",
+		});
+		expect(detectGitState({ revertHead: requirePath(paths, "REVERT_HEAD") })).toEqual({
+			gitState: "REVERTING",
+			gitStateLabel: "REVERTING",
+		});
+		expect(detectGitState({ bisectLog: requirePath(paths, "BISECT_LOG") })).toEqual({
+			gitState: "BISECTING",
+			gitStateLabel: "BISECTING",
+		});
+	});
+
+	describe("parseGitNumstat", () => {
+		it("sums added/deleted across text files", () => {
+			expect(
+				parseGitNumstat(["10\t5\tsrc/a.ts", "3\t0\tsrc/b.ts", "0\t7\tsrc/c.ts"].join("\n")),
+			).toEqual({ added: 13, deleted: 12 });
+		});
+
+		it("skips binary rows (-\t-)", () => {
+			expect(parseGitNumstat("-\t-\tasset.png\n5\t2\tsrc.ts")).toEqual({ added: 5, deleted: 2 });
+		});
+
+		it("handles rename rows (old\tnew path)", () => {
+			expect(parseGitNumstat("0\t0\told.ts\tnew.ts")).toEqual({ added: 0, deleted: 0 });
+			expect(parseGitNumstat("5\t1\told.ts\tnew.ts")).toEqual({ added: 5, deleted: 1 });
+		});
+
+		it("handles CRLF line endings", () => {
+			expect(parseGitNumstat("3\t2\ta.ts\r\n1\t1\tb.ts\r\n")).toEqual({
+				added: 4,
+				deleted: 3,
+			});
+		});
+
+		it("ignores malformed lines", () => {
+			expect(
+				parseGitNumstat(["garbage", "", "abc\tdef\tnotnum", "5\t2\tok.ts"].join("\n")),
+			).toEqual({ added: 5, deleted: 2 });
+		});
+
+		it("returns zeros for empty output", () => {
+			expect(parseGitNumstat("")).toEqual({ added: 0, deleted: 0 });
+		});
+	});
+
+	it("prefers rebase over merge", () => {
+		const { paths } = fixture({
+			"rebase-apply/msgnum": "1\n",
+			"rebase-apply/end": "2\n",
+			MERGE_HEAD: "abc",
+		});
+		const msgnum = requirePath(paths, "rebase-apply/msgnum");
+		const end = requirePath(paths, "rebase-apply/end");
+		const rebaseApply = join(msgnum, "..");
+		expect(
+			detectGitState({
+				rebaseApply,
+				mergeHead: requirePath(paths, "MERGE_HEAD"),
+				rebaseMsgnum: msgnum,
+				rebaseEnd: end,
+			}).gitState,
+		).toBe("REBASING");
+	});
+
+	it("returns empty when no state files exist", () => {
+		expect(detectGitState({})).toEqual({});
+	});
+});

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

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { defaultConfig } from "../extensions/zentui/config";
+import {
+	ASCII_DEFAULT_ICONS,
+	ICON_GLYPH_KEYS,
+	NERD_DEFAULT_ICONS,
+	RUNTIME_ASCII_SYMBOLS,
+	resolveConfiguredIcons,
+	resolveOsIcon,
+	resolveRuntimeSymbol,
+} from "../extensions/zentui/icons";
+import { runtimeMetadata } from "../extensions/zentui/runtime";
+
+describe("icon tables", () => {
+	it("keeps nerd defaults byte-identical to historical defaultConfig icons", () => {
+		for (const key of ICON_GLYPH_KEYS) {
+			expect(NERD_DEFAULT_ICONS[key]).toBe(defaultConfig.icons[key]);
+		}
+	});
+
+	it("provides ascii defaults for every nerd icon key", () => {
+		for (const key of ICON_GLYPH_KEYS) {
+			expect(typeof ASCII_DEFAULT_ICONS[key]).toBe("string");
+		}
+	});
+
+	it("covers runtime metadata names with ascii symbols", () => {
+		for (const runtime of runtimeMetadata) {
+			expect(RUNTIME_ASCII_SYMBOLS[runtime.name]).toBeTruthy();
+		}
+	});
+});
+
+describe("resolveConfiguredIcons", () => {
+	it("starts from nerd for auto/nerd and ascii for ascii mode", () => {
+		expect(resolveConfiguredIcons("auto").cwd).toBe(NERD_DEFAULT_ICONS.cwd);
+		expect(resolveConfiguredIcons("nerd").git).toBe(NERD_DEFAULT_ICONS.git);
+		expect(resolveConfiguredIcons("ascii").cwd).toBe(ASCII_DEFAULT_ICONS.cwd);
+	});
+
+	it("lets user overrides win over mode defaults", () => {
+		expect(resolveConfiguredIcons("ascii", { cwd: "DIR", os: "X" })).toMatchObject({
+			mode: "ascii",
+			cwd: "DIR",
+			os: "X",
+			git: ASCII_DEFAULT_ICONS.git,
+		});
+	});
+});
+
+describe("resolveOsIcon", () => {
+	it("always honors a custom os icon", () => {
+		expect(resolveOsIcon("X", "auto", "darwin")).toBe("X");
+		expect(resolveOsIcon("X", "ascii", "linux")).toBe("X");
+		expect(resolveOsIcon("X", "nerd", "win32")).toBe("X");
+	});
+
+	it("maps platforms when os is still the mode default", () => {
+		expect(resolveOsIcon(NERD_DEFAULT_ICONS.os, "auto", "linux")).toBe("\uf17c");
+		expect(resolveOsIcon(ASCII_DEFAULT_ICONS.os, "ascii", "darwin")).toBe("mac");
+	});
+});
+
+describe("resolveRuntimeSymbol", () => {
+	it("returns nerd symbol unless ascii mode is active", () => {
+		expect(resolveRuntimeSymbol("nodejs", "", "auto")).toBe("");
+		expect(resolveRuntimeSymbol("nodejs", "", "ascii")).toBe("node");
+	});
+});