pi-editor-footer 0.1.0

package/test/detail-render.test.ts

@@ -0,0 +1,202 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import { renderDetail, scroll, type DetailItem } from "../src/detail-render";
+
+const item: DetailItem = {
+	label: "to-spec",
+	kind: "skill",
+	description: "Turn the current conversation into a spec.",
+};
+
+describe("renderDetail", () => {
+	test("returns [] for a null item", () => {
+		assert.deepEqual(renderDetail(null, 40, 5, 0), []);
+	});
+
+	test("returns [] for an empty description", () => {
+		assert.deepEqual(renderDetail({ ...item, description: "" }, 40, 5, 0), []);
+	});
+
+	test("returns [] for a whitespace-only description", () => {
+		assert.deepEqual(
+			renderDetail({ ...item, description: "   \n\t " }, 40, 5, 0),
+			[],
+		);
+	});
+
+	test("wraps a long description to width, every line <= width", () => {
+		const longItem: DetailItem = {
+			...item,
+			description:
+				"This is a deliberately long description that will not fit in the window width and must therefore be wrapped across several lines.",
+		};
+		const lines = renderDetail(longItem, 20, 5, 0);
+		assert.ok(lines.length > 1);
+		for (const line of lines) {
+			assert.ok(line.length <= 20, `line too long: ${JSON.stringify(line)}`);
+		}
+		// 129 chars at width 20 → 7 content lines → overflows → marker present.
+		assert.equal(lines[0], "to-spec · skill 1/7");
+	});
+
+	test("shrink-to-fit: short description yields 1 header + content lines", () => {
+		// Description is 42 chars — use a width wide enough that it stays on one line.
+		const lines = renderDetail(item, 60, 5, 0);
+		assert.deepEqual(lines, [
+			"to-spec · skill",
+			"Turn the current conversation into a spec.",
+		]);
+		assert.ok(lines.length < 5);
+	});
+	test("cap: overflowing description yields exactly maxLines lines", () => {
+		const longItem: DetailItem = {
+			...item,
+			description: "word ".repeat(60).trim(),
+		};
+		const lines = renderDetail(longItem, 20, 5, 0);
+		assert.equal(lines.length, 5);
+	});
+
+	test("header carries a scroll marker only when overflowing", () => {
+		// Fits: no marker.
+		const fits = renderDetail(item, 40, 5, 0);
+		assert.equal(fits[0], "to-spec · skill");
+
+		// Overflows: marker ` offset/total` appended.
+		const longItem: DetailItem = {
+			...item,
+			description: "word ".repeat(60).trim(),
+		};
+		const overflows = renderDetail(longItem, 20, 5, 0);
+		assert.match(overflows[0], /^to-spec · skill \d+\/\d+$/);
+		assert.equal(overflows[0], "to-spec · skill 1/15");
+	});
+
+	test("scrollOffset shifts which content lines are visible", () => {
+		// 160 chars at width 30 → 6 content lines with distinct wrap phases;
+		// window shows header + 4 → overflows, max scroll offset 2.
+		const overflowing: DetailItem = {
+			...item,
+			description: "abcdefghij klmnopqrst uvwxyzabcd".repeat(5),
+		};
+		const top = renderDetail(overflowing, 30, 5, 0);
+		assert.equal(top[0], "to-spec · skill 1/6");
+
+		const scrolled = renderDetail(overflowing, 30, 5, 1);
+		assert.equal(scrolled.length, 5);
+		assert.equal(scrolled[0], "to-spec · skill 2/6");
+		// Scrolled lines must differ from the top lines.
+		assert.notDeepEqual(scrolled.slice(1), top.slice(1));
+	});
+
+	test("clamps scrollOffset above the maximum", () => {
+		const longItem: DetailItem = {
+			...item,
+			description: "x".repeat(200),
+		};
+		// 200 chars at width 20 → 10 content lines; window shows 4 content lines → max offset 6.
+		const lines = renderDetail(longItem, 20, 5, 999);
+		assert.equal(lines.length, 5);
+		assert.equal(lines[0], "to-spec · skill 7/10");
+	});
+
+	test("clamps negative scrollOffset to 0", () => {
+		const longItem: DetailItem = {
+			...item,
+			description: "x".repeat(200),
+		};
+		const lines = renderDetail(longItem, 20, 5, -5);
+		assert.equal(lines.length, 5);
+		assert.equal(lines[0], "to-spec · skill 1/10");
+	});
+
+	test("preserves explicit paragraph breaks in the description", () => {
+		const multiline: DetailItem = {
+			...item,
+			description: "First paragraph.\n\nSecond paragraph.",
+		};
+		const lines = renderDetail(multiline, 40, 5, 0);
+		assert.deepEqual(lines, [
+			"to-spec · skill",
+			"First paragraph.",
+			"",
+			"Second paragraph.",
+		]);
+	});
+
+	test("header never exceeds width and the scroll marker survives truncation", () => {
+		const overflowing: DetailItem = {
+			...item,
+			description: "x".repeat(200),
+		};
+		const lines = renderDetail(overflowing, 10, 5, 0);
+		assert.ok(lines[0].length <= 10);
+		assert.match(lines[0], /\d+\/\d+$/);
+	});
+
+	test("shows '...' on the last visible line when content remains below", () => {
+		const longItem: DetailItem = {
+			...item,
+			description: "x".repeat(200), // 10 content lines at width 20
+		};
+		const lines = renderDetail(longItem, 20, 5, 0);
+		assert.equal(lines[4], "...");
+	});
+
+	test("no bottom ellipsis when scrolled to the bottom", () => {
+		const longItem: DetailItem = {
+			...item,
+			description: "x".repeat(200),
+		};
+		const lines = renderDetail(longItem, 20, 5, 999); // clamped to max offset 6
+		assert.equal(lines.length, 5);
+		assert.notEqual(lines[4], "...");
+	});
+
+	test("mid-scroll: only the bottom ellipsis, first visible line stays content", () => {
+		const longItem: DetailItem = {
+			...item,
+			description: "x".repeat(200),
+		};
+		const mid = renderDetail(longItem, 20, 5, 3);
+		assert.notEqual(mid[1], "..."); // no top ellipsis
+		assert.equal(mid[4], "..."); // content still remains below
+	});
+
+	test("no ellipsis when the description fits the window", () => {
+		const lines = renderDetail(item, 60, 5, 0);
+		assert.deepEqual(lines, [
+			"to-spec · skill",
+			"Turn the current conversation into a spec.",
+		]);
+		assert.ok(!lines.includes("..."));
+	});
+});
+
+describe("scroll", () => {
+	test("returns 0 when the description fits the window", () => {
+		assert.equal(scroll(0, 1, 2, 5), 0);
+		assert.equal(scroll(3, -1, 2, 5), 0);
+	});
+
+	test("advances one line per delta within bounds", () => {
+		// 10 content lines, window shows 4 → max offset 6.
+		assert.equal(scroll(0, 1, 10, 5), 1);
+		assert.equal(scroll(3, 1, 10, 5), 4);
+		assert.equal(scroll(4, -1, 10, 5), 3);
+	});
+
+	test("clamps at the bottom (forward)", () => {
+		assert.equal(scroll(6, 1, 10, 5), 6);
+		assert.equal(scroll(999, 1, 10, 5), 6);
+	});
+
+	test("clamps at the top (back)", () => {
+		assert.equal(scroll(0, -1, 10, 5), 0);
+	});
+
+	test("edge: window of 1 line means no content scrollable", () => {
+		assert.equal(scroll(0, 1, 10, 1), 0);
+	});
+});

