@akiojin/gwt 2.12.0 → 2.13.0

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

@@ -12,6 +12,7 @@ import { getPullRequestByBranch } from "../../../github.js";
 import type { BranchInfo, WorktreeInfo } from "../types.js";
 import type { WorktreeInfo as GitWorktreeInfo } from "../../../worktree.js";
 import { getLastToolUsageMap } from "../../../config/index.js";
+import { hasUncommittedChanges } from "../../../git.js";
 
 export interface UseGitDataOptions {
   enableAutoRefresh?: boolean;
@@ -65,6 +66,22 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
         }
         worktreesData = [];
       }
+
+      // enrich worktrees with uncommitted status (only for accessible paths)
+      worktreesData = await Promise.all(
+        worktreesData.map(async (wt) => {
+          if (wt.isAccessible === false) {
+            return wt;
+          }
+          try {
+            const hasUncommitted = await hasUncommittedChanges(wt.path);
+            return { ...wt, hasUncommittedChanges: hasUncommitted };
+          } catch {
+            return wt;
+          }
+        }),
+      );
+
       const lastToolUsageMap = await getLastToolUsageMap(repoRoot);
 
       // upstream情報とdivergence情報を取得
@@ -109,6 +126,9 @@ export function useGitData(options?: UseGitDataOptions): UseGitDataResult {
           locked: false, // worktree.ts doesn't expose locked status
           prunable: worktree.isAccessible === false,
           isAccessible: worktree.isAccessible ?? true, // Default to true if undefined
+          ...(worktree.hasUncommittedChanges !== undefined
+            ? { hasUncommittedChanges: worktree.hasUncommittedChanges }
+            : {}),
         };
         worktreeMap.set(worktree.branch, uiWorktreeInfo);
       }

package/src/cli/ui/types.ts

@@ -6,6 +6,7 @@ export interface WorktreeInfo {
   locked: boolean;
   prunable: boolean;
   isAccessible?: boolean;
+  hasUncommittedChanges?: boolean;
 }
 
 export type AITool = string;
