@akiojin/gwt 4.10.0 → 4.12.0

package/src/utils/npmRegistry.ts

@@ -0,0 +1,249 @@
+/**
+ * npm Registry API utilities for fetching package versions
+ */
+
+export interface VersionInfo {
+  version: string;
+  isPrerelease: boolean;
+  publishedAt?: string;
+}
+
+export type VersionSelection = "installed" | "latest" | string;
+
+interface NpmRegistryResponse {
+  "dist-tags"?: Record<string, string>;
+  time?: Record<string, string>;
+  versions?: Record<string, unknown>;
+}
+
+const DEFAULT_TIMEOUT_MS = 3000;
+const DEFAULT_LIMIT = 10;
+
+/**
+ * Check if a version string is a prerelease version
+ */
+function isPrerelease(version: string): boolean {
+  // Prerelease versions contain - followed by alpha, beta, rc, canary, next, etc.
+  return /-(alpha|beta|rc|canary|next|dev|pre)\b/i.test(version);
+}
+
+/**
+ * Fetch package versions from npm registry
+ * Returns the latest N versions sorted by publish date (newest first)
+ */
+export async function fetchPackageVersions(
+  packageName: string,
+  limit: number = DEFAULT_LIMIT,
+  timeoutMs: number = DEFAULT_TIMEOUT_MS,
+): Promise<VersionInfo[]> {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}`,
+      {
+        signal: controller.signal,
+        headers: {
+          Accept: "application/json",
+        },
+      },
+    );
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      return [];
+    }
+
+    const data = (await response.json()) as NpmRegistryResponse;
+
+    if (!data.versions || !data.time) {
+      return [];
+    }
+
+    // Get all versions with their publish times
+    const versionsWithTime: Array<{
+      version: string;
+      publishedAt: string;
+    }> = [];
+
+    for (const version of Object.keys(data.versions)) {
+      const publishedAt = data.time[version];
+      if (publishedAt) {
+        versionsWithTime.push({ version, publishedAt });
+      }
+    }
+
+    // Sort by publish date (newest first)
+    versionsWithTime.sort((a, b) => {
+      const dateA = new Date(a.publishedAt).getTime();
+      const dateB = new Date(b.publishedAt).getTime();
+      return dateB - dateA;
+    });
+
+    // Take the top N versions
+    const topVersions = versionsWithTime.slice(0, limit);
+
+    // Convert to VersionInfo
+    return topVersions.map((v) => ({
+      version: v.version,
+      isPrerelease: isPrerelease(v.version),
+      publishedAt: v.publishedAt,
+    }));
+  } catch {
+    // Return empty array on any error (network, timeout, parse error, etc.)
+    return [];
+  }
+}
+
+/**
+ * Parse a package command to extract package name and version
+ * Examples:
+ *   "@anthropic-ai/claude-code" -> { packageName: "@anthropic-ai/claude-code", version: null }
+ *   "@anthropic-ai/claude-code@latest" -> { packageName: "@anthropic-ai/claude-code", version: "latest" }
+ *   "@anthropic-ai/claude-code@1.0.3" -> { packageName: "@anthropic-ai/claude-code", version: "1.0.3" }
+ *   "opencode-ai@latest" -> { packageName: "opencode-ai", version: "latest" }
+ */
+export function parsePackageCommand(command: string): {
+  packageName: string;
+  version: string | null;
+} {
+  // Handle scoped packages (@scope/name@version)
+  if (command.startsWith("@")) {
+    // Find the second @ which separates version
+    const firstSlash = command.indexOf("/");
+    if (firstSlash === -1) {
+      // Invalid scoped package format
+      return { packageName: command, version: null };
+    }
+    const afterScope = command.substring(firstSlash + 1);
+    const atIndex = afterScope.indexOf("@");
+    if (atIndex === -1) {
+      return { packageName: command, version: null };
+    }
+    const packageName = command.substring(0, firstSlash + 1 + atIndex);
+    const version = afterScope.substring(atIndex + 1);
+    return { packageName, version };
+  }
+
+  // Handle non-scoped packages (name@version)
+  const atIndex = command.indexOf("@");
+  if (atIndex === -1) {
+    return { packageName: command, version: null };
+  }
+  const packageName = command.substring(0, atIndex);
+  const version = command.substring(atIndex + 1);
+  return { packageName, version };
+}
+
+/**
+ * Resolve version selection to a bunx-compatible suffix
+ * Examples:
+ *   "installed" -> "" (use bunx default/cached version)
+ *   "latest" -> "@latest"
+ *   "1.0.3" -> "@1.0.3"
+ *   undefined -> "" (use bunx default/cached version)
+ */
+export function resolveVersionSuffix(version?: VersionSelection): string {
+  if (!version || version === "installed") {
+    return "";
+  }
+  return `@${version}`;
+}
+
+export interface GlobalPackageInfo {
+  name: string;
+  version: string;
+}
+
+export interface GlobalPackagesResult {
+  path: string | null;
+  packages: GlobalPackageInfo[];
+}
+
+/**
+ * Parse the output of `bun pm ls -g` command
+ * Example output:
+ *   /root/.bun/install/global node_modules (17)
+ *   ├── @anthropic-ai/claude-code@2.0.76
+ *   └── @openai/codex@0.77.0
+ */
+export function parseGlobalPackagesOutput(
+  output: string,
+): GlobalPackagesResult {
+  const lines = output.trim().split("\n");
+  if (lines.length === 0 || !lines[0]) {
+    return { path: null, packages: [] };
+  }
+
+  // Parse the first line to get the path
+  // Format: "/path/to/global node_modules (N)"
+  const firstLine = lines[0];
+  const pathMatch = firstLine.match(/^(.+?)\s+node_modules\s+\(\d+\)$/);
+  const path = pathMatch?.[1] ?? null;
+
+  // Parse package lines
+  const packages: GlobalPackageInfo[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+
+    // Remove tree characters (├── └── │)
+    const cleaned = line.replace(/^[├└│─\s]+/, "").trim();
+    if (!cleaned) continue;
+
+    // Parse package@version format
+    // Handle scoped packages like @anthropic-ai/claude-code@2.0.76
+    const lastAtIndex = cleaned.lastIndexOf("@");
+    if (lastAtIndex <= 0) continue; // No version or invalid format
+
+    const name = cleaned.substring(0, lastAtIndex);
+    const version = cleaned.substring(lastAtIndex + 1);
+
+    if (name && version) {
+      packages.push({ name, version });
+    }
+  }
+
+  return { path, packages };
+}
+
+export interface InstalledPackageInfo {
+  version: string;
+  path: string;
+}
+
+/**
+ * Get information about a globally installed package
+ * Returns null if the package is not installed
+ */
+export async function getInstalledPackageInfo(
+  packageName: string,
+): Promise<InstalledPackageInfo | null> {
+  try {
+    const { execa } = await import("execa");
+    const result = await execa("bun", ["pm", "ls", "-g"], {
+      timeout: 5000,
+      reject: false,
+    });
+
+    if (result.exitCode !== 0 || !result.stdout) {
+      return null;
+    }
+
+    const parsed = parseGlobalPackagesOutput(result.stdout);
+    const pkg = parsed.packages.find((p) => p.name === packageName);
+
+    if (!pkg || !parsed.path) {
+      return null;
+    }
+
+    return {
+      version: pkg.version,
+      path: `${parsed.path}/node_modules/${packageName}`,
+    };
+  } catch {
+    return null;
+  }
+}

package/src/utils/prompt.ts

@@ -95,7 +95,7 @@ async function runReadlinePrompt<T>(
 }
 
 /**
- * Wait for Enter using the same terminal streams as Ink.
+ * Wait for Enter using the same terminal streams as the CLI UI.
  * Falls back to no-op on non-interactive stdin to avoid blocking pipelines.
  */
 export async function waitForEnter(promptMessage: string): Promise<void> {

package/src/utils/session/common.ts

@@ -444,3 +444,31 @@ export function matchesCwd(
     isPathPrefix(normalizedSession, normalizedTarget)
   );
 }
+
+/**
+ * Resolves a branch name for a session cwd using worktree paths.
+ * Picks the worktree with the longest matching path prefix.
+ */
+export function resolveBranchFromCwd(
+  sessionCwd: string | null,
+  worktrees: { path: string; branch: string }[],
+): string | null {
+  if (!sessionCwd) return null;
+  const normalizedSession = normalizePath(sessionCwd);
+  let bestMatch: { branch: string; path: string } | null = null;
+
+  for (const worktree of worktrees) {
+    if (!worktree?.path || !worktree.branch) continue;
+    const normalizedPath = normalizePath(worktree.path);
+    if (
+      normalizedSession === normalizedPath ||
+      isPathPrefix(normalizedPath, normalizedSession)
+    ) {
+      if (!bestMatch || normalizedPath.length > bestMatch.path.length) {
+        bestMatch = { branch: worktree.branch, path: normalizedPath };
+      }
+    }
+  }
+
+  return bestMatch?.branch ?? null;
+}

package/src/utils/session/parsers/claude.ts

@@ -16,6 +16,7 @@ import {
   readFileContent,
   checkFileStat,
 } from "../common.js";
+import { listAllWorktrees } from "../../../worktree.js";
 
 /**
  * Encodes a project path for Claude's directory structure.
@@ -75,36 +76,72 @@ function getClaudeRootCandidates(): string[] {
  * 3. ~/.claude/history.jsonl (global history fallback)
  *
  * @param cwd - The working directory to find sessions for
- * @param options - Search options (since, until, preferClosestTo, windowMs)
+ * @param options - Search options (since, until, preferClosestTo, windowMs, branch/worktrees)
  * @returns Session info with ID and modification time, or null if not found
  */
 export async function findLatestClaudeSession(
   cwd: string,
-  options: Omit<SessionSearchOptions, "cwd"> = {},
+  options: SessionSearchOptions = {},
 ): Promise<ClaudeSessionInfo | null> {
   const rootCandidates = getClaudeRootCandidates();
-  const encodedPaths = generateClaudeProjectPathCandidates(cwd);
-
-  for (const claudeRoot of rootCandidates) {
-    for (const encoded of encodedPaths) {
-      const projectDir = path.join(claudeRoot, "projects", encoded);
-      const sessionsDir = path.join(projectDir, "sessions");
-
-      // 1) Look under sessions/ (official location)
-      const session = await findNewestSessionIdFromDir(
-        sessionsDir,
-        false,
-        options,
-      );
-      if (session) return session;
+  const branchFilter =
+    typeof options.branch === "string" && options.branch.trim().length > 0
+      ? options.branch.trim()
+      : null;
 
-      // 2) Look directly under project dir and subdirs
-      const rootSession = await findNewestSessionIdFromDir(
-        projectDir,
-        true,
-        options,
-      );
-      if (rootSession) return rootSession;
+  let cwdCandidates: string[] = [];
+  if (branchFilter) {
+    let worktrees: { path: string; branch: string }[] = [];
+    if (Array.isArray(options.worktrees) && options.worktrees.length > 0) {
+      worktrees = options.worktrees
+        .filter((entry) => entry?.path && entry?.branch)
+        .map((entry) => ({ path: entry.path, branch: entry.branch }));
+    } else {
+      try {
+        const allWorktrees = await listAllWorktrees();
+        worktrees = allWorktrees
+          .filter((entry) => entry?.path && entry?.branch)
+          .map((entry) => ({ path: entry.path, branch: entry.branch }));
+      } catch {
+        worktrees = [];
+      }
+    }
+    const matches = worktrees
+      .filter((entry) => entry.branch === branchFilter)
+      .map((entry) => entry.path);
+    if (!matches.length) return null;
+    cwdCandidates = matches;
+  } else {
+    const baseCwd = options.cwd ?? cwd;
+    if (!baseCwd) return null;
+    cwdCandidates = [baseCwd];
+  }
+
+  const uniqueCwds = Array.from(new Set(cwdCandidates));
+
+  for (const candidateCwd of uniqueCwds) {
+    const encodedPaths = generateClaudeProjectPathCandidates(candidateCwd);
+    for (const claudeRoot of rootCandidates) {
+      for (const encoded of encodedPaths) {
+        const projectDir = path.join(claudeRoot, "projects", encoded);
+        const sessionsDir = path.join(projectDir, "sessions");
+
+        // 1) Look under sessions/ (official location)
+        const session = await findNewestSessionIdFromDir(
+          sessionsDir,
+          false,
+          options,
+        );
+        if (session) return session;
+
+        // 2) Look directly under project dir and subdirs
+        const rootSession = await findNewestSessionIdFromDir(
+          projectDir,
+          true,
+          options,
+        );
+        if (rootSession) return rootSession;
+      }
     }
   }
 
@@ -124,7 +161,10 @@ export async function findLatestClaudeSession(
           typeof parsed.project === "string" ? parsed.project : null;
         const sessionId =
           typeof parsed.sessionId === "string" ? parsed.sessionId : null;
-        if (project && sessionId && matchesCwd(project, cwd)) {
+        const matchesProject = uniqueCwds.some((candidate) =>
+          matchesCwd(project, candidate),
+        );
+        if (project && sessionId && matchesProject) {
           return { id: sessionId, mtime: historyStat.mtimeMs };
         }
       } catch {
@@ -141,14 +181,14 @@ export async function findLatestClaudeSession(
 /**
  * Finds the latest Claude session ID for a given working directory.
  * @param cwd - The working directory to find sessions for
- * @param options - Search options (since, until, preferClosestTo, windowMs)
+ * @param options - Search options (since, until, preferClosestTo, windowMs, branch/worktrees)
  * @returns Session ID string or null if not found
  */
 export async function findLatestClaudeSessionId(
   cwd: string,
-  options: Omit<SessionSearchOptions, "cwd"> = {},
+  options: SessionSearchOptions = {},
 ): Promise<string | null> {
-  const found = await findLatestClaudeSession(cwd, options);
+  const found = await findLatestClaudeSession(options.cwd ?? cwd, options);
   return found?.id ?? null;
 }
 
@@ -167,6 +207,9 @@ export async function waitForClaudeSessionId(
     until?: number;
     preferClosestTo?: number;
     windowMs?: number;
+    branch?: string | null;
+    worktrees?: { path: string; branch: string }[] | null;
+    cwd?: string | null;
   } = {},
 ): Promise<string | null> {
   const timeoutMs = options.timeoutMs ?? 120_000;
@@ -174,15 +217,22 @@ export async function waitForClaudeSessionId(
   const deadline = Date.now() + timeoutMs;
 
   // Build search options once outside the loop
-  const searchOptions: Omit<SessionSearchOptions, "cwd"> = {};
+  const searchOptions: SessionSearchOptions = {};
   if (options.since !== undefined) searchOptions.since = options.since;
   if (options.until !== undefined) searchOptions.until = options.until;
   if (options.preferClosestTo !== undefined)
     searchOptions.preferClosestTo = options.preferClosestTo;
   if (options.windowMs !== undefined) searchOptions.windowMs = options.windowMs;
+  if (options.branch !== undefined) searchOptions.branch = options.branch;
+  if (options.worktrees !== undefined)
+    searchOptions.worktrees = options.worktrees;
+  if (options.cwd !== undefined) searchOptions.cwd = options.cwd;
 
   while (Date.now() < deadline) {
-    const found = await findLatestClaudeSession(cwd, searchOptions);
+    const found = await findLatestClaudeSession(
+      options.cwd ?? cwd,
+      searchOptions,
+    );
     if (found?.id) return found.id;
     await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
   }

package/src/utils/session/parsers/codex.ts

@@ -14,8 +14,10 @@ import {
   UUID_REGEX,
   collectFilesIterative,
   matchesCwd,
+  resolveBranchFromCwd,
   readSessionInfoFromFile,
 } from "../common.js";
+import { listAllWorktrees } from "../../../worktree.js";
 
 /**
  * Finds the latest Codex session with optional time filtering and cwd matching.
@@ -63,32 +65,62 @@ export async function findLatestCodexSession(
     return b.mtime - a.mtime;
   });
 
+  const branchFilter =
+    typeof options.branch === "string" && options.branch.trim().length > 0
+      ? options.branch.trim()
+      : null;
+  const shouldCheckBranch = Boolean(branchFilter);
+  const shouldCheckCwd = Boolean(options.cwd) && !shouldCheckBranch;
+
+  let worktrees: { path: string; branch: string }[] = [];
+  if (shouldCheckBranch) {
+    if (Array.isArray(options.worktrees) && options.worktrees.length > 0) {
+      worktrees = options.worktrees
+        .filter((entry) => entry?.path && entry?.branch)
+        .map((entry) => ({ path: entry.path, branch: entry.branch }));
+    } else {
+      try {
+        const allWorktrees = await listAllWorktrees();
+        worktrees = allWorktrees
+          .filter((entry) => entry?.path && entry?.branch)
+          .map((entry) => ({ path: entry.path, branch: entry.branch }));
+      } catch {
+        worktrees = [];
+      }
+    }
+    if (!worktrees.length) return null;
+  }
+
   for (const file of ordered) {
     // Priority 1: Extract session ID from filename (most reliable for Codex)
     const filenameMatch = path.basename(file.fullPath).match(UUID_REGEX);
-    if (filenameMatch) {
-      const sessionId = filenameMatch[0];
-      // If cwd filtering is needed, read file content to check cwd
-      if (options.cwd) {
-        const info = await readSessionInfoFromFile(file.fullPath);
-        if (matchesCwd(info.cwd, options.cwd)) {
-          return { id: sessionId, mtime: file.mtime };
-        }
-        continue; // cwd doesn't match, try next file
+    const idFromName = filenameMatch?.[0] ?? null;
+    const needsInfo = shouldCheckBranch || shouldCheckCwd || !idFromName;
+    const info = needsInfo
+      ? await readSessionInfoFromFile(file.fullPath)
+      : null;
+    const sessionCwd = info?.cwd ?? null;
+
+    if (shouldCheckBranch) {
+      const resolvedBranch = resolveBranchFromCwd(sessionCwd, worktrees);
+      if (resolvedBranch !== branchFilter) {
+        continue;
       }
-      return { id: sessionId, mtime: file.mtime };
     }
 
-    // Priority 2: Fallback to reading file content if filename lacks UUID
-    const info = await readSessionInfoFromFile(file.fullPath);
-    if (!info.id) continue;
-    if (options.cwd) {
-      if (matchesCwd(info.cwd, options.cwd)) {
-        return { id: info.id, mtime: file.mtime };
+    if (shouldCheckCwd && options.cwd) {
+      if (!matchesCwd(sessionCwd, options.cwd)) {
+        continue;
       }
-      continue;
     }
-    return { id: info.id, mtime: file.mtime };
+
+    const sessionId = idFromName ?? info?.id ?? null;
+    if (sessionId) {
+      return { id: sessionId, mtime: file.mtime };
+    }
+
+    // Priority 2: Fallback to reading file content if filename lacks UUID
+    // (already handled via info above)
   }
 
   return null;

package/src/utils/session/parsers/gemini.ts

@@ -12,8 +12,10 @@ import type { GeminiSessionInfo, SessionSearchOptions } from "../types.js";
 import {
   collectFilesIterative,
   matchesCwd,
+  resolveBranchFromCwd,
   readSessionInfoFromFile,
 } from "../common.js";
+import { listAllWorktrees } from "../../../worktree.js";
 
 /**
  * Finds the latest Gemini session with optional time filtering and cwd matching.
@@ -57,15 +59,50 @@ export async function findLatestGeminiSession(
     return b.mtime - a.mtime;
   });
 
+  const branchFilter =
+    typeof options.branch === "string" && options.branch.trim().length > 0
+      ? options.branch.trim()
+      : null;
+  const shouldCheckBranch = Boolean(branchFilter);
+  const shouldCheckCwd = Boolean(options.cwd) && !shouldCheckBranch;
+
+  let worktrees: { path: string; branch: string }[] = [];
+  if (shouldCheckBranch) {
+    if (Array.isArray(options.worktrees) && options.worktrees.length > 0) {
+      worktrees = options.worktrees
+        .filter((entry) => entry?.path && entry?.branch)
+        .map((entry) => ({ path: entry.path, branch: entry.branch }));
+    } else {
+      try {
+        const allWorktrees = await listAllWorktrees();
+        worktrees = allWorktrees
+          .filter((entry) => entry?.path && entry?.branch)
+          .map((entry) => ({ path: entry.path, branch: entry.branch }));
+      } catch {
+        worktrees = [];
+      }
+    }
+    if (!worktrees.length) return null;
+  }
+
   for (const file of pool) {
     const info = await readSessionInfoFromFile(file.fullPath);
     if (!info.id) continue;
-    if (options.cwd) {
-      if (matchesCwd(info.cwd, options.cwd)) {
-        return { id: info.id, mtime: file.mtime };
+    const sessionCwd = info.cwd ?? null;
+
+    if (shouldCheckBranch) {
+      const resolvedBranch = resolveBranchFromCwd(sessionCwd, worktrees);
+      if (resolvedBranch !== branchFilter) {
+        continue;
       }
-      continue;
     }
+
+    if (shouldCheckCwd && options.cwd) {
+      if (!matchesCwd(sessionCwd, options.cwd)) {
+        continue;
+      }
+    }
+
     return { id: info.id, mtime: file.mtime };
   }
 
@@ -82,7 +119,11 @@ export async function findLatestGeminiSessionId(
   cwd: string,
   options: SessionSearchOptions = {},
 ): Promise<string | null> {
-  const searchOptions: SessionSearchOptions = { cwd: options.cwd ?? cwd };
+  const searchOptions: SessionSearchOptions = {
+    cwd: options.cwd ?? cwd,
+    branch: options.branch ?? null,
+    worktrees: options.worktrees ?? null,
+  };
   if (options.since !== undefined) searchOptions.since = options.since;
   if (options.until !== undefined) searchOptions.until = options.until;
   if (options.preferClosestTo !== undefined)