@akiojin/gwt 2.0.0

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

@@ -0,0 +1,222 @@
+import type {
+  BranchInfo,
+  BranchItem,
+  BranchType,
+  WorktreeStatus,
+  WorktreeInfo,
+} from "../types.js";
+import stringWidth from "string-width";
+
+// Icon mappings
+const branchIcons: Record<BranchType, string> = {
+  main: "⚡",
+  develop: "⚡",
+  feature: "✨",
+  hotfix: "🔥",
+  release: "🚀",
+  other: "📌",
+};
+
+const worktreeIcons: Record<Exclude<WorktreeStatus, undefined>, string> = {
+  active: "🟢",
+  inaccessible: "🟠",
+};
+
+const changeIcons = {
+  current: "⭐",
+  hasChanges: "✏️",
+  unpushed: "⬆️",
+  openPR: "🔀",
+  mergedPR: "✅",
+  warning: "⚠️",
+};
+
+const remoteIcon = "☁";
+
+// Some icons are treated as double-width by string-width even though they render
+// as a single column in many terminals (e.g. ☁). Provide explicit overrides to
+// keep the column layout consistent across environments.
+const iconWidthOverrides: Record<string, number> = {
+  [remoteIcon]: 1,
+  "☁️": 1,
+  "☁︎": 1,
+  "⬆️": 1,
+  "⬆︎": 1,
+  "⬆": 1,
+};
+
+export interface FormatOptions {
+  hasChanges?: boolean;
+}
+
+/**
+ * Converts BranchInfo to BranchItem with display properties
+ */
+export function formatBranchItem(
+  branch: BranchInfo,
+  options: FormatOptions = {},
+): BranchItem {
+  const hasChanges = options.hasChanges ?? false;
+  const COLUMN_WIDTH = 2; // Fixed width for each icon column
+
+  // Helper to pad icon to fixed width
+  const padIcon = (icon: string): string => {
+    const width = iconWidthOverrides[icon] ?? stringWidth(icon);
+    const padding = Math.max(0, COLUMN_WIDTH - width);
+    return icon + " ".repeat(padding);
+  };
+
+  // Column 1: Branch type icon (always present)
+  const branchTypeIcon = padIcon(branchIcons[branch.branchType]);
+
+  // Column 2: Worktree status icon
+  let worktreeStatus: WorktreeStatus;
+  let worktreeIcon: string;
+  if (branch.worktree) {
+    if (branch.worktree.isAccessible === false) {
+      worktreeStatus = "inaccessible";
+      worktreeIcon = padIcon(worktreeIcons.inaccessible);
+    } else {
+      worktreeStatus = "active";
+      worktreeIcon = padIcon(worktreeIcons.active);
+    }
+  } else {
+    worktreeIcon = " ".repeat(COLUMN_WIDTH);
+  }
+
+  // Column 3: Change status icon (priority: ✏️ > ⬆️ > 🔀 > ✅ > ⚠️ > ⭐)
+  let changesIcon: string;
+  if (hasChanges) {
+    changesIcon = padIcon(changeIcons.hasChanges);
+  } else if (branch.hasUnpushedCommits) {
+    changesIcon = padIcon(changeIcons.unpushed);
+  } else if (branch.openPR) {
+    changesIcon = padIcon(changeIcons.openPR);
+  } else if (branch.mergedPR) {
+    changesIcon = padIcon(changeIcons.mergedPR);
+  } else if (branch.worktree?.isAccessible === false) {
+    changesIcon = padIcon(changeIcons.warning);
+  } else if (branch.isCurrent) {
+    changesIcon = padIcon(changeIcons.current);
+  } else {
+    changesIcon = " ".repeat(COLUMN_WIDTH);
+  }
+
+  // Column 4: Remote icon
+  let remoteIconStr: string;
+  if (branch.type === "remote") {
+    remoteIconStr = padIcon(remoteIcon);
+  } else {
+    remoteIconStr = " ".repeat(COLUMN_WIDTH);
+  }
+
+  // Build label with fixed-width columns
+  // Format: [Type][Worktree][Changes][Remote] BranchName
+  const label = `${branchTypeIcon}${worktreeIcon}${changesIcon}${remoteIconStr}${branch.name}`;
+
+  // Collect icons for compatibility
+  const icons: string[] = [];
+  icons.push(branchIcons[branch.branchType]);
+  if (worktreeStatus) {
+    icons.push(
+      worktreeStatus === "active"
+        ? worktreeIcons.active
+        : worktreeIcons.inaccessible,
+    );
+  }
+  // Add change icon based on priority
+  if (hasChanges) {
+    icons.push(changeIcons.hasChanges);
+  } else if (branch.hasUnpushedCommits) {
+    icons.push(changeIcons.unpushed);
+  } else if (branch.openPR) {
+    icons.push(changeIcons.openPR);
+  } else if (branch.mergedPR) {
+    icons.push(changeIcons.mergedPR);
+  } else if (branch.worktree?.isAccessible === false) {
+    icons.push(changeIcons.warning);
+  } else if (branch.isCurrent) {
+    icons.push(changeIcons.current);
+  }
+  if (branch.type === "remote") {
+    icons.push(remoteIcon);
+  }
+
+  return {
+    // Copy all properties from BranchInfo
+    ...branch,
+    // Add display properties
+    icons,
+    worktreeStatus,
+    hasChanges,
+    label,
+    value: branch.name,
+  };
+}
+
+/**
+ * Sorts branches according to the priority rules:
+ * 1. Current branch (highest priority)
+ * 2. main branch
+ * 3. develop branch (only if main exists)
+ * 4. Branches with worktree
+ * 5. Latest commit timestamp (descending) within same worktree status
+ * 6. Local branches
+ * 7. Alphabetical order by name
+ */
+function sortBranches(
+  branches: BranchInfo[],
+  worktreeMap: Map<string, WorktreeInfo>,
+): BranchInfo[] {
+  // Check if main branch exists
+  const hasMainBranch = branches.some((b) => b.branchType === "main");
+
+  return [...branches].sort((a, b) => {
+    // 1. Current branch is highest priority
+    if (a.isCurrent && !b.isCurrent) return -1;
+    if (!a.isCurrent && b.isCurrent) return 1;
+
+    // 2. main branch is second priority
+    if (a.branchType === "main" && b.branchType !== "main") return -1;
+    if (a.branchType !== "main" && b.branchType === "main") return 1;
+
+    // 3. develop branch is third priority (only if main exists)
+    if (hasMainBranch) {
+      if (a.branchType === "develop" && b.branchType !== "develop") return -1;
+      if (a.branchType !== "develop" && b.branchType === "develop") return 1;
+    }
+
+    // 4. Branches with worktree are prioritized
+    const aHasWorktree = worktreeMap.has(a.name) || !!a.worktree;
+    const bHasWorktree = worktreeMap.has(b.name) || !!b.worktree;
+    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;
+    }
+
+    // 6. Local branches are prioritized over remote-only
+    const aIsLocal = a.type === "local";
+    const bIsLocal = b.type === "local";
+    if (aIsLocal && !bIsLocal) return -1;
+    if (!aIsLocal && bIsLocal) return 1;
+
+    // 7. Alphabetical order by name
+    return a.name.localeCompare(b.name);
+  });
+}
+
+/**
+ * Converts an array of BranchInfo to BranchItem array with sorting
+ */
+export function formatBranchItems(
+  branches: BranchInfo[],
+  worktreeMap: Map<string, WorktreeInfo> = new Map(),
+): BranchItem[] {
+  const sortedBranches = sortBranches(branches, worktreeMap);
+  return sortedBranches.map((branch) => formatBranchItem(branch));
+}

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

