@akiojin/gwt 4.12.1 → 5.1.0

package/src/utils/npmRegistry.ts

@@ -1,249 +0,0 @@
-/**
- * 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

@@ -1,149 +0,0 @@
-import readline from "node:readline";
-import { getTerminalStreams } from "./terminal.js";
-
-type ReadlinePromptOptions<T> = {
-  fallback: T;
-  onAnswer: (answer: string) => T | undefined;
-  shouldSkip?: (terminal: ReturnType<typeof getTerminalStreams>) => boolean;
-};
-
-async function runReadlinePrompt<T>(
-  promptText: string,
-  { fallback, onAnswer, shouldSkip }: ReadlinePromptOptions<T>,
-): Promise<T> {
-  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 fallback;
-  }
-
-  if (shouldSkip?.(terminal)) {
-    return fallback;
-  }
-
-  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
-    }
-  }
-
-  return new Promise<T>((resolve) => {
-    const rl = readline.createInterface({ input: stdin, output: stdout });
-    let finished = false;
-
-    const cleanup = () => {
-      if (finished) {
-        return;
-      }
-      finished = true;
-      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(fallback);
-    };
-
-    rl.on("SIGINT", () => {
-      cleanup();
-      process.exit(0);
-    });
-
-    rl.question(`${promptText}\n`, (answer) => {
-      const result = onAnswer(answer);
-      cleanup();
-      resolve(result !== undefined ? result : fallback);
-    });
-
-    stdin.once("end", onEnd);
-    stdin.once("error", onEnd);
-  });
-}
-
-/**
- * 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> {
-  await runReadlinePrompt(promptMessage, {
-    fallback: undefined,
-    onAnswer: () => undefined,
-  });
-}
-
-/**
- * Prompts the user for a yes/no confirmation in the terminal.
- * Falls back to the default value on non-interactive stdin or fallback terminals.
- *
- * @param promptMessage - The message to display to the user
- * @param options - Configuration options
- * @param options.defaultValue - The default value when input is empty or stdin is non-interactive
- * @returns A promise that resolves to true for yes, false for no
- */
-export async function confirmYesNo(
-  promptMessage: string,
-  options: { defaultValue?: boolean } = {},
-): Promise<boolean> {
-  const fallback = options.defaultValue ?? false;
-
-  const suffix =
-    options.defaultValue === undefined
-      ? "[y/n]"
-      : options.defaultValue
-        ? "[Y/n]"
-        : "[y/N]";
-
-  const promptText = `${promptMessage} ${suffix}`.trim();
-
-  return runReadlinePrompt(promptText, {
-    fallback,
-    shouldSkip: (terminal) => terminal.usingFallback,
-    onAnswer: (answer) => {
-      const normalized = answer.trim().toLowerCase();
-      if (normalized === "y" || normalized === "yes") {
-        return true;
-      }
-      if (normalized === "n" || normalized === "no") {
-        return false;
-      }
-      if (normalized.length === 0 && options.defaultValue !== undefined) {
-        return options.defaultValue;
-      }
-      return undefined;
-    },
-  });
-}