@akiojin/gwt 4.11.6 → 4.12.0

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

@@ -103,7 +103,7 @@ describe("BranchListScreen icons", () => {
 
     try {
       const frame = testSetup.captureCharFrame();
-      expect(frame).toMatch(/\[\*\] w {2,}feature\/active-clean/);
+      expect(frame).toMatch(/\[\*\] w o feature\/active-clean/);
       expect(frame).toContain("[ ] . ! feature/no-worktree");
       expect(frame).not.toContain(">[*]");
       expect(frame).not.toContain(">[ ]");
@@ -112,7 +112,7 @@ describe("BranchListScreen icons", () => {
     }
   });
 
-  it("shows spinner during safety checks and blank icon for remote branches", async () => {
+  it("shows spinner for pending safety checks and blank icon for remote branches", async () => {
     const branches = [
       createBranch({
         name: "feature/loading",
@@ -146,7 +146,7 @@ describe("BranchListScreen icons", () => {
         indicators: {},
         footerMessage: null,
         inputLocked: false,
-        safetyLoading: true,
+        safetyPendingBranches: new Set(["feature/loading"]),
       },
     });
 
@@ -183,8 +183,6 @@ describe("BranchListScreen worktree footer", () => {
   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],
@@ -241,3 +239,105 @@ describe("BranchListScreen shortcut hints", () => {
     }
   });
 });
+
+describe("BranchListScreen status legend", () => {
+  it("shows legend for uncommitted/unpushed/unmerged indicators", async () => {
+    const branch = createBranch({
+      name: "feature/legend",
+      label: "feature/legend",
+      value: "feature/legend",
+    });
+    const testSetup = await renderBranchList({
+      branches: [branch],
+      stats: makeStats({ localCount: 1 }),
+    });
+
+    try {
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain(
+        "Legend: o Safe  ! Uncommitted  ! Unpushed  * Unmerged",
+      );
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});
+
+describe("BranchListScreen cursor position stability (FR-037a)", () => {
+  it("preserves cursor position when safety check completes", async () => {
+    const { createSignal } = await import("solid-js");
+    const branches = [
+      createBranch({
+        name: "feature/first",
+        label: "feature/first",
+        value: "feature/first",
+        worktreeStatus: "active",
+      }),
+      createBranch({
+        name: "feature/second",
+        label: "feature/second",
+        value: "feature/second",
+        worktreeStatus: "active",
+      }),
+      createBranch({
+        name: "feature/third",
+        label: "feature/third",
+        value: "feature/third",
+        worktreeStatus: "active",
+      }),
+    ];
+
+    // safetyPendingBranchesを動的に変更するためのシグナル
+    const [safetyPending, setSafetyPending] = createSignal<Set<string>>(
+      new Set(["feature/first", "feature/second", "feature/third"]),
+    );
+
+    const testSetup = await testRender(
+      () => (
+        <BranchListScreen
+          branches={branches}
+          stats={statsForBranches(branches)}
+          onSelect={() => {}}
+          cleanupUI={{
+            indicators: {},
+            footerMessage: null,
+            inputLocked: false,
+            safetyPendingBranches: safetyPending(),
+          }}
+        />
+      ),
+      { width: 80, height: 24 },
+    );
+    await testSetup.renderOnce();
+
+    try {
+      // 1. 初期状態ではカーソルは最初のブランチにある
+      let frame = testSetup.captureCharFrame();
+      // 最初のブランチがハイライトされている（選択されている）ことを確認
+      expect(frame).toContain("feature/first");
+
+      // 2. 下矢印キーでカーソルを2番目のブランチに移動
+      testSetup.mockInput.pressArrow("down");
+      await testSetup.renderOnce();
+
+      // 3. 安全状態確認が完了したことをシミュレート（pendingから削除）
+      setSafetyPending(new Set(["feature/second", "feature/third"]));
+      await testSetup.renderOnce();
+
+      // さらに別のブランチの安全状態確認が完了
+      setSafetyPending(new Set(["feature/third"]));
+      await testSetup.renderOnce();
+
+      // 4. カーソル位置が保持されていることを確認
+      // カーソルが2番目のブランチにあるので、下矢印でさらに移動できるはず
+      testSetup.mockInput.pressArrow("down");
+      await testSetup.renderOnce();
+
+      // 3番目のブランチに移動できていれば、カーソル位置は保持されていた
+      frame = testSetup.captureCharFrame();
+      expect(frame).toContain("feature/third");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});

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

@@ -0,0 +1,77 @@
+/** @jsxImportSource @opentui/solid */
+import { describe, expect, it } from "bun:test";
+import { testRender } from "@opentui/solid";
+import { TestRecorder } from "@opentui/core/testing";
+import { ConfirmScreen } from "../../screens/solid/ConfirmScreen.js";
+
+const getBgColor = (bg: Float32Array, width: number, x: number, y: number) => {
+  const index = (y * width + x) * 4;
+  return [
+    bg[index] ?? 0,
+    bg[index + 1] ?? 0,
+    bg[index + 2] ?? 0,
+    bg[index + 3] ?? 0,
+  ];
+};
+
+const isSameColor = (a: number[], b: number[], epsilon = 0.001) =>
+  a.length === b.length &&
+  a.every((value, i) => Math.abs(value - b[i]) < epsilon);
+
+describe("ConfirmScreen selection width", () => {
+  it("limits highlight to provided width", async () => {
+    const width = 20;
+    const height = 5;
+    const selectionWidth = 8;
+    const testSetup = await testRender(
+      () => (
+        <ConfirmScreen
+          message="Confirm?"
+          onConfirm={() => {}}
+          yesLabel="OK"
+          noLabel="Cancel"
+          width={selectionWidth}
+        />
+      ),
+      { width, height },
+    );
+
+    const recorder = new TestRecorder(testSetup.renderer, {
+      recordBuffers: { bg: true },
+    });
+    recorder.rec();
+
+    try {
+      await testSetup.renderOnce();
+      recorder.stop();
+
+      const frame = recorder.recordedFrames.at(-1);
+      if (!frame?.buffers?.bg) {
+        throw new Error("No background buffer recorded");
+      }
+
+      const bg = frame.buffers.bg;
+      const defaultColor = getBgColor(bg, width, 0, 0);
+      const targetRow = 1;
+      let highlightLength = 0;
+
+      for (let x = 0; x < width; x += 1) {
+        const color = getBgColor(bg, width, x, targetRow);
+        if (!isSameColor(color, defaultColor)) {
+          highlightLength += 1;
+        } else {
+          break;
+        }
+      }
+
+      expect(highlightLength).toBe(selectionWidth);
+
+      for (let x = selectionWidth; x < width; x += 1) {
+        const color = getBgColor(bg, width, x, targetRow);
+        expect(isSameColor(color, defaultColor)).toBe(true);
+      }
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});

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

@@ -0,0 +1,351 @@
+/** @jsxImportSource @opentui/solid */
+import { describe, expect, it, mock } from "bun:test";
+import { testRender } from "@opentui/solid";
+import { parseColor } from "@opentui/core";
+import { createSignal } from "solid-js";
+import type { FormattedLogEntry } from "../../../../logging/formatter.js";
+
+const makeEntry = (
+  message: string,
+  overrides: Partial<FormattedLogEntry> = {},
+): FormattedLogEntry => ({
+  id: "1",
+  raw: { level: 30, time: "2026-01-08T00:00:00.000Z", category: "cli" },
+  timestamp: 0,
+  timeLabel: "00:00:00",
+  levelLabel: "INFO",
+  category: "cli",
+  message,
+  summary: `[00:00:00] [INFO] [cli] ${message}`,
+  json: JSON.stringify({ message }, null, 2),
+  ...overrides,
+});
+
+const findLine = (frame: string, needle: string) => {
+  const lines = frame.split("\n");
+  const index = lines.findIndex((line) => line.includes(needle));
+  if (index < 0) {
+    throw new Error(`Line not found: ${needle}`);
+  }
+  return { index, line: lines[index] ?? "" };
+};
+
+const readColorAt = (
+  buffer: Float32Array,
+  width: number,
+  row: number,
+  col: number,
+) => {
+  const offset = (row * width + col) * 4;
+  return [
+    Math.round(buffer[offset] * 255),
+    Math.round(buffer[offset + 1] * 255),
+    Math.round(buffer[offset + 2] * 255),
+    Math.round(buffer[offset + 3] * 255),
+  ] as const;
+};
+
+describe("LogScreen", () => {
+  it("updates entries when data changes", async () => {
+    const [entries, setEntries] = createSignal<FormattedLogEntry[]>([]);
+
+    const { LogScreen } = await import("../../screens/solid/LogScreen.js");
+
+    const testSetup = await testRender(
+      () => (
+        <LogScreen
+          entries={entries()}
+          branchLabel="feature/logs"
+          sourceLabel="/tmp/feature-logs"
+          onBack={() => {}}
+          onSelect={() => {}}
+          onCopy={() => {}}
+        />
+      ),
+      { width: 80, height: 24 },
+    );
+
+    try {
+      await testSetup.renderOnce();
+      let frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Branch: feature/logs");
+      expect(frame).toContain("Source: /tmp/feature-logs");
+      expect(frame).toContain("No logs available.");
+
+      setEntries([makeEntry("Hello")]);
+      await testSetup.renderOnce();
+      frame = testSetup.captureCharFrame();
+      expect(frame).toContain("[00:00:00] [INFO ] [cli ] Hello");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("filters entries by query and shows counts", async () => {
+    const entries = [
+      makeEntry("alpha", {
+        id: "1",
+        category: "cli",
+        raw: { level: 30, time: "2026-01-08T00:00:00.000Z", category: "cli" },
+      }),
+      makeEntry("beta", {
+        id: "2",
+        category: "agent.stdout",
+        raw: {
+          level: 50,
+          time: "2026-01-08T00:00:01.000Z",
+          category: "agent.stdout",
+        },
+      }),
+    ];
+
+    const { LogScreen } = await import("../../screens/solid/LogScreen.js");
+
+    const testSetup = await testRender(
+      () => (
+        <LogScreen
+          entries={entries}
+          onBack={() => {}}
+          onSelect={() => {}}
+          onCopy={() => {}}
+        />
+      ),
+      { width: 80, height: 24 },
+    );
+
+    try {
+      await testSetup.renderOnce();
+      let frame = testSetup.captureCharFrame();
+      expect(frame).toContain("alpha");
+      expect(frame).toContain("beta");
+
+      await testSetup.mockInput.typeText("f");
+      await testSetup.renderOnce();
+
+      await testSetup.mockInput.typeText("agent");
+      await testSetup.renderOnce();
+      testSetup.mockInput.pressEnter();
+      await testSetup.renderOnce();
+
+      frame = testSetup.captureCharFrame();
+      expect(frame).toContain("beta");
+      expect(frame).not.toContain("alpha");
+      expect(frame).toContain("Showing 1 of 2");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("cycles level filter with v and hides lower levels", async () => {
+    const entries = [
+      makeEntry("info-log", {
+        id: "1",
+        levelLabel: "INFO",
+        raw: { level: 30, time: "2026-01-08T00:00:00.000Z", category: "cli" },
+      }),
+      makeEntry("error-log", {
+        id: "2",
+        levelLabel: "ERROR",
+        raw: { level: 50, time: "2026-01-08T00:00:01.000Z", category: "cli" },
+      }),
+    ];
+
+    const { LogScreen } = await import("../../screens/solid/LogScreen.js");
+
+    const testSetup = await testRender(
+      () => (
+        <LogScreen
+          entries={entries}
+          onBack={() => {}}
+          onSelect={() => {}}
+          onCopy={() => {}}
+        />
+      ),
+      { width: 80, height: 24 },
+    );
+
+    try {
+      await testSetup.renderOnce();
+      let frame = testSetup.captureCharFrame();
+      expect(frame).toContain("info-log");
+      expect(frame).toContain("error-log");
+
+      await testSetup.mockInput.typeText("v");
+      await testSetup.renderOnce();
+      await testSetup.mockInput.typeText("v");
+      await testSetup.renderOnce();
+
+      frame = testSetup.captureCharFrame();
+      expect(frame).toContain("error-log");
+      expect(frame).not.toContain("info-log");
+      expect(frame).toContain("Level: WARN+");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("triggers reload/tail and truncates long lines", async () => {
+    const onReload = mock();
+    const onToggleTail = mock();
+    const longMessage =
+      "this-is-a-very-long-log-line-that-should-be-truncated-with-ellipsis";
+    const entries = [
+      makeEntry(longMessage, {
+        id: "1",
+        raw: { level: 30, time: "2026-01-08T00:00:00.000Z", category: "cli" },
+      }),
+    ];
+
+    const { LogScreen } = await import("../../screens/solid/LogScreen.js");
+
+    const testSetup = await testRender(
+      () => (
+        <LogScreen
+          entries={entries}
+          onBack={() => {}}
+          onSelect={() => {}}
+          onCopy={() => {}}
+          onReload={onReload}
+          onToggleTail={onToggleTail}
+        />
+      ),
+      { width: 40, height: 16 },
+    );
+
+    try {
+      await testSetup.renderOnce();
+
+      await testSetup.mockInput.typeText("r");
+      await testSetup.renderOnce();
+      expect(onReload).toHaveBeenCalledTimes(1);
+
+      await testSetup.mockInput.typeText("t");
+      await testSetup.renderOnce();
+      expect(onToggleTail).toHaveBeenCalledTimes(1);
+
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain("...");
+      expect(frame).not.toContain("Wrap:");
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("triggers reset and shows Reset in footer", async () => {
+    const onReset = mock();
+    const { LogScreen } = await import("../../screens/solid/LogScreen.js");
+
+    const testSetup = await testRender(
+      () => (
+        <LogScreen
+          entries={[]}
+          onBack={() => {}}
+          onSelect={() => {}}
+          onCopy={() => {}}
+          onReset={onReset}
+        />
+      ),
+      { width: 80, height: 16 },
+    );
+
+    try {
+      await testSetup.renderOnce();
+      const frame = testSetup.captureCharFrame();
+      expect(frame).toContain("Reset");
+
+      await testSetup.mockInput.typeText("x");
+      await testSetup.renderOnce();
+      expect(onReset).toHaveBeenCalledTimes(1);
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("highlights the selected row with full-width cyan background", async () => {
+    const entries = [
+      makeEntry("alpha", {
+        id: "1",
+        raw: { level: 30, time: "2026-01-08T00:00:00.000Z", category: "cli" },
+      }),
+      makeEntry("beta", {
+        id: "2",
+        raw: { level: 30, time: "2026-01-08T00:00:01.000Z", category: "cli" },
+      }),
+    ];
+
+    const { LogScreen } = await import("../../screens/solid/LogScreen.js");
+
+    const width = 60;
+    const testSetup = await testRender(
+      () => (
+        <LogScreen
+          entries={entries}
+          onBack={() => {}}
+          onSelect={() => {}}
+          onCopy={() => {}}
+        />
+      ),
+      { width, height: 16 },
+    );
+
+    try {
+      await testSetup.renderOnce();
+      const frame = testSetup.captureCharFrame();
+      const { index: row } = findLine(frame, "alpha");
+      const buffers = testSetup.renderer.currentRenderBuffer.buffers;
+      const bg = readColorAt(buffers.bg, width, row, width - 1);
+      const fg = readColorAt(buffers.fg, width, row, width - 1);
+
+      expect(bg).toEqual(parseColor("cyan").toInts());
+      expect(fg).toEqual(parseColor("black").toInts());
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+
+  it("colors the level column for non-selected rows", async () => {
+    const entries = [
+      makeEntry("first", {
+        id: "1",
+        levelLabel: "INFO",
+        raw: { level: 30, time: "2026-01-08T00:00:00.000Z", category: "cli" },
+      }),
+      makeEntry("second", {
+        id: "2",
+        levelLabel: "ERROR",
+        raw: { level: 50, time: "2026-01-08T00:00:01.000Z", category: "cli" },
+      }),
+    ];
+
+    const { LogScreen } = await import("../../screens/solid/LogScreen.js");
+
+    const width = 80;
+    const testSetup = await testRender(
+      () => (
+        <LogScreen
+          entries={entries}
+          onBack={() => {}}
+          onSelect={() => {}}
+          onCopy={() => {}}
+        />
+      ),
+      { width, height: 16 },
+    );
+
+    try {
+      await testSetup.renderOnce();
+      testSetup.mockInput.pressArrow("down");
+      await testSetup.renderOnce();
+      const frame = testSetup.captureCharFrame();
+      const { index: row, line } = findLine(frame, "first");
+      const levelIndex = line.indexOf("INFO");
+      expect(levelIndex).toBeGreaterThanOrEqual(0);
+
+      const buffers = testSetup.renderer.currentRenderBuffer.buffers;
+      const fg = readColorAt(buffers.fg, width, row, levelIndex);
+      expect(fg).toEqual(parseColor("green").toInts());
+    } finally {
+      testSetup.renderer.destroy();
+    }
+  });
+});

package/src/cli/ui/__tests__/solid/components/QuickStartStep.test.tsx

@@ -131,7 +131,11 @@ describe("QuickStartStep", () => {
         testSetup.mockInput.pressEnter();
         await testSetup.renderOnce();
         expect(resumedEntry).not.toBeNull();
-        expect(resumedEntry?.toolId).toBe("claude-code");
+        const assertedEntry = resumedEntry as ToolSessionEntry | null;
+        if (!assertedEntry) {
+          throw new Error("Expected resumed entry");
+        }
+        expect(assertedEntry.toolId).toBe("claude-code");
       } finally {
         testSetup.renderer.destroy();
       }
@@ -193,7 +197,7 @@ describe("QuickStartStep", () => {
 
       try {
         // 矢印キーで最後の項目（Choose different settings）を選択
-        for (let i = 0; i < 5; i++) {
+        for (let i = 0; i < 4; i++) {
           testSetup.mockInput.pressArrow("down");
           await testSetup.renderOnce();
         }
@@ -234,4 +238,71 @@ describe("QuickStartStep", () => {
       }
     });
   });
+
+  describe("missing sessionId", () => {
+    it("does not render Resume option when sessionId is missing", async () => {
+      const historyWithoutSession: ToolSessionEntry[] = [
+        {
+          toolId: "claude-code",
+          toolLabel: "Claude Code",
+          branch: "feature/test",
+          worktreePath: "/path/to/worktree",
+          model: "claude-sonnet-4-20250514",
+          mode: "normal",
+          timestamp: Date.now(),
+          sessionId: null,
+        },
+      ];
+      const testSetup = await testRender(
+        () => (
+          <QuickStartStep
+            history={historyWithoutSession}
+            onResume={() => {}}
+            onStartNew={() => {}}
+            onChooseDifferent={() => {}}
+            onBack={() => {}}
+          />
+        ),
+        { width: 80, height: 24 },
+      );
+      await testSetup.renderOnce();
+
+      try {
+        const frame = testSetup.captureCharFrame();
+        expect(frame).not.toContain("Resume session");
+        expect(frame).toContain("Start new (previous settings)");
+        expect(frame).toContain("Choose different settings");
+      } finally {
+        testSetup.renderer.destroy();
+      }
+    });
+  });
+
+  describe("multi-tool display", () => {
+    it("renders tool-specific descriptions and session id only for resume", async () => {
+      const testSetup = await testRender(
+        () => (
+          <QuickStartStep
+            history={mockHistory}
+            onResume={() => {}}
+            onStartNew={() => {}}
+            onChooseDifferent={() => {}}
+            onBack={() => {}}
+          />
+        ),
+        { width: 90, height: 24 },
+      );
+      await testSetup.renderOnce();
+
+      try {
+        const frame = testSetup.captureCharFrame();
+        expect(frame).toContain("Claude Code, claude-sonnet-4-20250514");
+        expect(frame).toContain("Codex CLI, o3-mini, high");
+        expect(frame).toContain("Session: session-123");
+        expect(frame).toContain("Session: session-456");
+      } finally {
+        testSetup.renderer.destroy();
+      }
+    });
+  });
 });

package/src/cli/ui/__tests__/solid/components/WizardSteps.test.tsx

@@ -230,7 +230,10 @@ describe("SkipPermissionsStep", () => {
       // Enterキーで選択（デフォルトはYes）
       testSetup.mockInput.pressEnter();
       await testSetup.renderOnce();
-      expect(selected).toBe(true);
+      if (selected === null) {
+        throw new Error("Expected selection");
+      }
+      expect(selected === true).toBe(true);
     } finally {
       testSetup.renderer.destroy();
     }