@akiojin/gwt 4.12.1 → 6.0.0

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

@@ -1,222 +0,0 @@
-import type {
-  BranchInfo,
-  BranchItem,
-  WorktreeStatus,
-  WorktreeInfo,
-} from "../types.js";
-
-export interface FormatOptions {
-  hasChanges?: boolean;
-}
-
-function mapToolLabel(toolId: string, toolLabel?: string): string {
-  if (toolId === "claude-code") return "Claude";
-  if (toolId === "codex-cli") return "Codex";
-  if (toolId === "gemini-cli") return "Gemini";
-  if (toolLabel) return toolLabel;
-  return "Custom";
-}
-
-const LOCAL_DATE_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
-  year: "numeric",
-  month: "2-digit",
-  day: "2-digit",
-  hour: "2-digit",
-  minute: "2-digit",
-  hour12: false,
-});
-
-const formatLocalDateTimeParts = (date: Date): string => {
-  const parts = LOCAL_DATE_TIME_FORMATTER.formatToParts(date);
-  const get = (type: Intl.DateTimeFormatPartTypes) =>
-    parts.find((part) => part.type === type)?.value;
-  const year = get("year");
-  const month = get("month");
-  const day = get("day");
-  const hour = get("hour");
-  const minute = get("minute");
-
-  if (!year || !month || !day || !hour || !minute) {
-    return LOCAL_DATE_TIME_FORMATTER.format(date);
-  }
-
-  return `${year}-${month}-${day} ${hour}:${minute}`;
-};
-
-export function formatLocalDateTime(timestampMs: number): string {
-  const date = new Date(timestampMs);
-  if (Number.isNaN(date.getTime())) {
-    return "";
-  }
-  return formatLocalDateTimeParts(date);
-}
-
-function formatTimestamp(ts: number): string {
-  return formatLocalDateTime(ts);
-}
-
-function buildLastToolUsageLabel(
-  usage?: BranchInfo["lastToolUsage"] | null,
-): string | null {
-  if (!usage) return null;
-  const toolText = mapToolLabel(usage.toolId, usage.toolLabel);
-  // バージョン情報を追加（存在しない場合は@latest）
-  const versionSuffix = usage.toolVersion ? `@${usage.toolVersion}` : "@latest";
-  const labelWithVersion = `${toolText}${versionSuffix}`;
-  const timestamp = usage.timestamp ? formatTimestamp(usage.timestamp) : null;
-  const parts = [labelWithVersion];
-  if (timestamp) {
-    parts.push(timestamp);
-  }
-  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
- */
-export function formatBranchItem(
-  branch: BranchInfo,
-  options: FormatOptions = {},
-): BranchItem {
-  const hasChanges = options.hasChanges ?? false;
-  let worktreeStatus: WorktreeStatus | undefined;
-  if (branch.worktree) {
-    worktreeStatus =
-      branch.worktree.isAccessible === false ? "inaccessible" : "active";
-  }
-
-  // Build Local/Remote name for display
-  // ローカルブランチ: ブランチ名を表示
-  // リモートのみ: origin/xxxをフル表示
-  let displayName: string;
-  let remoteName: string | null = null;
-
-  if (branch.type === "remote") {
-    // リモートのみのブランチ: フルのリモートブランチ名を表示
-    displayName = branch.name; // origin/xxx
-    remoteName = branch.name;
-  } else {
-    // ローカルブランチ: ブランチ名を表示
-    displayName = branch.name;
-  }
-
-  const label = displayName;
-  const icons: string[] = [];
-
-  // Determine sync status for BranchItem
-  let syncStatus: BranchItem["syncStatus"];
-  if (branch.type === "remote") {
-    syncStatus = "remote-only";
-  } else if (!branch.hasRemoteCounterpart) {
-    syncStatus = "no-upstream";
-  } else if (branch.divergence) {
-    const { ahead, behind, upToDate } = branch.divergence;
-    if (upToDate) {
-      syncStatus = "up-to-date";
-    } else if (ahead > 0 && behind > 0) {
-      syncStatus = "diverged";
-    } else if (ahead > 0) {
-      syncStatus = "ahead";
-    } else {
-      syncStatus = "behind";
-    }
-  } else {
-    syncStatus = "no-upstream";
-  }
-
-  return {
-    // Copy all properties from BranchInfo
-    ...branch,
-    // Add display properties
-    icons,
-    worktreeStatus,
-    hasChanges,
-    label,
-    value: branch.name,
-    lastToolUsageLabel: buildLastToolUsageLabel(branch.lastToolUsage),
-    syncStatus,
-    syncInfo: undefined,
-    remoteName: remoteName ?? undefined,
-  };
-}
-
-/**
- * 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 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
-    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/clipboard.ts

@@ -1,31 +0,0 @@
-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/cli/ui/utils/continueSession.ts

@@ -1,231 +0,0 @@
-import type { SessionData, ToolSessionEntry } from "../../../config/index.js";
-import type { SessionSearchOptions } from "../../../utils/session/index.js";
-import {
-  findLatestClaudeSession,
-  findLatestClaudeSessionId,
-  findLatestCodexSession,
-  findLatestCodexSessionId,
-  findLatestGeminiSession,
-  findLatestGeminiSessionId,
-  findLatestOpenCodeSession,
-} from "../../../utils/session/index.js";
-import { listAllWorktrees } from "../../../worktree.js";
-
-export interface ContinueSessionContext {
-  history: ToolSessionEntry[];
-  sessionData: SessionData | null;
-  branch: string;
-  toolId: string;
-  repoRoot: string | null;
-  lookupLatestSessionId?: (params: {
-    toolId: string;
-    worktreePath: string;
-  }) => Promise<string | null>;
-}
-
-/**
- * 指定されたブランチ/ツールに紐づく最新セッションIDを解決する。
- * 1. 履歴(history)の最新マッチを優先
- * 2. lastSessionId がブランチ/ツール一致であれば利用
- * 3. それでも無い場合、同一ブランチ/ツールであればツール固有の保存場所から検出
- */
-export async function resolveContinueSessionId(
-  context: ContinueSessionContext,
-): Promise<string | null> {
-  const { history, sessionData, branch, toolId, repoRoot: _repoRoot } = context;
-
-  // 1) 履歴から最新マッチを探す（末尾から遡る）
-  for (let i = history.length - 1; i >= 0; i -= 1) {
-    const entry = history[i];
-    if (
-      entry &&
-      entry.branch === branch &&
-      entry.toolId === toolId &&
-      entry.sessionId
-    ) {
-      return entry.sessionId;
-    }
-  }
-
-  // 2) lastSessionId が一致する場合はそれを返す
-  if (
-    sessionData?.lastSessionId &&
-    sessionData.lastBranch === branch &&
-    sessionData.lastUsedTool === toolId
-  ) {
-    return sessionData.lastSessionId;
-  }
-
-  const latestEntry = findLatestBranchSession(history, branch, toolId);
-  const worktreePath = latestEntry?.worktreePath ?? null;
-  if (!worktreePath) {
-    return null;
-  }
-
-  if (context.lookupLatestSessionId) {
-    const lookupResult = await context.lookupLatestSessionId({
-      toolId,
-      worktreePath,
-    });
-    return lookupResult ?? null;
-  }
-
-  return lookupLatestSessionIdForTool(toolId, worktreePath);
-}
-
-async function lookupLatestSessionIdForTool(
-  toolId: string,
-  worktreePath: string,
-): Promise<string | null> {
-  try {
-    if (toolId === "claude-code") {
-      return await findLatestClaudeSessionId(worktreePath);
-    }
-    if (toolId === "codex-cli") {
-      return await findLatestCodexSessionId({ cwd: worktreePath });
-    }
-    if (toolId === "gemini-cli") {
-      return await findLatestGeminiSessionId(worktreePath);
-    }
-  } catch {
-    return null;
-  }
-
-  return null;
-}
-
-export function findLatestBranchSession(
-  history: ToolSessionEntry[],
-  branch: string,
-  toolId?: string | null,
-): ToolSessionEntry | null {
-  const byBranch = history.filter((entry) => entry && entry.branch === branch);
-  if (!byBranch.length) return null;
-
-  const pickLatest = (entries: ToolSessionEntry[]) =>
-    entries.reduce<ToolSessionEntry | null>((latest, entry) => {
-      if (!latest) return entry;
-      const latestTs = latest.timestamp ?? 0;
-      const currentTs = entry.timestamp ?? 0;
-      return currentTs >= latestTs ? entry : latest;
-    }, null);
-
-  if (toolId) {
-    const byTool = byBranch.filter((entry) => entry.toolId === toolId);
-    if (byTool.length) {
-      return pickLatest(byTool);
-    }
-  }
-
-  return pickLatest(byBranch);
-}
-
-export function findLatestBranchSessionsByTool(
-  history: ToolSessionEntry[],
-  branch: string,
-  worktreePath?: string | null,
-): ToolSessionEntry[] {
-  const byBranch = history.filter((entry) => entry && entry.branch === branch);
-  if (!byBranch.length) return [];
-
-  const source = worktreePath
-    ? byBranch.filter((entry) => entry.worktreePath === worktreePath)
-    : byBranch;
-  if (!source.length) return [];
-
-  const latestByTool = new Map<string, ToolSessionEntry>();
-  for (const entry of source) {
-    if (!entry.toolId) continue;
-    const current = latestByTool.get(entry.toolId);
-    const currentTs = current?.timestamp ?? 0;
-    const entryTs = entry.timestamp ?? 0;
-    if (!current || entryTs >= currentTs) {
-      latestByTool.set(entry.toolId, entry);
-    }
-  }
-
-  return Array.from(latestByTool.values()).sort(
-    (a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0),
-  );
-}
-
-export interface QuickStartRefreshContext {
-  branch: string;
-  worktreePath?: string | null;
-}
-
-export interface QuickStartSessionLookups {
-  findLatestCodexSession?: typeof findLatestCodexSession;
-  findLatestClaudeSession?: typeof findLatestClaudeSession;
-  findLatestGeminiSession?: typeof findLatestGeminiSession;
-  findLatestOpenCodeSession?: typeof findLatestOpenCodeSession;
-  listAllWorktrees?: typeof listAllWorktrees;
-}
-
-export async function refreshQuickStartEntries(
-  entries: ToolSessionEntry[],
-  context: QuickStartRefreshContext,
-  lookups: QuickStartSessionLookups = {},
-): Promise<ToolSessionEntry[]> {
-  if (!entries.length) return entries;
-  const worktreePath = context.worktreePath ?? null;
-  if (!worktreePath) return entries;
-
-  const lookupWorktrees = lookups.listAllWorktrees ?? listAllWorktrees;
-  let resolvedWorktrees: { path: string; branch: string }[] | null = null;
-  try {
-    const allWorktrees = await lookupWorktrees();
-    resolvedWorktrees = allWorktrees
-      .filter((entry) => entry?.path && entry?.branch)
-      .map((entry) => ({ path: entry.path, branch: entry.branch }));
-  } catch {
-    resolvedWorktrees = null;
-  }
-
-  const searchOptions: SessionSearchOptions = {
-    branch: context.branch,
-    ...(resolvedWorktrees && resolvedWorktrees.length > 0
-      ? { worktrees: resolvedWorktrees }
-      : {}),
-  };
-
-  const lookupCodex = lookups.findLatestCodexSession ?? findLatestCodexSession;
-  const lookupClaude =
-    lookups.findLatestClaudeSession ?? findLatestClaudeSession;
-  const lookupGemini =
-    lookups.findLatestGeminiSession ?? findLatestGeminiSession;
-  const lookupOpenCode =
-    lookups.findLatestOpenCodeSession ?? findLatestOpenCodeSession;
-
-  const updated = await Promise.all(
-    entries.map(async (entry) => {
-      let latest: { id: string; mtime: number } | null = null;
-      switch (entry.toolId) {
-        case "codex-cli":
-          latest = await lookupCodex(searchOptions);
-          break;
-        case "claude-code":
-          latest = await lookupClaude(worktreePath, searchOptions);
-          break;
-        case "gemini-cli":
-          latest = await lookupGemini(searchOptions);
-          break;
-        case "opencode":
-          latest = await lookupOpenCode(searchOptions);
-          break;
-        default:
-          return entry;
-      }
-
-      if (!latest?.id) return entry;
-      const updatedTimestamp = Math.max(entry.timestamp ?? 0, latest.mtime);
-      return {
-        ...entry,
-        sessionId: latest.id,
-        timestamp: updatedTimestamp,
-      };
-    }),
-  );
-
-  return updated.sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0));
-}

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