@@ -0,0 +1,44 @@
+import type { BranchInfo, Statistics } from "../types.js";
+
+/**
+ * Calculates statistics from branch data
+ * @param branches Array of BranchInfo
+ * @param changedBranches Optional set of branch names with uncommitted changes
+ * @returns Statistics object
+ */
+export function calculateStatistics(
+  branches: BranchInfo[],
+  changedBranches: Set<string> = new Set(),
+): Statistics {
+  let localCount = 0;
+  let remoteCount = 0;
+  let worktreeCount = 0;
+  let changesCount = 0;
+
+  for (const branch of branches) {
+    // Count by type
+    if (branch.type === "local") {
+      localCount++;
+
+      // Count worktrees (only for local branches)
+      if (branch.worktree) {
+        worktreeCount++;
+
+        // Count changes (only for branches with worktrees)
+        if (changedBranches.has(branch.name)) {
+          changesCount++;
+        }
+      }
+    } else if (branch.type === "remote") {
+      remoteCount++;
+    }
+  }
+
+  return {
+    localCount,
+    remoteCount,
+    worktreeCount,
+    changesCount,
+    lastUpdated: new Date(),
+  };
+}

package/src/codex.ts

@@ -0,0 +1,139 @@
+import { execa } from "execa";
+import chalk from "chalk";
+import { platform } from "os";
+import { existsSync } from "fs";
+import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
+
+const CODEX_CLI_PACKAGE = "@openai/codex@latest";
+const DEFAULT_CODEX_ARGS = [
+  "--enable",
+  "web_search_request",
+  "--model=gpt-5.1-codex",
+  "--sandbox",
+  "workspace-write",
+  "-c",
+  "model_reasoning_effort=high",
+  "-c",
+  "model_reasoning_summaries=detailed",
+  "-c",
+  "sandbox_workspace_write.network_access=true",
+  "-c",
+  "shell_environment_policy.inherit=all",
+  "-c",
+  "shell_environment_policy.ignore_default_excludes=true",
+  "-c",
+  "shell_environment_policy.experimental_use_profile=true",
+];
+
+export class CodexError extends Error {
+  constructor(
+    message: string,
+    public cause?: unknown,
+  ) {
+    super(message);
+    this.name = "CodexError";
+  }
+}
+
+export async function launchCodexCLI(
+  worktreePath: string,
+  options: {
+    mode?: "normal" | "continue" | "resume";
+    extraArgs?: string[];
+    bypassApprovals?: boolean;
+    envOverrides?: Record<string, string>;
+  } = {},
+): Promise<void> {
+  const terminal = getTerminalStreams();
+
+  try {
+    if (!existsSync(worktreePath)) {
+      throw new Error(`Worktree path does not exist: ${worktreePath}`);
+    }
+
+    console.log(chalk.blue("🚀 Launching Codex CLI..."));
+    console.log(chalk.gray(`   Working directory: ${worktreePath}`));
+
+    const args: string[] = [];
+
+    switch (options.mode) {
+      case "continue":
+        args.push("resume", "--last");
+        console.log(chalk.cyan("   ⏭️  Resuming last Codex session"));
+        break;
+      case "resume":
+        args.push("resume");
+        console.log(chalk.cyan("   🔄 Resume command"));
+        break;
+      case "normal":
+      default:
+        console.log(chalk.green("   ✨ Starting new session"));
+        break;
+    }
+
+    if (options.bypassApprovals) {
+      args.push("--yolo");
+      console.log(chalk.yellow("   ⚠️  Bypassing approvals and sandbox"));
+    }
+
+    if (options.extraArgs && options.extraArgs.length > 0) {
+      args.push(...options.extraArgs);
+    }
+
+    args.push(...DEFAULT_CODEX_ARGS);
+
+    terminal.exitRawMode();
+
+    const childStdio = createChildStdio();
+
+    const env = { ...process.env, ...(options.envOverrides ?? {}) };
+
+    try {
+      await execa("bunx", [CODEX_CLI_PACKAGE, ...args], {
+        cwd: worktreePath,
+        stdin: childStdio.stdin,
+        stdout: childStdio.stdout,
+        stderr: childStdio.stderr,
+        env,
+      } as any);
+    } finally {
+      childStdio.cleanup();
+    }
+  } catch (error: any) {
+    const errorMessage =
+      error.code === "ENOENT"
+        ? "bunx command not found. Please ensure Bun is installed so Codex CLI can run via bunx."
+        : `Failed to launch Codex CLI: ${error.message || "Unknown error"}`;
+
+    if (platform() === "win32") {
+      console.error(chalk.red("\n💡 Windows troubleshooting tips:"));
+      console.error(
+        chalk.yellow(
+          "   1. Confirm that Bun is installed and bunx is available",
+        ),
+      );
+      console.error(
+        chalk.yellow(
+          '   2. Run "bunx @openai/codex@latest -- --help" to verify the setup',
+        ),
+      );
+      console.error(
+        chalk.yellow("   3. Restart your terminal or IDE to refresh PATH"),
+      );
+    }
+
+    throw new CodexError(errorMessage, error);
+  }
+}
+
+export async function isCodexAvailable(): Promise<boolean> {
+  try {
+    await execa("bunx", [CODEX_CLI_PACKAGE, "--help"]);
+    return true;
+  } catch (error: any) {
+    if (error.code === "ENOENT") {
+      console.error(chalk.yellow("\n⚠️  bunx command not found"));
+    }
+    return false;
+  }
+}