package/test/footer.test.ts

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { renderFooter } from "../src/footer.js";
+import { createInitialState } from "../src/state.js";
+import { DEFAULT_CONFIG } from "../src/config.js";
+import { emptyGitStatus } from "../src/git.js";
+
+const theme = {
+  fg: (_style: string, text: string) => text,
+};
+
+function makeState(
+  overrides: Partial<ReturnType<typeof createInitialState>> = {},
+) {
+  return { ...createInitialState(), ...overrides };
+}
+
+describe("footer", () => {
+  test("renders one line at normal width", () => {
+    const state = makeState();
+    const lines = renderFooter(80, state, DEFAULT_CONFIG, theme as never, {
+      cwd: "/Users/test/project",
+    });
+    assert.equal(lines.length, 1);
+    assert.ok(lines[0]!.length > 0);
+  });
+
+  test("sheds segments at narrow width", () => {
+    const state = makeState({
+      git: {
+        ...emptyGitStatus(),
+        branch: "feature/very-long-branch-name-that-exceeds",
+        staged: 2,
+        modified: 3,
+      },
+      runtime: { name: "nodejs", version: "20.0.0" },
+    });
+    const narrow = renderFooter(30, state, DEFAULT_CONFIG, theme as never, {
+      cwd: "/Users/test/project",
+    });
+    assert.equal(narrow.length, 1);
+    // Should not exceed width (visible width approximated without ANSI)
+    for (const line of narrow) {
+      assert.ok(line.length <= 80);
+    }
+  });
+
+  test("workspaceDisplay switches cwd format (path vs name)", () => {
+    const state = makeState();
+    const configPath = { ...DEFAULT_CONFIG, workspaceDisplay: "path" as const };
+    const configName = { ...DEFAULT_CONFIG, workspaceDisplay: "name" as const };
+    const linesPath = renderFooter(80, state, configPath, theme as never, {
+      cwd: "/Users/test/long/path/to/project",
+    });
+    const linesName = renderFooter(80, state, configName, theme as never, {
+      cwd: "/Users/test/long/path/to/project",
+    });
+    assert.ok(linesPath[0]!.includes("/Users/test/long/path/to/project") || linesPath[0]!.includes("long/path/to/project"));
+    assert.ok(linesName[0]!.includes("project"));
+    assert.ok(!linesName[0]!.includes("/Users/test/long/path/to/project"));
+  });
+
+  test("respects footerSegments toggles", () => {
+    const state = makeState({ git: { ...emptyGitStatus(), branch: "main" } });
+    const config = {
+      ...DEFAULT_CONFIG,
+      footerSegments: {
+        ...DEFAULT_CONFIG.footerSegments,
+        gitBranch: false,
+        gitStatus: false,
+      },
+    };
+    const lines = renderFooter(80, state, config, theme as never, {
+      cwd: "/tmp",
+    });
+    assert.ok(!lines[0]!.includes("main"));
+  });
+
+  test("handles zero width", () => {
+    const state = makeState();
+    const lines = renderFooter(0, state, DEFAULT_CONFIG, theme as never, {
+      cwd: "/tmp",
+    });
+    assert.equal(lines[0], "");
+  });
+});