@@ -1,84 +0,0 @@
-/**
- * Installed version cache for coding agents (FR-017)
- *
- * Caches locally installed agent versions detected at startup
- * to avoid async fetch during wizard navigation.
- */
-
-import type { InstalledVersionInfo } from "./versionFetcher.js";
-import { fetchInstalledVersionForAgent } from "./versionFetcher.js";
-
-/**
- * In-memory cache for installed versions
- * Maps agentId -> InstalledVersionInfo | null
- */
-const installedVersionCache = new Map<string, InstalledVersionInfo | null>();
-
-/**
- * Type for installed version fetch function (injectable for testing)
- */
-export type InstalledVersionFetcher = (
-  agentId: string,
-) => Promise<InstalledVersionInfo | null>;
-
-/**
- * Get cached installed version for an agent
- * @returns Cached info or null if not installed/unknown
- */
-export function getInstalledVersionCache(
-  agentId: string,
-): InstalledVersionInfo | null {
-  const cached = installedVersionCache.get(agentId);
-  return cached ?? null;
-}
-
-/**
- * Set installed version cache (for testing or direct population)
- */
-export function setInstalledVersionCache(
-  agentId: string,
-  installed: InstalledVersionInfo | null,
-): void {
-  installedVersionCache.set(agentId, installed);
-}
-
-/**
- * Clear installed version cache
- */
-export function clearInstalledVersionCache(): void {
-  installedVersionCache.clear();
-}
-
-/**
- * Prefetch installed versions for multiple agents in parallel
- * This should be called at application startup
- *
- * @param agentIds - List of agent IDs to prefetch
- * @param fetchFn - Optional custom fetch function (for testing)
- */
-export async function prefetchInstalledVersions(
-  agentIds: string[],
-  fetchFn?: InstalledVersionFetcher,
-): Promise<void> {
-  const fetcher =
-    fetchFn ??
-    (async (agentId: string) => fetchInstalledVersionForAgent(agentId));
-
-  const results = await Promise.allSettled(
-    agentIds.map(async (agentId) => {
-      try {
-        const installed = await fetcher(agentId);
-        setInstalledVersionCache(agentId, installed);
-      } catch {
-        setInstalledVersionCache(agentId, null);
-      }
-    }),
-  );
-
-  // Swallow any rejections to keep startup non-blocking
-  for (const result of results) {
-    if (result.status === "rejected") {
-      // no-op
-    }
-  }
-}

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