@@ -229,6 +230,8 @@ export interface BranchItem extends BranchInfo {
   syncStatus?: SyncStatus;
   syncInfo?: string | undefined;
   remoteName?: string | undefined;
+  // クリーンアップ判定で「未コミット/未プッシュなし」と評価された場合に true
+  safeToCleanup?: boolean;
 }
 
 /**

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

@@ -65,7 +65,8 @@ const iconWidthOverrides: Record<string, number> = {
   "🚀": 1,
   "📌": 1,
   // Worktree status icons
-  "🟢": 1,
+  "🟢": 2,
+  "⚪": 2,
   "🟠": 1,
   // Change status icons
   "👉": 1,
@@ -73,7 +74,11 @@ const iconWidthOverrides: Record<string, number> = {
   "📤": 1,
   "🔃": 1,
   "✅": 1,
-  "⚠️": 1,
+  "⚠️": 2,
+  "⚠": 1,
+  "🛡": 2,
+  "☑": 2,
+  "☐": 2,
   // Remote markers
   "🔗": 1,
   "💻": 1,

package/src/cli/ui/utils/modelOptions.test.ts

@@ -23,6 +23,7 @@ describe("modelOptions", () => {
     expect(unique.size).toBe(ids.length);
     expect(ids).toEqual([
       "gpt-5.1-codex",
+      "gpt-5.2",
       "gpt-5.1-codex-max",
       "gpt-5.1-codex-mini",
       "gpt-5.1",
@@ -36,6 +37,19 @@ describe("modelOptions", () => {
     expect(getDefaultInferenceForModel(codexMax)).toBe("medium");
   });
 
+  it("exposes gpt-5.2 with xhigh reasoning and medium default", () => {
+    const codex52 = getModelOptions("codex-cli").find(
+      (m) => m.id === "gpt-5.2",
+    );
+    expect(codex52?.inferenceLevels).toEqual([
+      "xhigh",
+      "high",
+      "medium",
+      "low",
+    ]);
+    expect(getDefaultInferenceForModel(codex52)).toBe("medium");
+  });
+
   it("lists expected Gemini models", () => {
     expect(byId("gemini-cli")).toEqual([
       "gemini-3-pro-preview",

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

@@ -33,6 +33,13 @@ const MODEL_OPTIONS: Record<string, ModelOption[]> = {
       defaultInference: "high",
       isDefault: true,
     },
+    {
+      id: "gpt-5.2",
+      label: "gpt-5.2",
+      description: "Latest frontier model with extra high reasoning",
+      inferenceLevels: CODEX_MAX_LEVELS,
+      defaultInference: "medium",
+    },
     {
       id: "gpt-5.1-codex-max",
       label: "gpt-5.1-codex-max",

package/src/index.ts

@@ -33,6 +33,7 @@ import {
   getTerminalStreams,
   waitForUserAcknowledgement,
 } from "./utils/terminal.js";
+import { createLogger } from "./logging/logger.js";
 import { getToolById, getSharedEnvironment } from "./config/tools.js";
 import { launchCustomAITool } from "./launcher.js";
 import { saveSession, loadSession } from "./config/index.js";
@@ -43,18 +44,21 @@ import {
 } from "./utils/session.js";
 import { getPackageVersion } from "./utils.js";
 import { findLatestClaudeSessionId } from "./utils/session.js";
-import readline from "node:readline";
 import { resolveContinueSessionId } from "./cli/ui/utils/continueSession.js";
 import {
   installDependenciesForWorktree,
   DependencyInstallError,
   type DependencyInstallResult,
 } from "./services/dependency-installer.js";
+import { waitForEnter } from "./utils/prompt.js";
 
 const ERROR_PROMPT = chalk.yellow(
   "Review the error details, then press Enter to continue.",
 );
 
+// Category: cli
+const appLogger = createLogger({ category: "cli" });
+
 async function waitForErrorAcknowledgement(): Promise<void> {
   await waitForUserAcknowledgement(ERROR_PROMPT);
 }
@@ -64,14 +68,17 @@ async function waitForErrorAcknowledgement(): Promise<void> {
  */
 function printError(message: string): void {
   console.error(chalk.red(`❌ ${message}`));
+  appLogger.error({ message });
 }
 
 function printInfo(message: string): void {
   console.log(chalk.blue(`ℹ️  ${message}`));
+  appLogger.info({ message });
 }
 
 function printWarning(message: string): void {
   console.warn(chalk.yellow(`⚠️  ${message}`));
+  appLogger.warn({ message });
 }
 
 type GitStepResult<T> = { ok: true; value: T } | { ok: false };
@@ -192,50 +199,6 @@ async function runDependencyInstallStep<T extends DependencyInstallResult>(
   }
 }
 