package/src/config/builtin-tools.ts

@@ -0,0 +1,44 @@
+/**
+ * ビルトインAIツール定義
+ *
+ * Claude Code と Codex CLI の CustomAITool 形式定義
+ */
+
+import type { CustomAITool } from "../types/tools.js";
+
+/**
+ * Claude Code のビルトイン定義
+ */
+export const CLAUDE_CODE_TOOL: CustomAITool = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  type: "bunx",
+  command: "@anthropic-ai/claude-code@latest",
+  modeArgs: {
+    normal: [],
+    continue: ["-c"],
+    resume: ["-r"],
+  },
+  permissionSkipArgs: ["--yes"],
+};
+
+/**
+ * Codex CLI のビルトイン定義
+ */
+export const CODEX_CLI_TOOL: CustomAITool = {
+  id: "codex-cli",
+  displayName: "Codex CLI",
+  type: "bunx",
+  command: "@openai/codex@latest",
+  defaultArgs: ["--auto-approve", "--verbose"],
+  modeArgs: {
+    normal: [],
+    continue: ["resume", "--last"],
+    resume: ["resume"],
+  },
+};
+
+/**
+ * すべてのビルトインツール
+ */
+export const BUILTIN_TOOLS: CustomAITool[] = [CLAUDE_CODE_TOOL, CODEX_CLI_TOOL];

