@akiojin/gwt 4.6.1 → 4.8.0

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/branchFormatter.ts

@@ -125,6 +125,19 @@ function buildLastToolUsageLabel(
   return parts.join(" | ");
 }
 
+/**
+ * Calculate the latest activity timestamp for a branch.
+ * Returns the maximum of git commit timestamp and tool usage timestamp (in seconds).
+ */
+export function getLatestActivityTimestamp(branch: BranchInfo): number {
+  const gitTimestampSec = branch.latestCommitTimestamp ?? 0;
+  // lastToolUsage.timestamp is in milliseconds, convert to seconds
+  const toolTimestampSec = branch.lastToolUsage?.timestamp
+    ? Math.floor(branch.lastToolUsage.timestamp / 1000)
+    : 0;
+  return Math.max(gitTimestampSec, toolTimestampSec);
+}
+
 /**
  * Converts BranchInfo to BranchItem with display properties
  */
@@ -357,11 +370,12 @@ function sortBranches(
     if (aHasWorktree && !bHasWorktree) return -1;
     if (!aHasWorktree && bHasWorktree) return 1;
 
-    // 5. Prioritize most recent commit within same worktree status
-    const aCommit = a.latestCommitTimestamp ?? 0;
-    const bCommit = b.latestCommitTimestamp ?? 0;
-    if (aCommit !== bCommit) {
-      return bCommit - aCommit;
+    // 5. Prioritize most recent activity within same worktree status
+    // (max of git commit timestamp and tool usage timestamp)
+    const aLatest = getLatestActivityTimestamp(a);
+    const bLatest = getLatestActivityTimestamp(b);
+    if (aLatest !== bLatest) {
+      return bLatest - aLatest;
     }
 
     // 6. Local branches are prioritized over remote-only

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/codex.ts

@@ -196,7 +196,6 @@ export async function launchCodexCLI(
 
       const child = execa("bunx", [CODEX_CLI_PACKAGE, ...args], {
         cwd: worktreePath,
-        shell: true,
         stdin: childStdio.stdin,
         stdout: childStdio.stdout,
         stderr: childStdio.stderr,

package/src/gemini.ts

@@ -175,7 +175,6 @@ export async function launchGeminiCLI(
       const run = async (cmd: string, args: string[]) => {
         const child = execa(cmd, args, {
           cwd: worktreePath,
-          shell: true,
           stdin: childStdio.stdin,
           stdout: childStdio.stdout,
           stderr: childStdio.stderr,
@@ -201,7 +200,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]);
     };
 
@@ -323,7 +327,7 @@ export async function launchGeminiCLI(
  */
 export async function isGeminiCLIAvailable(): Promise<boolean> {
   try {
-    await execa("bunx", [GEMINI_CLI_PACKAGE, "--version"], { shell: true });
+    await execa("bunx", [GEMINI_CLI_PACKAGE, "--version"]);
     return true;
   } catch (error: unknown) {
     const err = error as NodeJS.ErrnoException;

package/src/index.ts

@@ -13,7 +13,6 @@ import {
   hasUnpushedCommits,
   getUncommittedChangesCount,
   getUnpushedCommitsCount,
-  pushBranchToRemote,
   GitError,
 } from "./git.js";
 import { launchClaudeCode } from "./claude.js";
@@ -57,7 +56,7 @@ import {
   DependencyInstallError,
   type DependencyInstallResult,
 } from "./services/dependency-installer.js";
-import { confirmYesNo, waitForEnter } from "./utils/prompt.js";
+import { waitForEnter } from "./utils/prompt.js";
 
 const ERROR_PROMPT = chalk.yellow(
   "Review the error details, then press Enter to continue.",
@@ -435,7 +434,7 @@ export async function handleAIToolWorkflow(
       switch (dependencyStatus.reason) {
         case "missing-lockfile":
           warningMessage =
-            "Skipping automatic install because no lockfiles (bun.lock / pnpm-lock.yaml / package-lock.json) or package.json were found. Run the appropriate package-manager install command manually if needed.";
+            "Skipping automatic install because no lockfiles (bun.lock / pnpm-lock.yaml / package-lock.json) or package.json could be found. Run the appropriate package-manager install command manually if needed.";
           break;
         case "missing-binary":
           warningMessage = `Package manager '${dependencyStatus.manager ?? "unknown"}' is not available in this environment; skipping automatic install.`;
@@ -554,23 +553,21 @@ export async function handleAIToolWorkflow(
       throw new Error(`Tool not found: ${tool}`);
     }
 
-    // Save selection immediately so "last tool" is reflected even if the tool
-    // is interrupted or killed mid-run (e.g., Ctrl+C).
-    await saveSession(
-      {
-        lastWorktreePath: worktreePath,
-        lastBranch: branch,
-        lastUsedTool: tool,
-        toolLabel: toolConfig.displayName ?? tool,
-        mode,
-        model: normalizedModel ?? null,
-        reasoningLevel: inferenceLevel ?? null,
-        skipPermissions: skipPermissions ?? null,
-        timestamp: Date.now(),
-        repositoryRoot: repoRoot,
-      },
-      { skipHistory: true },
-    );
+    // Save selection immediately (including history) so "last tool" is reflected
+    // even if the tool is interrupted or killed mid-run (e.g., Ctrl+C).
+    // FR-042: Record timestamp to session history immediately on tool start.
+    await saveSession({
+      lastWorktreePath: worktreePath,
+      lastBranch: branch,
+      lastUsedTool: tool,
+      toolLabel: toolConfig.displayName ?? tool,
+      mode,
+      model: normalizedModel ?? null,
+      reasoningLevel: inferenceLevel ?? null,
+      skipPermissions: skipPermissions ?? null,
+      timestamp: Date.now(),
+      repositoryRoot: repoRoot,
+    });
 
     // Lookup saved session ID for Continue (auto attach)
     let resumeSessionId: string | null =
@@ -600,96 +597,127 @@ export async function handleAIToolWorkflow(
 
     const launchStartedAt = Date.now();
 
+    // FR-043: Start periodic timestamp update timer (30 seconds interval)
+    // This ensures the latest activity time is updated even if the tool is force-killed
+    const SESSION_UPDATE_INTERVAL_MS = 30_000;
+    const updateTimer = setInterval(async () => {
+      try {
+        await saveSession(
+          {
+            lastWorktreePath: worktreePath,
+            lastBranch: branch,
+            lastUsedTool: tool,
+            toolLabel: toolConfig.displayName ?? tool,
+            mode,
+            model: normalizedModel ?? null,
+            reasoningLevel: inferenceLevel ?? null,
+            skipPermissions: skipPermissions ?? null,
+            timestamp: Date.now(),
+            repositoryRoot: repoRoot,
+          },
+          { skipHistory: true }, // Don't add to history, just update timestamp
+        );
+      } catch {
+        // Ignore errors during periodic update
+      }
+    }, SESSION_UPDATE_INTERVAL_MS);
+
     // Launch selected AI tool
     // Builtin tools use their dedicated launch functions
     // Custom tools use the generic launchCustomAITool function
     let launchResult: { sessionId?: string | null } | void;
-    if (tool === "claude-code") {
-      const launchOptions: {
-        mode?: "normal" | "continue" | "resume";
-        skipPermissions?: boolean;
-        envOverrides?: Record<string, string>;
-        model?: string;
-        sessionId?: string | null;
-        chrome?: boolean;
-      } = {
-        mode:
-          mode === "resume"
-            ? "resume"
-            : mode === "continue"
-              ? "continue"
-              : "normal",
-        skipPermissions,
-        envOverrides: sharedEnv,
-        sessionId: resumeSessionId,
-        chrome: true,
-      };
-      if (normalizedModel) {
-        launchOptions.model = normalizedModel;
-      }
-      launchResult = await launchClaudeCode(worktreePath, launchOptions);
-    } else if (tool === "codex-cli") {
-      const launchOptions: {
-        mode?: "normal" | "continue" | "resume";
-        bypassApprovals?: boolean;
-        envOverrides?: Record<string, string>;
-        model?: string;
-        reasoningEffort?: CodexReasoningEffort;
-        sessionId?: string | null;
-      } = {
-        mode:
-          mode === "resume"
-            ? "resume"
-            : mode === "continue"
-              ? "continue"
-              : "normal",
-        bypassApprovals: skipPermissions,
-        envOverrides: sharedEnv,
-        sessionId: resumeSessionId,
-      };
-      if (normalizedModel) {
-        launchOptions.model = normalizedModel;
-      }
-      if (inferenceLevel) {
-        launchOptions.reasoningEffort = inferenceLevel as CodexReasoningEffort;
-      }
-      launchResult = await launchCodexCLI(worktreePath, launchOptions);
-    } else if (tool === "gemini-cli") {
-      const launchOptions: {
-        mode?: "normal" | "continue" | "resume";
-        skipPermissions?: boolean;
-        envOverrides?: Record<string, string>;
-        model?: string;
-        sessionId?: string | null;
-      } = {
-        mode:
-          mode === "resume"
-            ? "resume"
-            : mode === "continue"
-              ? "continue"
-              : "normal",
-        skipPermissions,
-        envOverrides: sharedEnv,
-        sessionId: resumeSessionId,
-      };
-      if (normalizedModel) {
-        launchOptions.model = normalizedModel;
+    try {
+      if (tool === "claude-code") {
+        const launchOptions: {
+          mode?: "normal" | "continue" | "resume";
+          skipPermissions?: boolean;
+          envOverrides?: Record<string, string>;
+          model?: string;
+          sessionId?: string | null;
+          chrome?: boolean;
+        } = {
+          mode:
+            mode === "resume"
+              ? "resume"
+              : mode === "continue"
+                ? "continue"
+                : "normal",
+          skipPermissions,
+          envOverrides: sharedEnv,
+          sessionId: resumeSessionId,
+          chrome: true,
+        };
+        if (normalizedModel) {
+          launchOptions.model = normalizedModel;
+        }
+        launchResult = await launchClaudeCode(worktreePath, launchOptions);
+      } else if (tool === "codex-cli") {
+        const launchOptions: {
+          mode?: "normal" | "continue" | "resume";
+          bypassApprovals?: boolean;
+          envOverrides?: Record<string, string>;
+          model?: string;
+          reasoningEffort?: CodexReasoningEffort;
+          sessionId?: string | null;
+        } = {
+          mode:
+            mode === "resume"
+              ? "resume"
+              : mode === "continue"
+                ? "continue"
+                : "normal",
+          bypassApprovals: skipPermissions,
+          envOverrides: sharedEnv,
+          sessionId: resumeSessionId,
+        };
+        if (normalizedModel) {
+          launchOptions.model = normalizedModel;
+        }
+        if (inferenceLevel) {
+          launchOptions.reasoningEffort =
+            inferenceLevel as CodexReasoningEffort;
+        }
+        launchResult = await launchCodexCLI(worktreePath, launchOptions);
+      } else if (tool === "gemini-cli") {
+        const launchOptions: {
+          mode?: "normal" | "continue" | "resume";
+          skipPermissions?: boolean;
+          envOverrides?: Record<string, string>;
+          model?: string;
+          sessionId?: string | null;
+        } = {
+          mode:
+            mode === "resume"
+              ? "resume"
+              : mode === "continue"
+                ? "continue"
+                : "normal",
+          skipPermissions,
+          envOverrides: sharedEnv,
+          sessionId: resumeSessionId,
+        };
+        if (normalizedModel) {
+          launchOptions.model = normalizedModel;
+        }
+        launchResult = await launchGeminiCLI(worktreePath, launchOptions);
+      } else {
+        // Custom tool
+        printInfo(`Launching custom tool: ${toolConfig.displayName}`);
+        launchResult = await launchCustomAITool(toolConfig, {
+          mode:
+            mode === "resume"
+              ? "resume"
+              : mode === "continue"
+                ? "continue"
+                : "normal",
+          skipPermissions,
+          cwd: worktreePath,
+          sharedEnv,
+        });
       }
-      launchResult = await launchGeminiCLI(worktreePath, launchOptions);
-    } else {
-      // Custom tool
-      printInfo(`Launching custom tool: ${toolConfig.displayName}`);
-      launchResult = await launchCustomAITool(toolConfig, {
-        mode:
-          mode === "resume"
-            ? "resume"
-            : mode === "continue"
-              ? "continue"
-              : "normal",
-        skipPermissions,
-        cwd: worktreePath,
-        sharedEnv,
-      });
+    } finally {
+      // FR-043: Clear the periodic timestamp update timer
+      clearInterval(updateTimer);
     }
 
     // Persist session with captured session ID (if any)
@@ -777,8 +805,12 @@ export async function handleAIToolWorkflow(
       if (hasUncommitted) {
         const uncommittedCount = await getUncommittedChangesCount(worktreePath);
         const countLabel =
-          uncommittedCount > 0 ? ` (${uncommittedCount}件)` : "";
-        printWarning(`未コミットの変更があります${countLabel}。`);
+          uncommittedCount > 0
+            ? ` (${uncommittedCount} ${
+                uncommittedCount === 1 ? "change" : "changes"
+              })`
+            : "";
+        printWarning(`Uncommitted changes detected${countLabel}.`);
       }
 
       if (hasUnpushed) {
@@ -786,27 +818,19 @@ export async function handleAIToolWorkflow(
           worktreePath,
           branch,
         );
-        const countLabel = unpushedCount > 0 ? ` (${unpushedCount}件)` : "";
-        const shouldPush = await confirmYesNo(
-          `未プッシュのコミットがあります${countLabel}。プッシュしますか？`,
-          { defaultValue: false },
-        );
-        if (shouldPush) {
-          printInfo(`Pushing origin/${branch}...`);
-          try {
-            await pushBranchToRemote(worktreePath, branch);
-            printInfo(`Push completed for ${branch}.`);
-          } catch (error) {
-            const details =
-              error instanceof Error ? error.message : String(error);
-            printWarning(`Push failed for ${branch}: ${details}`);
-          }
-        }
+        const countLabel =
+          unpushedCount > 0
+            ? ` (${unpushedCount} ${
+                unpushedCount === 1 ? "commit" : "commits"
+              })`
+            : "";
+        printWarning(`Unpushed commits detected${countLabel}.`);
       }
     } catch (error) {
       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));
     printInfo("Session completed successfully. Returning to main menu...");

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);
+}