@akiojin/gwt 4.9.1 → 4.11.6

package/src/cli/ui/__tests__/solid/AppSolid.cleanup.test.tsx

@@ -0,0 +1,255 @@
+/** @jsxImportSource @opentui/solid */
+import { describe, expect, it, mock, afterEach } from "bun:test";
+import { testRender } from "@opentui/solid";
+import type { BranchItem, Statistics } from "../../types.js";
+
+if (!mock.module) {
+  mock.module = mock.module.bind(vi);
+}
+
+const makeStats = (overrides: Partial<Statistics> = {}): Statistics => ({
+  localCount: 0,
+  remoteCount: 0,
+  worktreeCount: 0,
+  changesCount: 0,
+  lastUpdated: new Date("2025-01-01T00:00:00Z"),
+  ...overrides,
+});
+
+const createBranch = (overrides: Partial<BranchItem> = {}): BranchItem => {
+  const base: BranchItem = {
+    name: "feature/cleanup-target",
+    type: "local",
+    branchType: "feature",
+    isCurrent: false,
+    icons: [],
+    hasChanges: false,
+    label: "feature/cleanup-target",
+    value: "feature/cleanup-target",
+    worktreeStatus: "active",
+    worktree: {
+      path: "/tmp/worktree",
+      locked: false,
+      prunable: false,
+      isAccessible: true,
+    },
+    mergedPR: { number: 1, mergedAt: "2025-01-01T00:00:00Z" },
+    hasUnpushedCommits: false,
+    syncStatus: "no-upstream",
+  };
+  return {
+    ...base,
+    ...overrides,
+    worktreeStatus: overrides.worktreeStatus ?? base.worktreeStatus,
+  };
+};
+
+afterEach(() => {
+  mock.restore();
+  mock.restore();
+});
+
+describe("AppSolid cleanup command", () => {
+  it("runs cleanup for selected branches when pressing c", async () => {
+    const deleteBranchMock = mock(async () => {});
+    const removeWorktreeMock = mock(async () => {});
+    const getCleanupStatusMock = mock(async () => [
+      {
+        worktreePath: "/tmp/worktree",
+        branch: "feature/cleanup-target",
+        hasUncommittedChanges: false,
+        hasUnpushedCommits: false,
+        cleanupType: "worktree-and-branch",
+        hasRemoteBranch: true,
+        hasUniqueCommits: false,
+        hasUpstream: true,
+        upstream: "origin/feature/cleanup-target",
+        isAccessible: true,
+        reasons: ["no-diff-with-base"],
+      },
+    ]);
+
+    mock.module?.("../../../../worktree.js", () => ({
+      listAdditionalWorktrees: mock(async () => []),
+      repairWorktrees: mock(async () => ({
+        repairedCount: 0,
+        failedCount: 0,
+        failures: [],
+      })),
+      removeWorktree: removeWorktreeMock,
+      getCleanupStatus: getCleanupStatusMock,
+      isProtectedBranchName: mock(() => false),
+    }));
+
+    mock.module?.("../../../../git.js", () => ({
+      getRepositoryRoot: mock(async () => "/repo"),
+      getAllBranches: mock(async () => []),
+      getLocalBranches: mock(async () => []),
+      getCurrentBranch: mock(async () => "main"),
+      deleteBranch: deleteBranchMock,
+    }));
+
+    mock.module?.("../../../../config/index.js", () => ({
+      getConfig: mock(async () => ({ defaultBaseBranch: "main" })),
+      getLastToolUsageMap: mock(async () => new Map()),
+      loadSession: mock(async () => null),
+    }));
+
+    mock.module?.("../../../../config/tools.js", () => ({
+      getAllCodingAgents: mock(async () => [
+        { id: "codex-cli", displayName: "Codex CLI" },
+      ]),
+    }));
+
+    mock.module?.("../../../../config/profiles.js", () => ({
+      loadProfiles: mock(async () => ({ profiles: {}, activeProfile: null })),
+      createProfile: mock(async () => {}),
+      updateProfile: mock(async () => {}),
+      deleteProfile: mock(async () => {}),
+      setActiveProfile: mock(async () => {}),
+    }));
+
+    const { AppSolid } = await import("../../App.solid.js");
+
+    const branch = createBranch();
+    const stats = makeStats({ localCount: 1, worktreeCount: 1 });
+
+    const testSetup = await testRender(
+      () => (
+        <AppSolid
+          branches={[branch]}
+          stats={stats}
+          version={null}
+          toolStatuses={[]}
+        />
+      ),
+      { width: 80, height: 24 },
+    );
+    await testSetup.renderOnce();
+
+    try {
+      await testSetup.mockInput.typeText(" ");
+      await testSetup.renderOnce();
+
+      await testSetup.mockInput.typeText("c");
+      await testSetup.renderOnce();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(removeWorktreeMock).toHaveBeenCalledWith("/tmp/worktree", false);
+      expect(deleteBranchMock).toHaveBeenCalledWith(
+        "feature/cleanup-target",
+        true,
+      );
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("maps cleanup safety indicators from cleanup candidates", async () => {
+    const getCleanupStatusMock = mock(async () => [
+      {
+        worktreePath: "/tmp/safe",
+        branch: "feature/safe",
+        hasUncommittedChanges: false,
+        hasUnpushedCommits: false,
+        cleanupType: "worktree-and-branch",
+        hasRemoteBranch: true,
+        hasUniqueCommits: false,
+        hasUpstream: true,
+        upstream: "origin/feature/safe",
+        isAccessible: true,
+        reasons: ["no-diff-with-base"],
+      },
+      {
+        worktreePath: null,
+        branch: "feature/unsafe",
+        hasUncommittedChanges: false,
+        hasUnpushedCommits: false,
+        cleanupType: "branch-only",
+        hasRemoteBranch: false,
+        hasUniqueCommits: false,
+        hasUpstream: false,
+        upstream: null,
+        reasons: [],
+      },
+    ]);
+
+    mock.module?.("../../../../worktree.js", () => ({
+      listAdditionalWorktrees: mock(async () => []),
+      repairWorktrees: mock(async () => ({
+        repairedCount: 0,
+        failedCount: 0,
+        failures: [],
+      })),
+      removeWorktree: mock(async () => {}),
+      getCleanupStatus: getCleanupStatusMock,
+      isProtectedBranchName: mock(() => false),
+    }));
+
+    mock.module?.("../../../../git.js", () => ({
+      getRepositoryRoot: mock(async () => "/repo"),
+      getAllBranches: mock(async () => []),
+      getLocalBranches: mock(async () => []),
+      getCurrentBranch: mock(async () => "main"),
+      deleteBranch: mock(async () => {}),
+    }));
+
+    mock.module?.("../../../../config/index.js", () => ({
+      getConfig: mock(async () => ({ defaultBaseBranch: "main" })),
+      getLastToolUsageMap: mock(async () => new Map()),
+      loadSession: mock(async () => null),
+    }));
+
+    mock.module?.("../../../../config/tools.js", () => ({
+      getAllCodingAgents: mock(async () => [
+        { id: "codex-cli", displayName: "Codex CLI" },
+      ]),
+    }));
+
+    mock.module?.("../../../../config/profiles.js", () => ({
+      loadProfiles: mock(async () => ({ profiles: {}, activeProfile: null })),
+      createProfile: mock(async () => {}),
+      updateProfile: mock(async () => {}),
+      deleteProfile: mock(async () => {}),
+      setActiveProfile: mock(async () => {}),
+    }));
+
+    const { AppSolid } = await import("../../App.solid.js");
+
+    const safeBranch = createBranch({
+      name: "feature/safe",
+      label: "feature/safe",
+      value: "feature/safe",
+    });
+    const unsafeBranch = createBranch({
+      name: "feature/unsafe",
+      label: "feature/unsafe",
+      value: "feature/unsafe",
+      worktree: undefined,
+      worktreeStatus: undefined,
+    });
+
+    const testSetup = await testRender(
+      () => (
+        <AppSolid
+          branches={[safeBranch, unsafeBranch]}
+          stats={makeStats({ localCount: 2, worktreeCount: 1 })}
+          version={null}
+          toolStatuses={[]}
+        />
+      ),
+      { width: 80, height: 24 },
+    );
+    await testSetup.renderOnce();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await testSetup.renderOnce();
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toMatch(/\[ \] w {2,}feature\/safe/);
+      expect(frame).toContain("[ ] w ! feature/unsafe");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});

package/src/cli/ui/__tests__/solid/BranchListScreen.test.tsx

@@ -0,0 +1,243 @@
+/** @jsxImportSource @opentui/solid */
+import { describe, expect, it } from "bun:test";
+import { testRender } from "@opentui/solid";
+import { BranchListScreen } from "../../screens/solid/BranchListScreen.js";
+import type { BranchListScreenProps } from "../../screens/solid/BranchListScreen.js";
+import type { BranchItem, Statistics } from "../../types.js";
+
+const makeStats = (overrides: Partial<Statistics> = {}): Statistics => ({
+  localCount: 0,
+  remoteCount: 0,
+  worktreeCount: 0,
+  changesCount: 0,
+  lastUpdated: new Date("2025-01-01T00:00:00Z"),
+  ...overrides,
+});
+
+const statsForBranches = (branches: BranchItem[]): Statistics => ({
+  localCount: branches.filter((branch) => branch.type === "local").length,
+  remoteCount: branches.filter((branch) => branch.type === "remote").length,
+  worktreeCount: branches.filter((branch) => Boolean(branch.worktreeStatus))
+    .length,
+  changesCount: branches.filter((branch) => branch.hasChanges).length,
+  lastUpdated: new Date("2025-01-01T00:00:00Z"),
+});
+
+const createBranch = (overrides: Partial<BranchItem> = {}): BranchItem => {
+  const hasWorktree = Boolean(overrides.worktree);
+  const base: BranchItem = {
+    name: "feature/test",
+    type: "local",
+    branchType: "feature",
+    isCurrent: false,
+    icons: [],
+    hasChanges: false,
+    label: "feature/test",
+    value: "feature/test",
+    worktreeStatus: hasWorktree ? "active" : undefined,
+    syncStatus: "no-upstream",
+  };
+  return {
+    ...base,
+    ...overrides,
+    worktreeStatus: overrides.worktreeStatus ?? base.worktreeStatus,
+  };
+};
+
+const renderBranchList = async (props: {
+  branches: BranchItem[];
+  stats?: Statistics;
+  workingDirectory?: string;
+  selectedBranches?: string[];
+  activeProfile?: string | null;
+  cleanupUI?: BranchListScreenProps["cleanupUI"];
+}) => {
+  const testSetup = await testRender(
+    () => (
+      <BranchListScreen
+        branches={props.branches}
+        stats={props.stats ?? makeStats()}
+        onSelect={() => {}}
+        workingDirectory={props.workingDirectory}
+        {...(props.activeProfile !== undefined
+          ? { activeProfile: props.activeProfile }
+          : {})}
+        {...(props.selectedBranches
+          ? { selectedBranches: props.selectedBranches }
+          : {})}
+        {...(props.cleanupUI ? { cleanupUI: props.cleanupUI } : {})}
+      />
+    ),
+    { width: 80, height: 24 },
+  );
+  await testSetup.renderOnce();
+  return testSetup;
+};
+
+describe("BranchListScreen icons", () => {
+  it("renders ASCII icons with spacing and no cursor prefix", async () => {
+    const branches = [
+      createBranch({
+        name: "feature/active-clean",
+        label: "feature/active-clean",
+        value: "feature/active-clean",
+        worktreeStatus: "active",
+        safeToCleanup: true,
+      }),
+      createBranch({
+        name: "feature/no-worktree",
+        label: "feature/no-worktree",
+        value: "feature/no-worktree",
+        worktreeStatus: undefined,
+        safeToCleanup: false,
+        hasUnpushedCommits: true,
+        mergedPR: undefined,
+      }),
+    ];
+
+    const testSetup = await renderBranchList({
+      branches,
+      stats: statsForBranches(branches),
+      selectedBranches: ["feature/active-clean"],
+    });
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toMatch(/\[\*\] w {2,}feature\/active-clean/);
+      expect(frame).toContain("[ ] . ! feature/no-worktree");
+      expect(frame).not.toContain(">[*]");
+      expect(frame).not.toContain(">[ ]");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("shows spinner during safety checks and blank icon for remote branches", async () => {
+    const branches = [
+      createBranch({
+        name: "feature/loading",
+        label: "feature/loading",
+        value: "feature/loading",
+        worktree: { path: "/tmp/worktree", locked: false, prunable: false },
+      }),
+      createBranch({
+        name: "feature/unmerged",
+        label: "feature/unmerged",
+        value: "feature/unmerged",
+        worktree: { path: "/tmp/worktree2", locked: false, prunable: false },
+        isUnmerged: true,
+        safeToCleanup: false,
+      }),
+      createBranch({
+        name: "origin/remote-only",
+        label: "origin/remote-only",
+        value: "origin/remote-only",
+        type: "remote",
+        hasRemoteCounterpart: false,
+        worktree: undefined,
+        worktreeStatus: undefined,
+      }),
+    ];
+
+    const testSetup = await renderBranchList({
+      branches,
+      stats: statsForBranches(branches),
+      cleanupUI: {
+        indicators: {},
+        footerMessage: null,
+        inputLocked: false,
+        safetyLoading: true,
+      },
+    });
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toMatch(/\[ \] w [-\\|/] feature\/loading/);
+      expect(frame).toMatch(/\[ \] w \* feature\/unmerged/);
+      expect(frame).toMatch(/\[ \] \. {2,}origin\/remote-only/);
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});
+
+describe("BranchListScreen worktree footer", () => {
+  it("shows selected worktree path", async () => {
+    const branch = createBranch({
+      worktree: { path: "/tmp/worktree", locked: false, prunable: false },
+      worktreeStatus: "active",
+    });
+    const testSetup = await renderBranchList({
+      branches: [branch],
+      stats: makeStats({ localCount: 1, worktreeCount: 1 }),
+    });
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Worktree: /tmp/worktree");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("falls back to working directory for current branch without worktree", async () => {
+    const branch = createBranch({
+      isCurrent: true,
+      worktree: undefined,
+      worktreeStatus: undefined,
+    });
+    const testSetup = await renderBranchList({
+      branches: [branch],
+      stats: makeStats({ localCount: 1 }),
+      workingDirectory: "/repo/root",
+    });
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Worktree: /repo/root");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("shows (none) when branch list is empty", async () => {
+    const testSetup = await renderBranchList({
+      branches: [],
+      stats: makeStats(),
+    });
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Worktree: (none)");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});
+
+describe("BranchListScreen shortcut hints", () => {
+  it("shows shortcuts in labels and omits them from footer", async () => {
+    const branch = createBranch({
+      name: "feature/shortcuts",
+      label: "feature/shortcuts",
+      value: "feature/shortcuts",
+    });
+    const testSetup = await renderBranchList({
+      branches: [branch],
+      stats: makeStats({ localCount: 1 }),
+      activeProfile: "dev",
+    });
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Filter(f): (press f to filter)");
+      expect(frame).toContain("Mode(tab): All");
+      expect(frame).toContain("Profile(p): dev");
+      expect(frame).not.toContain("[f] Filter");
+      expect(frame).not.toContain("[tab] Mode");
+      expect(frame).not.toContain("[p] Profiles");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});