package/test/git.test.ts

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { emptyGitStatus, hasGitChanges, readGitStatus } from "../src/git.js";
+
+describe("git", () => {
+  test("emptyGitStatus has defaults", () => {
+    const s = emptyGitStatus();
+    assert.equal(s.branch, undefined);
+    assert.equal(s.ahead, 0);
+    assert.equal(s.staged, 0);
+    assert.equal(s.commit, null);
+  });
+
+  test("hasGitChanges false when clean", () => {
+    assert.equal(hasGitChanges(emptyGitStatus()), false);
+  });
+
+  test("hasGitChanges true when modified", () => {
+    const s = emptyGitStatus();
+    s.modified = 1;
+    assert.equal(hasGitChanges(s), true);
+  });
+
+  test("readGitStatus on non-git dir returns empty", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "git-test-"));
+    try {
+      const status = await readGitStatus(dir);
+      assert.equal(status.branch, undefined);
+      assert.equal(status.staged, 0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("readGitStatus on this repo returns branch", async () => {
+    // Use the worktree root, which is a git repo
+    const status = await readGitStatus(process.cwd());
+    // Branch may be undefined if detached, but should not throw
+    assert.ok(typeof status.ahead === "number");
+    assert.ok(typeof status.staged === "number");
+  });
+});

package/test/header.test.ts

@@ -0,0 +1,169 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  basenamePath,
+  formatCwd,
+  renderHeader,
+  truncatePath,
+  type HeaderThemeLike,
+} from "../src/header.js";
+
+const theme: HeaderThemeLike = {
+  fg: (_style: string, text: string) => text,
+};
+
+describe("formatCwd", () => {
+  it("leaves cwd outside home untouched", () => {
+    const cwd = "/tmp/other/path";
+    // HOME may vary; at least ensure it doesn't throw
+    assert.equal(typeof formatCwd(cwd), "string");
+  });
+
+  it("collapses home to ~", () => {
+    const home = process.env.HOME ?? "";
+    if (!home) return;
+    assert.equal(formatCwd(home), "~");
+    assert.equal(formatCwd(`${home}/projects/foo`), `~/projects/foo`);
+  });
+});
+
+describe("basenamePath", () => {
+  it("extracts basename", () => {
+    assert.equal(basenamePath("~/a/b/c"), "c");
+    assert.equal(basenamePath("/foo/bar"), "bar");
+    assert.equal(basenamePath("single"), "single");
+  });
+});
+
+describe("truncatePath", () => {
+  it("leaves short paths untouched", () => {
+    assert.equal(truncatePath("~/a/b", 10), "~/a/b");
+  });
+
+  it("truncates long paths with middle ellipsis", () => {
+    const long = "~/very/long/path/with/many/segments/here";
+    const out = truncatePath(long, 16);
+    assert.ok(out.includes("..."));
+    assert.ok(out.length <= 16);
+  });
+
+  it("handles maxLen <=3", () => {
+    assert.equal(truncatePath("abcdef", 2), "..");
+  });
+});
+
+describe("renderHeader", () => {
+  it("shows cwd with icon and hints at wide width", () => {
+    const lines = renderHeader(
+      80,
+      {
+        cwd: "/tmp/my-workspace",
+        workspaceDisplay: "path",
+        tipCommands: ["theme", "model-info"],
+      },
+      theme,
+    );
+    assert.equal(lines.length, 1);
+    assert.ok(lines[0]!.includes("my-workspace"));
+    assert.ok(lines[0]!.includes("/theme"));
+  });
+
+  it("honours workspaceDisplay=name (basename only)", () => {
+    const wide = renderHeader(
+      80,
+      {
+        cwd: "/home/user/projects/my-workspace",
+        workspaceDisplay: "name",
+        tipCommands: ["theme"],
+      },
+      theme,
+    );
+    const pathMode = renderHeader(
+      80,
+      {
+        cwd: "/home/user/projects/my-workspace",
+        workspaceDisplay: "path",
+        tipCommands: ["theme"],
+      },
+      theme,
+    );
+    assert.ok(wide[0]!.includes("my-workspace"));
+    // path mode should contain more than just basename (either ~ or full)
+    assert.ok(pathMode[0]!.length >= wide[0]!.length);
+  });
+
+  it("drops tips at narrow width", () => {
+    const lines = renderHeader(
+      20,
+      {
+        cwd: "/tmp/ws",
+        workspaceDisplay: "path",
+        tipCommands: ["theme", "model-info"],
+      },
+      theme,
+    );
+    assert.equal(lines.length, 1);
+    // Should still contain cwd but not necessarily tips (depends on logic)
+    assert.ok(lines[0]!.includes("ws"));
+  });
+
+  it("returns empty for missing cwd", () => {
+    assert.deepEqual(
+      renderHeader(
+        80,
+        { cwd: "", workspaceDisplay: "path", tipCommands: ["theme"] },
+        theme,
+      ),
+      [],
+    );
+  });
+
+  it("returns empty for zero width", () => {
+    assert.deepEqual(
+      renderHeader(
+        0,
+        { cwd: "/tmp/x", workspaceDisplay: "path", tipCommands: ["x"] },
+        theme,
+      ),
+      [],
+    );
+  });
+
+  it("truncates long cwd via truncatePath", () => {
+    const lines = renderHeader(
+      40,
+      {
+        cwd: "/very/long/path/that/needs/truncation/because/it/is/huge/workspace",
+        workspaceDisplay: "path",
+        tipCommands: ["theme"],
+      },
+      theme,
+    );
+    assert.ok(lines[0]!.length <= 40);
+    // When truncation happens, should contain ...
+    if (lines[0]!.length === 40) assert.ok(lines[0]!.includes("..."));
+  });
+
+  it("normalizes tipCommands without leading slash", () => {
+    const lines = renderHeader(
+      80,
+      { cwd: "/tmp/ws", workspaceDisplay: "path", tipCommands: ["theme"] },
+      theme,
+    );
+    assert.ok(lines[0]!.includes("/theme"));
+  });
+
+  it("respects custom cwd icon", () => {
+    const lines = renderHeader(
+      80,
+      {
+        cwd: "/tmp/ws",
+        workspaceDisplay: "path",
+        tipCommands: [],
+        iconCwd: "",
+      },
+      theme,
+    );
+    assert.ok(lines[0]!.includes(""));
+  });
+});