package/src/config/constants.ts

@@ -0,0 +1,100 @@
+/**
+ * アプリケーション全体で使用する定数
+ */
+
+// ブランチタイプ
+export const BRANCH_TYPES = {
+  FEATURE: "feature",
+  HOTFIX: "hotfix",
+  RELEASE: "release",
+  MAIN: "main",
+  DEVELOP: "develop",
+  OTHER: "other",
+} as const;
+
+// ブランチプレフィックス
+export const BRANCH_PREFIXES = {
+  FEATURE: "feature/",
+  HOTFIX: "hotfix/",
+  RELEASE: "release/",
+} as const;
+
+// メインブランチ名
+export const MAIN_BRANCHES = ["main", "master"] as const;
+export const DEVELOP_BRANCHES = ["develop", "dev"] as const;
+
+// 表示設定
+export const DISPLAY_CONFIG = {
+  MAX_BRANCH_NAME_LENGTH: 50,
+  TABLE_PADDING: 2,
+  CHANGES_COLUMN_WIDTH: 10,
+} as const;
+
+// プロンプト設定
+export const PROMPT_CONFIG = {
+  PAGE_SIZE: 15,
+  SEARCH_ENABLED: true,
+} as const;
+
+// Git設定
+export const GIT_CONFIG = {
+  DEFAULT_BASE_BRANCH: "main",
+  FETCH_TIMEOUT: 30000, // 30秒
+  PUSH_RETRY_COUNT: 3,
+} as const;
+
+// GitHub設定
+export const GITHUB_CONFIG = {
+  PR_FETCH_LIMIT: 100,
+  DEBUG_ENV_VAR: "DEBUG_CLEANUP",
+} as const;
+
+// メッセージキー（国際化対応の基盤）
+export const MESSAGE_KEYS = {
+  // エラーメッセージ
+  ERROR: {
+    NOT_GIT_REPO: "error.not_git_repo",
+    GIT_COMMAND_FAILED: "error.git_command_failed",
+    WORKTREE_CREATE_FAILED: "error.worktree_create_failed",
+    GITHUB_CLI_NOT_AVAILABLE: "error.github_cli_not_available",
+    GITHUB_AUTH_REQUIRED: "error.github_auth_required",
+  },
+  // 成功メッセージ
+  SUCCESS: {
+    WORKTREE_CREATED: "success.worktree_created",
+    BRANCH_CREATED: "success.branch_created",
+    CHANGES_COMMITTED: "success.changes_committed",
+    CHANGES_PUSHED: "success.changes_pushed",
+    CLEANUP_COMPLETED: "success.cleanup_completed",
+  },
+  // 情報メッセージ
+  INFO: {
+    LOADING: "info.loading",
+    PROCESSING: "info.processing",
+    FETCHING_DATA: "info.fetching_data",
+  },
+} as const;
+
+// English messages (default)
+export const MESSAGES_EN = {
+  [MESSAGE_KEYS.ERROR.NOT_GIT_REPO]: "This directory is not a Git repository",
+  [MESSAGE_KEYS.ERROR.GIT_COMMAND_FAILED]: "Failed to run the Git command",
+  [MESSAGE_KEYS.ERROR.WORKTREE_CREATE_FAILED]: "Failed to create the worktree",
+  [MESSAGE_KEYS.ERROR.GITHUB_CLI_NOT_AVAILABLE]: "GitHub CLI is not installed",
+  [MESSAGE_KEYS.ERROR.GITHUB_AUTH_REQUIRED]:
+    "GitHub authentication is required. Please run 'gh auth login'",
+  [MESSAGE_KEYS.SUCCESS.WORKTREE_CREATED]: "Worktree created",
+  [MESSAGE_KEYS.SUCCESS.BRANCH_CREATED]: "Branch created",
+  [MESSAGE_KEYS.SUCCESS.CHANGES_COMMITTED]: "Changes committed",
+  [MESSAGE_KEYS.SUCCESS.CHANGES_PUSHED]: "Changes pushed",
+  [MESSAGE_KEYS.SUCCESS.CLEANUP_COMPLETED]: "Cleanup completed",
+  [MESSAGE_KEYS.INFO.LOADING]: "Loading...",
+  [MESSAGE_KEYS.INFO.PROCESSING]: "Processing...",
+  [MESSAGE_KEYS.INFO.FETCHING_DATA]: "Fetching data...",
+} as const;
+
+// Message lookup helper (multi-language ready)
+export function getMessage(key: string): string {
+  // Currently only English is provided
+  return MESSAGES_EN[key as keyof typeof MESSAGES_EN] || key;
+}