@@ -1,98 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import {
-  getModelOptions,
-  getDefaultInferenceForModel,
-  getDefaultModelOption,
-  normalizeModelId,
-} from "./modelOptions.js";
-
-const byId = (tool: string) => getModelOptions(tool).map((m) => m.id);
-
-describe("modelOptions", () => {
-  it("lists Claude official aliases and sets Default as default", () => {
-    const options = getModelOptions("claude-code");
-    const ids = options.map((m) => m.id);
-    expect(ids).toEqual(["", "opus", "sonnet", "haiku"]);
-    const defaultModel = getDefaultModelOption("claude-code");
-    expect(defaultModel?.id).toBe("");
-    expect(defaultModel?.label).toBe("Default (Auto)");
-  });
-
-  it("has unique Codex models", () => {
-    const ids = byId("codex-cli");
-    const unique = new Set(ids);
-    expect(unique.size).toBe(ids.length);
-    expect(ids).toEqual([
-      "",
-      "gpt-5.2-codex",
-      "gpt-5.1-codex-max",
-      "gpt-5.1-codex-mini",
-      "gpt-5.2",
-    ]);
-  });
-
-  it("exposes gpt-5.2-codex with xhigh reasoning and high default", () => {
-    const codex52 = getModelOptions("codex-cli").find(
-      (m) => m.id === "gpt-5.2-codex",
-    );
-    expect(codex52?.inferenceLevels).toEqual([
-      "xhigh",
-      "high",
-      "medium",
-      "low",
-    ]);
-    expect(getDefaultInferenceForModel(codex52)).toBe("high");
-  });
-
-  it("uses medium as default reasoning for codex-max", () => {
-    const codexMax = getModelOptions("codex-cli").find(
-      (m) => m.id === "gpt-5.1-codex-max",
-    );
-    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",
-      "gemini-3-flash-preview",
-      "gemini-2.5-pro",
-      "gemini-2.5-flash",
-      "gemini-2.5-flash-lite",
-    ]);
-  });
-
-  it("includes OpenCode default and custom options", () => {
-    expect(byId("opencode")).toEqual(["", "__custom__"]);
-    const defaultModel = getDefaultModelOption("opencode");
-    expect(defaultModel?.id).toBe("");
-  });
-
-  it("normalizes known Claude model typos and casing", () => {
-    expect(normalizeModelId("claude-code", "opuss")).toBe("opus");
-    expect(normalizeModelId("claude-code", "Opus")).toBe("opus");
-    expect(normalizeModelId("claude-code", "sonnet")).toBe("sonnet");
-    expect(normalizeModelId("claude-code", null)).toBeNull();
-    expect(normalizeModelId("claude-code", undefined)).toBeNull();
-    expect(normalizeModelId("claude-code", "")).toBeNull();
-    expect(normalizeModelId("claude-code", "  ")).toBeNull();
-    expect(normalizeModelId("claude-code", "  opus  ")).toBe("opus");
-  });
-
-  it("returns no models for unsupported tools", () => {
-    expect(byId("unknown-tool")).toEqual([]);
-  });
-});