@akiojin/gwt 4.6.1 → 4.7.0

package/src/cli/ui/components/screens/BranchListScreen.tsx

@@ -93,6 +93,7 @@ export interface BranchListScreenProps {
   onCleanupCommand?: () => void;
   onRefresh?: () => void;
   onOpenProfiles?: () => void;
+  onOpenLogs?: () => void;
   loading?: boolean;
   error?: Error | null;
   lastUpdated?: Date | null;
@@ -128,6 +129,7 @@ export const BranchListScreen = React.memo(function BranchListScreen({
   onCleanupCommand,
   onRefresh,
   onOpenProfiles,
+  onOpenLogs,
   loading = false,
   error = null,
   lastUpdated = null,
@@ -273,6 +275,8 @@ export const BranchListScreen = React.memo(function BranchListScreen({
       onRefresh();
     } else if (input === "p" && onOpenProfiles) {
       onOpenProfiles();
+    } else if (input === "l" && onOpenLogs) {
+      onOpenLogs();
     }
   });
 
@@ -346,6 +350,7 @@ export const BranchListScreen = React.memo(function BranchListScreen({
     { key: "r", description: "Refresh" },
     { key: "c", description: "Cleanup" },
     { key: "p", description: "Profiles" },
+    { key: "l", description: "Logs" },
   ];
 
   const formatLatestCommit = useCallback((timestamp?: number) => {
@@ -622,7 +627,7 @@ export const BranchListScreen = React.memo(function BranchListScreen({
             onChange={setFilterQuery}
             onSubmit={() => {}} // No-op: filter is applied in real-time
             placeholder="Type to search..."
-            blockKeys={["c", "r", "f"]} // Block shortcuts while typing
+            blockKeys={["c", "r", "f", "l"]} // Block shortcuts while typing
           />
         ) : (
           <Text dimColor>{filterQuery || "(press f to filter)"}</Text>

package/src/cli/ui/components/screens/LogDatePickerScreen.tsx

@@ -0,0 +1,83 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { Header } from "../parts/Header.js";
+import { Footer } from "../parts/Footer.js";
+import { Select } from "../common/Select.js";
+import { useAppInput } from "../../hooks/useAppInput.js";
+import { useTerminalSize } from "../../hooks/useTerminalSize.js";
+import type { LogFileInfo } from "../../../../logging/reader.js";
+
+interface DateItem {
+  label: string;
+  value: string;
+}
+
+export interface LogDatePickerScreenProps {
+  dates: LogFileInfo[];
+  onBack: () => void;
+  onSelect: (date: string) => void;
+  version?: string | null;
+}
+
+export function LogDatePickerScreen({
+  dates,
+  onBack,
+  onSelect,
+  version,
+}: LogDatePickerScreenProps) {
+  const { rows } = useTerminalSize();
+
+  useAppInput((input, key) => {
+    if (key.escape || input === "q") {
+      onBack();
+    }
+  });
+
+  const items: DateItem[] = dates.map((date) => ({
+    label: date.date,
+    value: date.date,
+  }));
+
+  const handleSelect = (item: DateItem) => {
+    onSelect(item.value);
+  };
+
+  const headerLines = 2;
+  const statsLines = 1;
+  const emptyLine = 1;
+  const footerLines = 1;
+  const fixedLines = headerLines + statsLines + emptyLine + footerLines;
+  const contentHeight = rows - fixedLines;
+  const limit = Math.max(5, contentHeight);
+
+  const footerActions = [
+    { key: "enter", description: "Select" },
+    { key: "esc", description: "Back" },
+  ];
+
+  return (
+    <Box flexDirection="column" height={rows}>
+      <Header title="gwt - Log Date" titleColor="cyan" version={version} />
+
+      <Box marginTop={1}>
+        <Text>
+          Total: <Text bold>{dates.length}</Text>
+        </Text>
+      </Box>
+
+      <Box height={1} />
+
+      <Box flexDirection="column" flexGrow={1}>
+        {dates.length === 0 ? (
+          <Box>
+            <Text dimColor>ログがありません</Text>
+          </Box>
+        ) : (
+          <Select items={items} onSelect={handleSelect} limit={limit} />
+        )}
+      </Box>
+
+      <Footer actions={footerActions} />
+    </Box>
+  );
+}

package/src/cli/ui/components/screens/LogDetailScreen.tsx

@@ -0,0 +1,67 @@
+import React, { useMemo } from "react";
+import { Box, Text } from "ink";
+import { Header } from "../parts/Header.js";
+import { Footer } from "../parts/Footer.js";
+import { useAppInput } from "../../hooks/useAppInput.js";
+import { useTerminalSize } from "../../hooks/useTerminalSize.js";
+import type { FormattedLogEntry } from "../../../../logging/formatter.js";
+
+export interface LogDetailScreenProps {
+  entry: FormattedLogEntry | null;
+  onBack: () => void;
+  onCopy: (entry: FormattedLogEntry) => void;
+  notification?: { message: string; tone: "success" | "error" } | null;
+  version?: string | null;
+}
+
+export function LogDetailScreen({
+  entry,
+  onBack,
+  onCopy,
+  notification,
+  version,
+}: LogDetailScreenProps) {
+  const { rows } = useTerminalSize();
+
+  useAppInput((input, key) => {
+    if (key.escape || input === "q") {
+      onBack();
+      return;
+    }
+
+    if (input === "c" && entry) {
+      onCopy(entry);
+    }
+  });
+
+  const jsonLines = useMemo<string[]>(() => {
+    if (!entry) return ["ログがありません"]; // fallback
+    return entry.json.split("\n");
+  }, [entry]);
+
+  const footerActions = [
+    { key: "c", description: "Copy" },
+    { key: "esc", description: "Back" },
+  ];
+
+  return (
+    <Box flexDirection="column" height={rows}>
+      <Header title="gwt - Log Detail" titleColor="cyan" version={version} />
+
+      {notification ? (
+        <Box marginTop={1}>
+          <Text color={notification.tone === "error" ? "red" : "green"}>
+            {notification.message}
+          </Text>
+        </Box>
+      ) : null}
+      <Box flexDirection="column" flexGrow={1} marginTop={1}>
+        {jsonLines.map((line, index) => (
+          <Text key={`${line}-${index}`}>{line}</Text>
+        ))}
+      </Box>
+
+      <Footer actions={footerActions} />
+    </Box>
+  );
+}

package/src/cli/ui/components/screens/LogListScreen.tsx

@@ -0,0 +1,192 @@
+import React, { useCallback, useMemo, useState } from "react";
+import { Box, Text } from "ink";
+import stringWidth from "string-width";
+import { Header } from "../parts/Header.js";
+import { Footer } from "../parts/Footer.js";
+import { Select } from "../common/Select.js";
+import { useAppInput } from "../../hooks/useAppInput.js";
+import { useTerminalSize } from "../../hooks/useTerminalSize.js";
+import type { FormattedLogEntry } from "../../../../logging/formatter.js";
+
+interface LogListItem {
+  label: string;
+  value: string;
+  entry: FormattedLogEntry;
+}
+
+export interface LogListScreenProps {
+  entries: FormattedLogEntry[];
+  loading?: boolean;
+  error?: string | null;
+  onBack: () => void;
+  onSelect: (entry: FormattedLogEntry) => void;
+  onCopy: (entry: FormattedLogEntry) => void;
+  onPickDate?: () => void;
+  notification?: { message: string; tone: "success" | "error" } | null;
+  version?: string | null;
+  selectedDate?: string | null;
+}
+
+const truncateToWidth = (value: string, maxWidth: number): string => {
+  if (maxWidth <= 0) return "";
+  if (stringWidth(value) <= maxWidth) return value;
+  const ellipsis = "…";
+  const ellipsisWidth = stringWidth(ellipsis);
+  if (ellipsisWidth >= maxWidth) return ellipsis;
+
+  let result = "";
+  for (const char of Array.from(value)) {
+    if (stringWidth(result + char) + ellipsisWidth > maxWidth) {
+      break;
+    }
+    result += char;
+  }
+  return result + ellipsis;
+};
+
+const padToWidth = (value: string, width: number): string => {
+  if (width <= 0) return "";
+  if (stringWidth(value) >= width) return value;
+  return value + " ".repeat(width - stringWidth(value));
+};
+
+export function LogListScreen({
+  entries,
+  loading = false,
+  error = null,
+  onBack,
+  onSelect,
+  onCopy,
+  onPickDate,
+  notification,
+  version,
+  selectedDate,
+}: LogListScreenProps) {
+  const { rows, columns } = useTerminalSize();
+  const [selectedIndex, setSelectedIndex] = useState(0);
+
+  const maxLabelWidth = Math.max(10, columns - 2);
+
+  const items = useMemo<LogListItem[]>(
+    () =>
+      entries.map((entry) => ({
+        label: truncateToWidth(entry.summary, maxLabelWidth),
+        value: entry.id,
+        entry,
+      })),
+    [entries, maxLabelWidth],
+  );
+
+  const handleSelect = useCallback(
+    (item: LogListItem) => {
+      onSelect(item.entry);
+    },
+    [onSelect],
+  );
+
+  const handleCopy = useCallback(() => {
+    const entry = entries[selectedIndex];
+    if (entry) {
+      onCopy(entry);
+    }
+  }, [entries, selectedIndex, onCopy]);
+
+  useAppInput((input, key) => {
+    if (key.escape || input === "q") {
+      onBack();
+      return;
+    }
+
+    if (input === "c") {
+      handleCopy();
+      return;
+    }
+
+    if (input === "d" && onPickDate) {
+      onPickDate();
+    }
+  });
+
+  const renderItem = useCallback(
+    (item: LogListItem, isSelected: boolean) => {
+      if (!isSelected) {
+        return <Text>{item.label}</Text>;
+      }
+      const padded = padToWidth(item.label, maxLabelWidth);
+      const output = `\u001b[46m\u001b[30m${padded}\u001b[0m`;
+      return <Text>{output}</Text>;
+    },
+    [maxLabelWidth],
+  );
+
+  const headerLines = 2;
+  const statsLines = 1;
+  const emptyLine = 1;
+  const footerLines = 1;
+  const fixedLines = headerLines + statsLines + emptyLine + footerLines;
+  const contentHeight = rows - fixedLines;
+  const limit = Math.max(5, contentHeight);
+
+  const footerActions = [
+    { key: "enter", description: "Detail" },
+    { key: "c", description: "Copy" },
+    { key: "d", description: "Date" },
+    { key: "esc", description: "Back" },
+  ];
+
+  return (
+    <Box flexDirection="column" height={rows}>
+      <Header title="gwt - Log Viewer" titleColor="cyan" version={version} />
+
+      {notification ? (
+        <Box marginTop={1}>
+          <Text color={notification.tone === "error" ? "red" : "green"}>
+            {notification.message}
+          </Text>
+        </Box>
+      ) : null}
+
+      <Box marginTop={1}>
+        <Box marginRight={2}>
+          <Text>
+            Date: <Text bold>{selectedDate ?? "---"}</Text>
+          </Text>
+        </Box>
+        <Text>
+          Total: <Text bold>{entries.length}</Text>
+        </Text>
+      </Box>
+
+      <Box height={1} />
+
+      <Box flexDirection="column" flexGrow={1}>
+        {loading ? (
+          <Box>
+            <Text dimColor>Loading logs...</Text>
+          </Box>
+        ) : entries.length === 0 ? (
+          <Box>
+            <Text dimColor>ログがありません</Text>
+          </Box>
+        ) : (
+          <Select
+            items={items}
+            onSelect={handleSelect}
+            limit={limit}
+            selectedIndex={selectedIndex}
+            onSelectedIndexChange={setSelectedIndex}
+            renderItem={renderItem}
+          />
+        )}
+
+        {error ? (
+          <Box marginTop={1}>
+            <Text color="red">{error}</Text>
+          </Box>
+        ) : null}
+      </Box>
+
+      <Footer actions={footerActions} />
+    </Box>
+  );
+}

package/src/cli/ui/hooks/useGitData.ts

@@ -1,4 +1,4 @@
-import { useState, useEffect, useCallback } from "react";
+import { useState, useEffect, useCallback, useRef } from "react";
 import {
   getAllBranches,
   hasUnpushedCommitsInRepo,
@@ -80,7 +80,15 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
   const [error, setError] = useState<Error | null>(null);
   const [lastUpdated, setLastUpdated] = useState<Date | null>(null);
 
-  const loadData = useCallback(async () => {
+  // キャッシュ機構: 初回ロード完了を追跡（useRef で再レンダリングを防ぐ）
+  const hasLoadedOnceRef = useRef(false);
+
+  const loadData = useCallback(async (forceRefresh = false) => {
+    // キャッシュがあり、強制リフレッシュでなければスキップ
+    if (hasLoadedOnceRef.current && !forceRefresh) {
+      return;
+    }
+
     setLoading(true);
     setError(null);
 
@@ -295,6 +303,7 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
 
       setBranches(enrichedBranches);
       setLastUpdated(new Date());
+      hasLoadedOnceRef.current = true; // 初回ロード完了をマーク
     } catch (err) {
       setError(err instanceof Error ? err : new Error(String(err)));
       setBranches([]);
@@ -305,7 +314,7 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
   }, []);
 
   const refresh = useCallback(() => {
-    loadData();
+    loadData(true); // forceRefresh = true で強制的にデータを再取得
   }, [loadData]);
 
   useEffect(() => {

package/src/cli/ui/types.ts

@@ -188,6 +188,9 @@ export interface GitHubPRResponse {
  */
 export type ScreenType =
   | "branch-list"
+  | "log-list"
+  | "log-detail"
+  | "log-date-picker"
   | "branch-creator"
   | "branch-action-selector"
   | "branch-quick-start"

package/src/cli/ui/utils/clipboard.ts

@@ -0,0 +1,31 @@
+import { execa } from "execa";
+
+export interface ClipboardOptions {
+  platform?: NodeJS.Platform;
+  execa?: typeof execa;
+}
+
+export async function copyToClipboard(
+  text: string,
+  options: ClipboardOptions = {},
+): Promise<void> {
+  const runner = options.execa ?? execa;
+  const platform = options.platform ?? process.platform;
+
+  if (platform === "win32") {
+    await runner("cmd", ["/c", "clip"], { input: text, windowsHide: true });
+    return;
+  }
+
+  if (platform === "darwin") {
+    await runner("pbcopy", [], { input: text });
+    return;
+  }
+
+  try {
+    await runner("xclip", ["-selection", "clipboard"], { input: text });
+    return;
+  } catch {
+    await runner("xsel", ["--clipboard", "--input"], { input: text });
+  }
+}

package/src/gemini.ts

@@ -201,7 +201,12 @@ export async function launchGeminiCLI(
       );
       console.log(chalk.yellow("      npm install -g @google/gemini-cli"));
       console.log("");
-      await new Promise((resolve) => setTimeout(resolve, 2000));
+      const shouldSkipDelay =
+        typeof process !== "undefined" &&
+        (process.env?.NODE_ENV === "test" || Boolean(process.env?.VITEST));
+      if (!shouldSkipDelay) {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      }
       return await run("bunx", [GEMINI_CLI_PACKAGE, ...runArgs]);
     };
 

package/src/index.ts

@@ -768,11 +768,13 @@ export async function handleAIToolWorkflow(
       lastSessionId: finalSessionId,
     });
 
+    let uncommittedExists = false;
     try {
       const [hasUncommitted, hasUnpushed] = await Promise.all([
         hasUncommittedChanges(worktreePath),
         hasUnpushedCommits(worktreePath, branch),
       ]);
+      uncommittedExists = hasUncommitted;
 
       if (hasUncommitted) {
         const uncommittedCount = await getUncommittedChangesCount(worktreePath);
@@ -807,8 +809,15 @@ export async function handleAIToolWorkflow(
       const details = error instanceof Error ? error.message : String(error);
       printWarning(`Failed to check git status after session: ${details}`);
     }
-    // Small buffer before returning to branch list to avoid abrupt screen swap
-    await new Promise((resolve) => setTimeout(resolve, POST_SESSION_DELAY_MS));
+
+    if (uncommittedExists) {
+      await waitForEnter("Press Enter to return to the main menu...");
+    } else {
+      // Small buffer before returning to branch list to avoid abrupt screen swap
+      await new Promise((resolve) =>
+        setTimeout(resolve, POST_SESSION_DELAY_MS),
+      );
+    }
     printInfo("Session completed successfully. Returning to main menu...");
     return;
   } catch (error) {

package/src/logging/formatter.ts

@@ -0,0 +1,106 @@
+export interface FormattedLogEntry {
+  id: string;
+  raw: Record<string, unknown>;
+  timestamp: number | null;
+  timeLabel: string;
+  levelLabel: string;
+  category: string;
+  message: string;
+  summary: string;
+  json: string;
+}
+
+const LEVEL_LABELS: Record<number, string> = {
+  10: "TRACE",
+  20: "DEBUG",
+  30: "INFO",
+  40: "WARN",
+  50: "ERROR",
+  60: "FATAL",
+};
+
+const formatTimeLabel = (
+  value: unknown,
+): { label: string; timestamp: number | null } => {
+  if (typeof value === "string" || typeof value === "number") {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      const hours = String(date.getHours()).padStart(2, "0");
+      const minutes = String(date.getMinutes()).padStart(2, "0");
+      const seconds = String(date.getSeconds()).padStart(2, "0");
+      return {
+        label: `${hours}:${minutes}:${seconds}`,
+        timestamp: date.getTime(),
+      };
+    }
+  }
+
+  return { label: "--:--:--", timestamp: null };
+};
+
+const formatLevelLabel = (value: unknown): string => {
+  if (typeof value === "number") {
+    return LEVEL_LABELS[value] ?? `LEVEL-${value}`;
+  }
+  if (typeof value === "string") {
+    return value.toUpperCase();
+  }
+  return "UNKNOWN";
+};
+
+const resolveMessage = (entry: Record<string, unknown>): string => {
+  if (typeof entry.msg === "string") {
+    return entry.msg;
+  }
+  if (typeof entry.message === "string") {
+    return entry.message;
+  }
+  if (entry.msg !== undefined) {
+    return String(entry.msg);
+  }
+  return "";
+};
+
+export function parseLogLines(
+  lines: string[],
+  options: { limit?: number } = {},
+): FormattedLogEntry[] {
+  const entries: FormattedLogEntry[] = [];
+
+  lines.forEach((line, index) => {
+    if (!line.trim()) return;
+    try {
+      const parsed = JSON.parse(line) as Record<string, unknown>;
+      const { label: timeLabel, timestamp } = formatTimeLabel(parsed.time);
+      const levelLabel = formatLevelLabel(parsed.level);
+      const category =
+        typeof parsed.category === "string" ? parsed.category : "unknown";
+      const message = resolveMessage(parsed);
+      const summary =
+        `[${timeLabel}] [${levelLabel}] [${category}] ${message}`.trim();
+      const json = JSON.stringify(parsed, null, 2);
+      const id = `${timestamp ?? "unknown"}-${index}`;
+
+      entries.push({
+        id,
+        raw: parsed,
+        timestamp,
+        timeLabel,
+        levelLabel,
+        category,
+        message,
+        summary,
+        json,
+      });
+    } catch {
+      // Skip malformed JSON lines
+    }
+  });
+
+  const limit = options.limit ?? 100;
+  if (entries.length <= limit) {
+    return [...entries].reverse();
+  }
+
+  return entries.slice(-limit).reverse();
+}

package/src/logging/reader.ts

@@ -0,0 +1,76 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { formatDate } from "./logger.js";
+
+export interface LogFileInfo {
+  date: string;
+  path: string;
+  mtimeMs: number;
+}
+
+const LOG_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+
+export function resolveLogDir(cwd: string = process.cwd()): string {
+  const cwdBase = path.basename(cwd) || "workspace";
+  return path.join(os.homedir(), ".gwt", "logs", cwdBase);
+}
+
+export function buildLogFilePath(logDir: string, date: string): string {
+  return path.join(logDir, `${date}.jsonl`);
+}
+
+export function getTodayLogDate(): string {
+  return formatDate(new Date());
+}
+
+export async function readLogFileLines(filePath: string): Promise<string[]> {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return content.split("\n").filter(Boolean);
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+
+export async function listLogFiles(logDir: string): Promise<LogFileInfo[]> {
+  try {
+    const entries = await fs.readdir(logDir, { withFileTypes: true });
+    const files: LogFileInfo[] = [];
+
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!LOG_FILENAME_PATTERN.test(entry.name)) continue;
+
+      const date = entry.name.replace(/\.jsonl$/, "");
+      const fullPath = path.join(logDir, entry.name);
+      try {
+        const stat = await fs.stat(fullPath);
+        files.push({ date, path: fullPath, mtimeMs: stat.mtimeMs });
+      } catch {
+        // Ignore stat errors per-file
+      }
+    }
+
+    return files.sort((a, b) => b.date.localeCompare(a.date));
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+
+export async function listRecentLogFiles(
+  logDir: string,
+  days = 7,
+): Promise<LogFileInfo[]> {
+  const files = await listLogFiles(logDir);
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+  return files.filter((file) => file.mtimeMs >= cutoff);
+}