@akiojin/gwt 4.2.0 → 4.3.1

package/src/claude.ts

@@ -1,6 +1,6 @@
 import { execa, type Options as ExecaOptions } from "execa";
 import chalk from "chalk";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import {
   createChildStdio,
   getTerminalStreams,
@@ -37,6 +37,7 @@ export class ClaudeError extends Error {
  *
  * @param worktreePath - Worktree directory to run Claude Code in
  * @param options - Launch options (mode/session/model/permissions/env)
+ * @param options.chrome - Enable Chrome extension integration (adds --chrome flag)
  * @returns Captured session id when available
  */
 export async function launchClaudeCode(
@@ -48,6 +49,7 @@ export async function launchClaudeCode(
     envOverrides?: Record<string, string>;
     model?: string;
     sessionId?: string | null;
+    chrome?: boolean;
   } = {},
 ): Promise<{ sessionId?: string | null }> {
   const terminal = getTerminalStreams();
@@ -169,6 +171,18 @@ export async function launchClaudeCode(
         break;
     }
 
+    // Handle Chrome extension integration
+    if (options.chrome && isChromeIntegrationSupported()) {
+      args.push("--chrome");
+      console.log(chalk.green("   🌐 Chrome integration enabled"));
+    } else if (options.chrome) {
+      console.log(
+        chalk.yellow(
+          "   ⚠️  Chrome integration is not supported on this platform. Skipping --chrome.",
+        ),
+      );
+    }
+
     // Detect root user for Docker/sandbox environments
     let isRoot = false;
     try {
@@ -201,7 +215,11 @@ export async function launchClaudeCode(
     terminal.exitRawMode();
     resetTerminalModes(terminal.stdout);
 
-    const baseEnv = { ...process.env, ...(options.envOverrides ?? {}) };
+    const baseEnv: Record<string, string | undefined> = {
+      ...process.env,
+      ...(options.envOverrides ?? {}),
+      ENABLE_LSP_TOOL: "true", // Enable TypeScript LSP support in Claude Code
+    };
     const launchEnvSource =
       options.skipPermissions && !baseEnv.IS_SANDBOX
         ? { ...baseEnv, IS_SANDBOX: "1" }
@@ -427,3 +445,40 @@ export async function isClaudeCodeAvailable(): Promise<boolean> {
     return false;
   }
 }
+
+/**
+ * Checks whether Chrome integration is supported on the current platform.
+ *
+ * Supported platforms:
+ * - Windows (win32)
+ * - macOS (darwin)
+ * - Linux (non-WSL)
+ */
+function isChromeIntegrationSupported(): boolean {
+  switch (process.platform) {
+    case "win32":
+    case "darwin":
+      return true;
+    case "linux":
+      return !isWslEnvironment();
+    default:
+      return false;
+  }
+}
+
+function isWslEnvironment(): boolean {
+  if (process.platform !== "linux") {
+    return false;
+  }
+
+  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) {
+    return true;
+  }
+
+  try {
+    const procVersion = readFileSync("/proc/version", "utf8");
+    return /microsoft|wsl/i.test(procVersion);
+  } catch {
+    return false;
+  }
+}

package/src/cli/ui/__tests__/components/App.shortcuts.test.tsx

@@ -107,6 +107,18 @@ describe("App shortcuts integration", () => {
         },
       ],
       worktrees: [
+        {
+          branch: "feature/add-new-feature",
+          path: "/worktrees/feature-add-new-feature",
+          isAccessible: true,
+          hasUncommittedChanges: false,
+        },
+        {
+          branch: "hotfix/urgent-fix",
+          path: "/worktrees/hotfix-urgent-fix",
+          isAccessible: true,
+          hasUncommittedChanges: true,
+        },
         {
           branch: "feature/existing",
           path: "/worktrees/feature-existing",
@@ -208,6 +220,98 @@ describe("App shortcuts integration", () => {
     expect(navigateToMock).toHaveBeenCalledWith("ai-tool-selector");
   });
 
+  it("shows warning when cleanup runs without selection", async () => {
+    const onExit = vi.fn();
+
+    render(<App onExit={onExit} />);
+
+    const initialProps = branchListProps.at(-1);
+    expect(initialProps).toBeDefined();
+
+    act(() => {
+      initialProps?.onCleanupCommand?.();
+    });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    const latestProps = branchListProps.at(-1);
+    expect(latestProps?.cleanupUI?.footerMessage?.text).toBe(
+      "クリーンアップ対象が選択されていません",
+    );
+    expect(removeWorktreeMock).not.toHaveBeenCalled();
+    expect(deleteBranchMock).not.toHaveBeenCalled();
+  });
+
+  it("marks branches safe only when merged and clean", () => {
+    const onExit = vi.fn();
+    const refresh = vi.fn();
+    useGitDataMock.mockReturnValue({
+      branches: [
+        {
+          name: "feature/merged-clean",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+          mergedPR: { number: 101, mergedAt: "2025-01-02T10:00:00Z" },
+        },
+        {
+          name: "feature/merged-unpushed",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+          hasUnpushedCommits: true,
+          mergedPR: { number: 102, mergedAt: "2025-01-03T10:00:00Z" },
+        },
+        {
+          name: "feature/unmerged",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+        },
+      ],
+      worktrees: [
+        {
+          branch: "feature/merged-clean",
+          path: "/worktrees/merged-clean",
+          isAccessible: true,
+          hasUncommittedChanges: false,
+        },
+        {
+          branch: "feature/merged-unpushed",
+          path: "/worktrees/merged-unpushed",
+          isAccessible: true,
+          hasUncommittedChanges: false,
+        },
+        {
+          branch: "feature/unmerged",
+          path: "/worktrees/unmerged",
+          isAccessible: true,
+          hasUncommittedChanges: false,
+        },
+      ],
+      loading: false,
+      error: null,
+      refresh,
+      lastUpdated: null,
+    });
+
+    render(<App onExit={onExit} />);
+
+    const latestProps = branchListProps.at(-1);
+    const safeMap = new Map(
+      latestProps?.branches?.map((branch: BranchItem) => [
+        branch.name,
+        branch.safeToCleanup,
+      ]),
+    );
+
+    expect(safeMap.get("feature/merged-clean")).toBe(true);
+    expect(safeMap.get("feature/merged-unpushed")).toBe(false);
+    expect(safeMap.get("feature/unmerged")).toBe(false);
+  });
+
   it("displays per-branch cleanup indicators and waits before clearing results", async () => {
     vi.useFakeTimers();
     const originalNodeEnv = process.env.NODE_ENV;

package/src/cli/ui/components/App.tsx

@@ -32,6 +32,7 @@ import type {
   AITool,
   BranchInfo,
   BranchItem,
+  CleanupTarget,
   InferenceLevel,
   SelectedBranchState,
 } from "../types.js";
@@ -40,7 +41,6 @@ import { loadSession } from "../../../config/index.js";
 import {
   createWorktree,
   generateWorktreePath,
-  getMergedPRWorktrees,
   isProtectedBranchName,
   removeWorktree,
   switchToProtectedBranch,
@@ -166,7 +166,6 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
   } | null>(null);
   const [hiddenBranches, setHiddenBranches] = useState<string[]>([]);
   const [selectedBranches, setSelectedBranches] = useState<string[]>([]);
-  const [safeBranches, setSafeBranches] = useState<Set<string>>(new Set());
   const spinnerFrameIndexRef = useRef(0);
   const [spinnerFrameIndex, setSpinnerFrameIndex] = useState(0);
   const completionTimerRef = useRef<NodeJS.Timeout | null>(null);
@@ -258,29 +257,6 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
     );
   }, [branches, hiddenBranches]);
 
-  // Precompute safe-to-clean branches using cleanup candidate logic
-  useEffect(() => {
-    let cancelled = false;
-    (async () => {
-      try {
-        const targets = await getMergedPRWorktrees();
-        if (cancelled) return;
-        const safe = new Set(
-          targets
-            .filter((t) => !t.hasUncommittedChanges && !t.hasUnpushedCommits)
-            .map((t) => t.branch),
-        );
-        setSafeBranches(safe);
-      } catch {
-        if (cancelled) return;
-        setSafeBranches(new Set());
-      }
-    })();
-    return () => {
-      cancelled = true;
-    };
-  }, [branches, worktrees]);
-
   // Load quick start options for selected branch (latest per tool)
   useEffect(() => {
     if (!selectedBranch) {
@@ -520,16 +496,15 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
       });
     }
     const baseItems = formatBranchItems(visibleBranches, worktreeMap);
-    return baseItems.map((item) => ({
-      ...item,
-      safeToCleanup: safeBranches.has(item.name),
-    }));
-  }, [branchHash, worktreeHash, visibleBranches, worktrees, safeBranches]);
-
-  const selectedBranchSet = useMemo(
-    () => new Set(selectedBranches),
-    [selectedBranches],
-  );
+    return baseItems.map((item) => {
+      const hasUncommitted = item.worktree?.hasUncommittedChanges ?? false;
+      const hasUnpushed = Boolean(item.hasUnpushedCommits);
+      const isMerged = Boolean(item.mergedPR);
+      const safeToCleanup =
+        item.type === "local" && isMerged && !hasUncommitted && !hasUnpushed;
+      return { ...item, safeToCleanup };
+    });
+  }, [branchHash, worktreeHash, visibleBranches, worktrees]);
 
   // Calculate statistics (memoized for performance)
   const stats = useMemo(
@@ -622,17 +597,31 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
     [isProtectedBranchName],
   );
 