package/src/config/env-history.ts

@@ -0,0 +1,45 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { EnvironmentHistoryEntry } from "../types/api.js";
+import { CONFIG_DIR } from "./tools.js";
+
+const HISTORY_PATH = path.join(CONFIG_DIR, "env-history.json");
+const HISTORY_LIMIT = 200;
+
+interface HistoryFile {
+  entries: EnvironmentHistoryEntry[];
+}
+
+export async function loadEnvHistory(): Promise<EnvironmentHistoryEntry[]> {
+  try {
+    const raw = await readFile(HISTORY_PATH, "utf8");
+    const parsed = JSON.parse(raw) as HistoryFile;
+    return parsed.entries ?? [];
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+
+export async function recordEnvHistory(
+  entries: EnvironmentHistoryEntry[],
+): Promise<void> {
+  if (!entries.length) {
+    return;
+  }
+
+  const existing = await loadEnvHistory();
+  const updated = [...existing, ...entries];
+  const trimmed =
+    updated.length > HISTORY_LIMIT
+      ? updated.slice(updated.length - HISTORY_LIMIT)
+      : updated;
+
+  await mkdir(CONFIG_DIR, { recursive: true });
+  const payload: HistoryFile = { entries: trimmed };
+  await writeFile(HISTORY_PATH, JSON.stringify(payload, null, 2), {
+    mode: 0o600,
+  });
+}