-async function waitForEnter(promptMessage: string): Promise<void> {
-  if (!process.stdin.isTTY) {
-    // For non-interactive environments, resolve immediately.
-    return;
-  }
-
-  // Ensure stdin is resumed and not in raw mode before using readline.
-  // This is crucial for environments where stdin might be paused or in raw mode
-  // by other libraries (like Ink.js).
-  if (typeof process.stdin.resume === "function") {
-    process.stdin.resume();
-  }
-  if (process.stdin.isRaw) {
-    process.stdin.setRawMode(false);
-  }
-
-  await new Promise<void>((resolve) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    // Handle Ctrl+C to gracefully exit.
-    rl.on("SIGINT", () => {
-      rl.close();
-      // Restore stdin to a paused state before exiting.
-      if (typeof process.stdin.pause === "function") {
-        process.stdin.pause();
-      }
-      process.exit(0);
-    });
-
-    rl.question(`${promptMessage}\n`, () => {
-      rl.close();
-      // Pause stdin again to allow other parts of the application
-      // to take control if needed.
-      if (typeof process.stdin.pause === "function") {
-        process.stdin.pause();
-      }
-      resolve();
-    });
-  });
-}
-
 function showHelp(): void {
   console.log(`
 Worktree Manager

package/src/logging/logger.ts

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import pino, { type LoggerOptions, type Logger } from "pino";
+import { pruneOldLogs } from "./rotation.js";
+
+type Category = "cli" | "server" | "worker" | string;
+
+export interface LoggerConfig {
+  level?: string;
+  logDir?: string;
+  filename?: string;
+  category?: Category;
+  base?: Record<string, unknown>;
+  keepDays?: number;
+  /** For tests or sync writes use pino.destination sync */
+  sync?: boolean;
+}
+
+/** 
+ * Create a pino logger with unified structure and category field.
+ * - Writes to a single file stream (no per-component files)
+ * - Adds `category` to each log record
+ * - Prunes files older than keepDays at startup
+ */
+export function createLogger(config: LoggerConfig = {}): Logger {
+  const level = config.level ?? process.env.LOG_LEVEL ?? "info";
+  const cwdBase = path.basename(process.cwd()) || "workspace";
+  const defaultLogDir = path.join(os.homedir(), ".gwt", "logs", cwdBase);
+  const logDir = config.logDir ?? defaultLogDir;
+  const filename = config.filename ?? `${formatDate(new Date())}.jsonl`;
+  const category = config.category ?? "default";
+  const keepDays = config.keepDays ?? 7;
+
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  // Startup rotation
+  pruneOldLogs(logDir, keepDays);
+
+  const destination = path.join(logDir, filename);
+
+  const options: LoggerOptions = {
+    level,
+    base: {
+      category,
+      ...(config.base ?? {}),
+    },
+    timestamp: pino.stdTimeFunctions.isoTime,
+  };
+
+  if (config.sync) {
+    const destinationStream = pino.destination({ dest: destination, sync: true });
+    return pino(options, destinationStream);
+  }
+
+  const transport = pino.transport({
+    targets: [
+      {
+        target: "pino/file",
+        options: { destination, mkdir: true, append: true },
+        level,
+      },
+    ],
+  });
+
+  return pino(options, transport);
+}
+
+/** Convenience logger for quick use (category defaults to "default"). */
+export const logger = createLogger();
+
+export function formatDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}

package/src/logging/rotation.ts

@@ -0,0 +1,25 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Delete log files older than `keepDays` from the given directory.
+ * This is called at startup to enforce 7-day retention without size limits.
+ */
+export function pruneOldLogs(logDir: string, keepDays = 7): void {
+  if (!fs.existsSync(logDir)) return;
+
+  const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1000;
+
+  for (const entry of fs.readdirSync(logDir)) {
+    const full = path.join(logDir, entry);
+    try {
+      const stat = fs.statSync(full);
+      if (!stat.isFile()) continue;
+      if (stat.mtime.getTime() < cutoff) {
+        fs.unlinkSync(full);
+      }
+    } catch {
+      // Ignore individual file errors to avoid breaking startup
+    }
+  }
+}

package/src/utils/__tests__/prompt.test.ts

@@ -0,0 +1,89 @@
+import { PassThrough } from "node:stream";
+import { describe, expect, it, vi } from "vitest";
+
+// Shared mock target to avoid hoisting issues
+const terminalStreams: Record<string, unknown> = {};
+
+vi.mock("../terminal.js", () => ({
+  getTerminalStreams: () => terminalStreams,
+}));
+
+const withTimeout = <T>(promise: Promise<T>, ms = 500): Promise<T> =>
+  Promise.race([
+    promise,
+    new Promise<T>((_, reject) =>
+      setTimeout(() => reject(new Error("timeout")), ms),
+    ),
+  ]);
+
+describe("waitForEnter", () => {
+  it("uses terminal stdin/stdout and resolves after newline on TTY", async () => {
+    vi.resetModules();
+    for (const key of Object.keys(terminalStreams)) {
+      delete terminalStreams[key];
+    }
+
+    const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
+    const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
+    Object.defineProperty(stdin, "isTTY", { value: true });
+
+    let resumed = false;
+    let paused = false;
+    const originalResume = stdin.resume.bind(stdin);
+    const originalPause = stdin.pause.bind(stdin);
+    // Track resume/pause calls
+    stdin.resume = (() => {
+      resumed = true;
+      return originalResume();
+    }) as typeof stdin.resume;
+    stdin.pause = (() => {
+      paused = true;
+      return originalPause();
+    }) as typeof stdin.pause;
+
+    const exitRawMode = vi.fn();
+
+    Object.assign(terminalStreams, {
+      stdin,
+      stdout,
+      stderr: stdout,
+      usingFallback: false,
+      exitRawMode,
+    });
+
+    const { waitForEnter } = await import("../prompt.js");
+
+    const waiting = withTimeout(waitForEnter("prompt"), 200);
+    stdin.write("hello\n");
+
+    await expect(waiting).resolves.toBeUndefined();
+    expect(resumed).toBe(true);
+    expect(paused).toBe(true);
+    expect(exitRawMode).toHaveBeenCalled();
+  });
+
+  it("returns immediately on non-TTY stdin", async () => {
+    vi.resetModules();
+    for (const key of Object.keys(terminalStreams)) {
+      delete terminalStreams[key];
+    }
+
+    const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
+    const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
+    Object.defineProperty(stdin, "isTTY", { value: false });
+
+    Object.assign(terminalStreams, {
+      stdin,
+      stdout,
+      stderr: stdout,
+      usingFallback: false,
+      exitRawMode: vi.fn(),
+    });
+
+    const { waitForEnter } = await import("../prompt.js");
+
+    const start = Date.now();
+    await waitForEnter("prompt");
+    expect(Date.now() - start).toBeLessThan(50);
+  });
+});

package/src/utils/prompt.ts

@@ -0,0 +1,74 @@
+import readline from "node:readline";
+import { getTerminalStreams } from "./terminal.js";
+
+/**
+ * Wait for Enter using the same terminal streams as Ink.
+ * Falls back to no-op on non-interactive stdin to avoid blocking pipelines.
+ */
+export async function waitForEnter(promptMessage: string): Promise<void> {
+  const terminal = getTerminalStreams();
+  const stdin = terminal.stdin as NodeJS.ReadStream | undefined;
+  const stdout = terminal.stdout as NodeJS.WriteStream | undefined;
+
+  if (!stdin || typeof stdin.on !== "function" || !stdin.isTTY) {
+    return;
+  }
+
+  terminal.exitRawMode?.();
+
+  if (typeof stdin.resume === "function") {
+    stdin.resume();
+  }
+
+  if ((stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw) {
+    try {
+      (stdin as NodeJS.ReadStream & { setRawMode?: (flag: boolean) => void }).setRawMode?.(false);
+    } catch {
+      // Ignore raw mode errors
+    }
+  }
+
+  await new Promise<void>((resolve) => {
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+
+    const cleanup = () => {
+      rl.removeAllListeners();
+      rl.close();
+      const remover = (method: "off" | "removeListener") =>
+        (stdin as unknown as Record<string, (event: string, fn: () => void) => void>)[method]?.(
+          "end",
+          onEnd,
+        );
+      remover("off");
+      remover("removeListener");
+      const removerErr = (method: "off" | "removeListener") =>
+        (stdin as unknown as Record<string, (event: string, fn: () => void) => void>)[method]?.(
+          "error",
+          onEnd,
+        );
+      removerErr("off");
+      removerErr("removeListener");
+      if (typeof stdin.pause === "function") {
+        stdin.pause();
+      }
+    };
+
+    const onEnd = () => {
+      cleanup();
+      resolve();
+    };
+
+    rl.on("SIGINT", () => {
+      cleanup();
+      process.exit(0);
+    });
+
+    rl.question(`${promptMessage}\n`, () => {
+      cleanup();
+      resolve();
+    });
+
+    stdin.once("end", onEnd);
+    stdin.once("error", onEnd);
+  });
+}

package/src/web/server/index.ts

@@ -14,6 +14,8 @@ import { PTYManager } from "./pty/manager.js";
 import { WebSocketHandler } from "./websocket/handler.js";
 import { registerRoutes } from "./routes/index.js";
 import { importOsEnvIntoSharedConfig } from "./env/importer.js";
+import { createLogger } from "../../logging/logger.js";
+import type { WebFastifyInstance } from "./types.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -22,10 +24,10 @@ const __dirname = dirname(__filename);
  * Webサーバーを起動
  */
 export async function startWebServer(): Promise<void> {
-  const fastify = Fastify({
-    logger: {
-      level: process.env.LOG_LEVEL || "info",
-    },
+  const serverLogger = createLogger({ category: "server" });
+
+  const fastify: WebFastifyInstance = Fastify({
+    loggerInstance: serverLogger,
   });
 
   // PTYマネージャーとWebSocketハンドラーを初期化

package/src/web/server/routes/branches.ts

@@ -4,7 +4,6 @@
  * ブランチ関連のREST APIエンドポイント。
  */
 
-import type { FastifyInstance } from "fastify";
 import {
   listBranches,
   getBranchByName,
@@ -16,12 +15,13 @@ import type {
   BranchSyncRequest,
   BranchSyncResult,
 } from "../../../types/api.js";
+import type { WebFastifyInstance } from "../types.js";
 
 /**
  * ブランチ関連のルートを登録
  */
 export async function registerBranchRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
 ): Promise<void> {
   // GET /api/branches - すべてのブランチ一覧を取得
   fastify.get<{ Reply: ApiResponse<Branch[]> }>(

package/src/web/server/routes/config.ts

@@ -2,7 +2,6 @@
  * Config Routes
  */
 
-import type { FastifyInstance } from "fastify";
 import { loadToolsConfig, saveToolsConfig } from "../../../config/tools.js";
 import {
   loadEnvHistory,
@@ -17,6 +16,7 @@ import type {
 } from "../../../types/api.js";
 import type { CustomAITool as FileCustomAITool } from "../../../types/tools.js";
 import { getImportedEnvKeys } from "../env/importer.js";
+import type { WebFastifyInstance } from "../types.js";
 
 function normalizeEnv(
   env: Record<string, string> | undefined,
@@ -135,7 +135,7 @@ function diffEnvHistory(
 }
 
 export async function registerConfigRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
 ): Promise<void> {
   fastify.get<{ Reply: ApiResponse<ConfigPayload> }>(
     "/api/config",

package/src/web/server/routes/index.ts

@@ -5,19 +5,19 @@
  * 仕様: specs/SPEC-d5e56259/contracts/rest-api.yaml
  */
 
-import type { FastifyInstance } from "fastify";
 import type { PTYManager } from "../pty/manager.js";
 import { registerBranchRoutes } from "./branches.js";
 import { registerWorktreeRoutes } from "./worktrees.js";
 import { registerSessionRoutes } from "./sessions.js";
 import { registerConfigRoutes } from "./config.js";
 import type { HealthResponse } from "../../../types/api.js";
+import type { WebFastifyInstance } from "../types.js";
 
 /**
  * すべてのルートを登録
  */
 export async function registerRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
   ptyManager: PTYManager,
 ): Promise<void> {
   // ヘルスチェック

package/src/web/server/routes/sessions.ts

@@ -4,7 +4,6 @@
  * AI Toolセッション関連のREST APIエンドポイント。
  */
 
-import type { FastifyInstance } from "fastify";
 import type { PTYManager } from "../pty/manager.js";
 import type {
   ApiResponse,
@@ -13,12 +12,13 @@ import type {
 } from "../../../types/api.js";
 import { saveSession } from "../../../config/index.js";
 import { execa } from "execa";
+import type { WebFastifyInstance } from "../types.js";
 
 /**
  * セッション関連のルートを登録
  */
 export async function registerSessionRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
   ptyManager: PTYManager,
 ): Promise<void> {
   // GET /api/sessions - すべてのセッション一覧を取得

package/src/web/server/routes/worktrees.ts

@@ -4,7 +4,6 @@
  * Worktree関連のREST APIエンドポイント。
  */
 
-import type { FastifyInstance } from "fastify";
 import {
   listWorktrees,
   getWorktreeByPath,
@@ -16,12 +15,13 @@ import type {
   Worktree,
   CreateWorktreeRequest,
 } from "../../../types/api.js";
+import type { WebFastifyInstance } from "../types.js";
 
 /**
  * Worktree関連のルートを登録
  */
 export async function registerWorktreeRoutes(
-  fastify: FastifyInstance,
+  fastify: WebFastifyInstance,
 ): Promise<void> {
   // GET /api/worktrees - すべてのWorktree一覧を取得
   fastify.get<{ Reply: ApiResponse<Worktree[]> }>(

package/src/web/server/types.ts

@@ -0,0 +1,14 @@
+import type {
+  FastifyInstance,
+  RawReplyDefaultExpression,
+  RawRequestDefaultExpression,
+  RawServerDefault,
+} from "fastify";
+import type { Logger } from "pino";
+
+export type WebFastifyInstance = FastifyInstance<
+  RawServerDefault,
+  RawRequestDefaultExpression<RawServerDefault>,
+  RawReplyDefaultExpression<RawServerDefault>,
+  Logger
+>;

package/src/worktree.ts

@@ -110,6 +110,7 @@ export interface WorktreeInfo {
   head: string;
   isAccessible?: boolean;
   invalidReason?: string;
+  hasUncommittedChanges?: boolean;
 }
 
 async function listWorktrees(): Promise<WorktreeInfo[]> {