-  const toggleBranchSelection = useCallback((branchName: string) => {
-    setSelectedBranches((prev) => {
-      const set = new Set(prev);
-      if (set.has(branchName)) {
-        set.delete(branchName);
-      } else {
-        set.add(branchName);
+  const toggleBranchSelection = useCallback(
+    (branchName: string) => {
+      const branch = branches.find((b) => b.name === branchName);
+      if (!branch || branch.type === "remote") {
+        return;
       }
-      return Array.from(set);
-    });
-  }, []);
+      if (
+        isProtectedBranchName(branch.name) ||
+        branch.branchType === "main" ||
+        branch.branchType === "develop"
+      ) {
+        return;
+      }
+      setSelectedBranches((prev) => {
+        const set = new Set(prev);
+        if (set.has(branchName)) {
+          set.delete(branchName);
+        } else {
+          set.add(branchName);
+        }
+        return Array.from(set);
+      });
+    },
+    [branches, isProtectedBranchName],
+  );
 
   const protectedBranchInfo = useMemo(() => {
     if (!selectedBranch) {
@@ -846,6 +835,20 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
       completionTimerRef.current = null;
     }
 
+    if (selectedBranches.length === 0) {
+      setCleanupIndicators({});
+      setCleanupFooterMessage({
+        text: "クリーンアップ対象が選択されていません",
+        color: "yellow",
+      });
+      setCleanupInputLocked(false);
+      completionTimerRef.current = setTimeout(() => {
+        setCleanupFooterMessage(null);
+        completionTimerRef.current = null;
+      }, COMPLETION_HOLD_DURATION_MS);
+      return;
+    }
+
     const succeededBranches: string[] = [];
 
     const resetAfterWait = () => {
@@ -878,26 +881,50 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
     spinnerFrameIndexRef.current = 0;
     setSpinnerFrameIndex(0);
 
-    let targets;
-    try {
-      targets = await getMergedPRWorktrees();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      setCleanupIndicators({});
-      setCleanupFooterMessage({ text: `❌ ${message}`, color: "red" });
-      setCleanupInputLocked(false);
-      completionTimerRef.current = setTimeout(() => {
-        setCleanupFooterMessage(null);
-        completionTimerRef.current = null;
-      }, COMPLETION_HOLD_DURATION_MS);
-      return;
-    }
+    const branchMap = new Map(branches.map((branch) => [branch.name, branch]));
+    const worktreeMap = new Map(
+      worktrees.map((worktree) => [worktree.branch, worktree]),
+    );
+    const targets = selectedBranches.reduce<CleanupTarget[]>((acc, name) => {
+      const branch = branchMap.get(name);
+      if (!branch || branch.type === "remote") {
+        return acc;
+      }
+      if (
+        isProtectedBranchName(branch.name) ||
+        branch.branchType === "main" ||
+        branch.branchType === "develop"
+      ) {
+        return acc;
+      }
+
+      const worktree = worktreeMap.get(branch.name);
+      const hasRemoteBranch =
+        typeof branch.hasRemoteCounterpart === "boolean"
+          ? branch.hasRemoteCounterpart
+          : undefined;
+      const isAccessible =
+        typeof worktree?.isAccessible === "boolean"
+          ? worktree.isAccessible
+          : undefined;
+      acc.push({
+        branch: branch.name,
+        pullRequest: null,
+        worktreePath: worktree?.path ?? null,
+        cleanupType: worktree ? "worktree-and-branch" : "branch-only",
+        hasUncommittedChanges: worktree?.hasUncommittedChanges ?? false,
+        hasUnpushedCommits: Boolean(branch.hasUnpushedCommits),
+        ...(hasRemoteBranch !== undefined ? { hasRemoteBranch } : {}),
+        ...(isAccessible !== undefined ? { isAccessible } : {}),
+      });
+      return acc;
+    }, []);
 
     if (targets.length === 0) {
       setCleanupIndicators({});
       setCleanupFooterMessage({
-        text: "✅ Nothing to clean up.",
-        color: "green",
+        text: "⚠️ No cleanup candidates among selected branches.",
+        color: "yellow",
       });
       setCleanupInputLocked(false);
       completionTimerRef.current = setTimeout(() => {
@@ -907,24 +934,6 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
       return;
     }
 
-    // Manual selection: restrict targets when選択がある
-    if (selectedBranchSet.size > 0) {
-      targets = targets.filter((t) => selectedBranchSet.has(t.branch));
-      if (targets.length === 0) {
-        setCleanupIndicators({});
-        setCleanupFooterMessage({
-          text: "⚠️ No cleanup candidates among selected branches.",
-          color: "yellow",
-        });
-        setCleanupInputLocked(false);
-        completionTimerRef.current = setTimeout(() => {
-          setCleanupFooterMessage(null);
-          completionTimerRef.current = null;
-        }, COMPLETION_HOLD_DURATION_MS);
-        return;
-      }
-    }
-
     // Reset hidden branches that may already be gone
     setHiddenBranches((prev) =>
       prev.filter(
@@ -1037,11 +1046,12 @@ export function App({ onExit, loadingIndicatorDelay = 300 }: AppProps) {
     completionTimerRef.current = setTimeout(resetAfterWait, holdDuration);
   }, [
     cleanupInputLocked,
+    branches,
     deleteBranch,
-    getMergedPRWorktrees,
     refresh,
     removeWorktree,
-    selectedBranchSet,
+    selectedBranches,
+    worktrees,
   ]);
 
   // Handle AI tool selection

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

@@ -407,7 +407,12 @@ export function BranchListScreen({
       const indicatorPrefix = indicatorIcon ? `${indicatorIcon} ` : "";
 
       const isChecked = selectedSet.has(item.name);
-      const selectionIcon = isChecked ? "[*]" : "[ ]";
+      const isWarning = Boolean(item.hasUnpushedCommits) || !item.mergedPR;
+      const selectionIcon = isChecked
+        ? isWarning
+          ? chalk.red("[*]")
+          : "[*]"
+        : "[ ]";
       let worktreeIcon = chalk.gray("⚪");
       if (item.worktreeStatus === "active") {
         worktreeIcon = chalk.green("🟢");

package/src/cli/ui/types.ts

@@ -231,7 +231,7 @@ export interface BranchItem extends BranchInfo {
   syncStatus?: SyncStatus;
   syncInfo?: string | undefined;
   remoteName?: string | undefined;
-  // クリーンアップ判定で「未コミット/未プッシュなし」と評価された場合に true
+  // クリーンアップ判定で「未コミット/未プッシュなし かつマージ済み」と評価された場合に true
   safeToCleanup?: boolean;
 }
 

package/src/config/builtin-tools.ts

@@ -24,6 +24,9 @@ export const CLAUDE_CODE_TOOL: CustomAITool = {
     resume: ["-r"],
   },
   permissionSkipArgs: Array.from(CLAUDE_PERMISSION_SKIP_ARGS),
+  env: {
+    ENABLE_LSP_TOOL: "true",
+  },
 };
 
 /**

package/src/config/tools.ts

@@ -21,8 +21,11 @@ import type {
   AIToolConfig,
 } from "../types/tools.js";
 import { BUILTIN_TOOLS } from "./builtin-tools.js";
+import { createLogger } from "../logging/logger.js";
 import { resolveProfileEnv } from "./profiles.js";
 
+const logger = createLogger({ category: "config" });
+
 /**
  * ツール設定ファイルのパス
  * 環境変数の優先順位: GWT_HOME > CLAUDE_WORKTREE_HOME (後方互換性) > ホームディレクトリ
@@ -64,6 +67,10 @@ async function migrateLegacyConfig(): Promise<void> {
     // レガシーディレクトリを新しいディレクトリにコピー
     await mkdir(path.dirname(CONFIG_DIR), { recursive: true });
     await cp(LEGACY_CONFIG_DIR, CONFIG_DIR, { recursive: true });
+    logger.info(
+      { from: LEGACY_CONFIG_DIR, to: CONFIG_DIR },
+      "Legacy config migrated",
+    );
     console.log(
       `✅ Migrated configuration from ${LEGACY_CONFIG_DIR} to ${CONFIG_DIR}`,
     );
@@ -101,6 +108,11 @@ export async function loadToolsConfig(): Promise<ToolsConfig> {
     // 検証
     validateToolsConfig(config);
 
+    logger.debug(
+      { path: TOOLS_CONFIG_PATH, toolCount: config.customTools.length },
+      "Tools config loaded",
+    );
+
     return {
       ...config,
       env: config.env ?? {},
@@ -108,11 +120,19 @@ export async function loadToolsConfig(): Promise<ToolsConfig> {
   } catch (error) {
     // ファイルが存在しない場合は空配列を返す
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      logger.debug(
+        { path: TOOLS_CONFIG_PATH },
+        "Tools config not found, using defaults",
+      );
       return { ...DEFAULT_CONFIG };
     }
 
     // JSON構文エラーの場合
     if (error instanceof SyntaxError) {
+      logger.error(
+        { path: TOOLS_CONFIG_PATH, error: error.message },
+        "Tools config parse error",
+      );
       throw new Error(
         `Failed to parse tools.json: ${error.message}\n` +
           `Please check the JSON syntax in ${TOOLS_CONFIG_PATH}`,
@@ -283,12 +303,15 @@ export async function getToolById(
   // ビルトインツールから検索
   const builtinTool = BUILTIN_TOOLS.find((t) => t.id === id);
   if (builtinTool) {
+    logger.debug({ id, found: true, isBuiltin: true }, "Tool lookup");
     return builtinTool;
   }
 
   // カスタムツールから検索
   const config = await loadToolsConfig();
-  return config.customTools.find((t) => t.id === id);
+  const customTool = config.customTools.find((t) => t.id === id);
+  logger.debug({ id, found: !!customTool, isBuiltin: false }, "Tool lookup");
+  return customTool;
 }
 
 /**

package/src/index.ts

@@ -209,7 +209,7 @@ Worktree Manager
 Usage: gwt [command] [options]
 
 Commands:
-  serve           Start Web UI server (http://localhost:3000)
+  serve           Start Web UI server (http://localhost:3001)
 
 Options:
   -h, --help      Show this help message
@@ -608,6 +608,7 @@ export async function handleAIToolWorkflow(
         envOverrides?: Record<string, string>;
         model?: string;
         sessionId?: string | null;
+        chrome?: boolean;
       } = {
         mode:
           mode === "resume"
@@ -618,6 +619,7 @@ export async function handleAIToolWorkflow(
         skipPermissions,
         envOverrides: sharedEnv,
         sessionId: resumeSessionId,
+        chrome: true,
       };
       if (normalizedModel) {
         launchOptions.model = normalizedModel;

package/src/launcher.ts

@@ -7,6 +7,9 @@
 
 import { execa } from "execa";
 import type { CustomAITool, LaunchOptions } from "./types/tools.js";
+import { createLogger } from "./logging/logger.js";
+
+const logger = createLogger({ category: "launcher" });
 
 /**
  * コマンド名をPATH環境変数から解決
@@ -28,16 +31,22 @@ export async function resolveCommand(commandName: string): Promise<string> {
     const resolvedPath = (result.stdout.split("\n")[0] ?? "").trim();
 
     if (!resolvedPath) {
+      logger.error({ commandName }, "Command not found in PATH");
       throw new Error(
         `Command "${commandName}" not found in PATH.\n` +
           `Please ensure the command is installed and available in your PATH environment variable.`,
       );
     }
 
+    logger.debug({ commandName, resolvedPath }, "Command resolved");
     return resolvedPath;
   } catch (error) {
     // which/whereコマンド自体が失敗した場合
     if (error instanceof Error) {
+      logger.error(
+        { commandName, error: error.message },
+        "Command resolution failed",
+      );
       throw new Error(
         `Failed to resolve command "${commandName}".\n` +
           `Error: ${error.message}\n` +
@@ -78,6 +87,10 @@ function buildArgs(tool: CustomAITool, options: LaunchOptions): string[] {
     args.push(...options.extraArgs);
   }
 
+  logger.debug(
+    { toolId: tool.id, mode: options.mode ?? "normal", argsCount: args.length },
+    "Args built",
+  );
   return args;
 }
 
@@ -110,10 +123,21 @@ export async function launchCustomAITool(
     env,
   };
 
+  logger.info(
+    {
+      toolId: tool.id,
+      toolType: tool.type,
+      command: tool.command,
+      mode: options.mode ?? "normal",
+    },
+    "Launching custom AI tool",
+  );
+
   switch (tool.type) {
     case "path": {
       // 絶対パスで直接実行
       await execa(tool.command, args, execaOptions);
+      logger.info({ toolId: tool.id }, "Custom AI tool completed (path)");
       break;
     }
 
@@ -121,6 +145,7 @@ export async function launchCustomAITool(
       // bunx経由でパッケージ実行
       // bunx [package] [args...]
       await execa("bunx", [tool.command, ...args], execaOptions);
+      logger.info({ toolId: tool.id }, "Custom AI tool completed (bunx)");
       break;
     }
 
@@ -128,6 +153,7 @@ export async function launchCustomAITool(
       // PATH解決 → 実行
       const resolvedPath = await resolveCommand(tool.command);
       await execa(resolvedPath, args, execaOptions);
+      logger.info({ toolId: tool.id }, "Custom AI tool completed (command)");
       break;
     }