package/test/icons.test.ts

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { resolveGlyphs, resolveIconMode, runtimeSymbol } from "../src/icons.js";
+
+describe("icons", () => {
+  test("resolveIconMode respects explicit modes", () => {
+    assert.equal(resolveIconMode("nerd"), "nerd");
+    assert.equal(resolveIconMode("ascii"), "ascii");
+  });
+
+  test("resolveGlyphs returns glyphs", () => {
+    const nerd = resolveGlyphs("nerd");
+    const ascii = resolveGlyphs("ascii");
+    assert.ok(nerd.git);
+    assert.ok(ascii.git);
+    assert.notEqual(nerd.git, ascii.git);
+  });
+
+  test("runtimeSymbol returns symbols", () => {
+    assert.equal(runtimeSymbol("nodejs", "ascii"), "node");
+    assert.ok(runtimeSymbol("nodejs", "nerd").length > 0);
+    assert.equal(runtimeSymbol("unknown-xyz", "ascii"), "unknown-xyz");
+  });
+});

package/test/runtime.test.ts

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { clearRuntimeCache, readRuntimeInfo } from "../src/runtime.js";
+
+describe("runtime", () => {
+  test("detects nodejs via package.json", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "runtime-node-"));
+    try {
+      writeFileSync(join(dir, "package.json"), "{}");
+      clearRuntimeCache();
+      const info = await readRuntimeInfo(dir);
+      assert.ok(info);
+      assert.equal(info!.name, "nodejs");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("detects python via pyproject.toml", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "runtime-py-"));
+    try {
+      writeFileSync(join(dir, "pyproject.toml"), "[tool.poetry]");
+      clearRuntimeCache();
+      const info = await readRuntimeInfo(dir);
+      assert.ok(info);
+      assert.equal(info!.name, "python");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("detects rust via Cargo.toml", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "runtime-rust-"));
+    try {
+      writeFileSync(join(dir, "Cargo.toml"), "[package]");
+      clearRuntimeCache();
+      const info = await readRuntimeInfo(dir);
+      assert.ok(info);
+      assert.equal(info!.name, "rust");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("returns null for empty dir", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "runtime-empty-"));
+    try {
+      clearRuntimeCache();
+      const info = await readRuntimeInfo(dir);
+      assert.equal(info, null);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("cache returns same on repeat", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "runtime-cache-"));
+    try {
+      writeFileSync(join(dir, "go.mod"), "module example");
+      clearRuntimeCache();
+      const a = await readRuntimeInfo(dir);
+      const b = await readRuntimeInfo(dir);
+      assert.ok(a && b && a.name === b.name);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});