@akiojin/gwt 4.12.1 → 5.1.0

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

@@ -1,151 +0,0 @@
-/**
- * OpenCode session parser
- *
- * Handles session detection for OpenCode.
- * Session files are stored in ~/.local/share/opencode/storage/session/[projectID]/[sessionID].json
- * Session JSON contains: id, projectID, directory (cwd), title, created, updated, etc.
- */
-
-import path from "node:path";
-import { homedir } from "node:os";
-
-import type { OpenCodeSessionInfo, SessionSearchOptions } from "../types.js";
-import {
-  collectFilesIterative,
-  matchesCwd,
-  resolveBranchFromCwd,
-  readSessionInfoFromFile,
-} from "../common.js";
-import { listAllWorktrees } from "../../../worktree.js";
-
-/**
- * Returns the OpenCode session directory
- * OpenCode stores sessions in: ~/.local/share/opencode/storage/session/[projectID]/[sessionID].json
- */
-function getOpenCodeSessionDir(): string {
-  return path.join(
-    homedir(),
-    ".local",
-    "share",
-    "opencode",
-    "storage",
-    "session",
-  );
-}
-
-/**
- * Finds the latest OpenCode session with optional time filtering and cwd matching.
- *
- * @param options - Search options including time filters and cwd matching
- * @returns Session info with ID and modification time, or null if not found
- */
-export async function findLatestOpenCodeSession(
-  options: SessionSearchOptions = {},
-): Promise<OpenCodeSessionInfo | null> {
-  // OpenCode stores sessions under ~/.local/share/opencode/storage/session/[projectID]/
-  const baseDir = getOpenCodeSessionDir();
-  const files = await collectFilesIterative(
-    baseDir,
-    (name) => name.endsWith(".json") || name.endsWith(".jsonl"),
-  );
-  if (!files.length) return null;
-
-  // Apply time filters
-  let pool = files;
-  const sinceVal = options.since;
-  if (sinceVal !== undefined) {
-    pool = pool.filter((f) => f.mtime >= sinceVal);
-  }
-  const untilVal = options.until;
-  if (untilVal !== undefined) {
-    pool = pool.filter((f) => f.mtime <= untilVal);
-  }
-  if (!pool.length) return null;
-
-  // Sort by preference or mtime
-  const ref = options.preferClosestTo;
-  const window = options.windowMs ?? 30 * 60 * 1000;
-  pool = pool.slice().sort((a, b) => {
-    if (typeof ref === "number") {
-      const da = Math.abs(a.mtime - ref);
-      const db = Math.abs(b.mtime - ref);
-      if (da === db) return b.mtime - a.mtime;
-      if (da <= window || db <= window) return da - db;
-    }
-    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;
-    const sessionCwd = info.cwd ?? null;
-
-    if (shouldCheckBranch) {
-      const resolvedBranch = resolveBranchFromCwd(sessionCwd, worktrees);
-      if (resolvedBranch !== branchFilter) {
-        continue;
-      }
-    }
-
-    if (shouldCheckCwd && options.cwd) {
-      if (!matchesCwd(sessionCwd, options.cwd)) {
-        continue;
-      }
-    }
-
-    return { id: info.id, mtime: file.mtime };
-  }
-
-  return null;
-}
-
-/**
- * Finds the latest OpenCode session ID.
- * @param cwd - The working directory to find sessions for (used as fallback if options.cwd not set)
- * @param options - Search options including time filters and cwd matching
- * @returns Session ID string or null if not found
- */
-export async function findLatestOpenCodeSessionId(
-  cwd: string,
-  options: SessionSearchOptions = {},
-): Promise<string | null> {
-  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)
-    searchOptions.preferClosestTo = options.preferClosestTo;
-  if (options.windowMs !== undefined) searchOptions.windowMs = options.windowMs;
-
-  const found = await findLatestOpenCodeSession(searchOptions);
-  return found?.id ?? null;
-}

package/src/utils/session/types.ts

@@ -1,51 +0,0 @@
-/**
- * Session types - common type definitions for session parsers
- */
-
-/**
- * Options for session search operations
- */
-export interface SessionSearchOptions {
-  /** Minimum mtime (ms since epoch) */
-  since?: number;
-  /** Maximum mtime (ms since epoch) */
-  until?: number;
-  /** Reference time for preferring closest match */
-  preferClosestTo?: number;
-  /** Time window for closest match (default: 30 minutes) */
-  windowMs?: number;
-  /** Working directory filter */
-  cwd?: string | null;
-  /** Branch name filter (resolved from session cwd via worktree paths) */
-  branch?: string | null;
-  /** Optional worktree list to avoid shelling out for branch mapping */
-  worktrees?: { path: string; branch: string }[] | null;
-}
-
-/**
- * Base session info with ID and modification time
- */
-export interface SessionInfo {
-  id: string;
-  mtime: number;
-}
-
-/**
- * Claude Code session info
- */
-export type ClaudeSessionInfo = SessionInfo;
-
-/**
- * Codex CLI session info
- */
-export type CodexSessionInfo = SessionInfo;
-
-/**
- * Gemini CLI session info
- */
-export type GeminiSessionInfo = SessionInfo;
-
-/**
- * OpenCode session info
- */
-export type OpenCodeSessionInfo = SessionInfo;

package/src/utils/session.ts

@@ -1,16 +0,0 @@
-/**
- * Session utilities - backward compatibility layer
- *
- * This file re-exports all session-related functions and types from the
- * modularized session directory structure. Existing imports from this file
- * will continue to work without modification.
- *
- * For new code, consider importing directly from:
- * - ./session/types.js - Type definitions
- * - ./session/common.js - Common utilities
- * - ./session/parsers/claude.js - Claude-specific functions
- * - ./session/parsers/codex.js - Codex-specific functions
- * - ./session/parsers/gemini.js - Gemini-specific functions
- */
-
-export * from "./session/index.js";

package/src/utils/spinner.ts

@@ -1,54 +0,0 @@
-const SPINNER_FRAMES = [
-  "⠋",
-  "⠙",
-  "⠹",
-  "⠸",
-  "⠼",
-  "⠴",
-  "⠦",
-  "⠧",
-  "⠇",
-  "⠏",
-] as const;
-const FRAME_INTERVAL_MS = 80;
-
-function isWritableStream(
-  stream: NodeJS.WriteStream | undefined,
-): stream is NodeJS.WriteStream {
-  return Boolean(stream && typeof stream.write === "function");
-}
-
-/**
- * CLI用の簡易スピナーを開始する。
- * 戻り値の関数を呼び出すとスピナーが停止して行をクリアします。
- */
-export function startSpinner(message: string): () => void {
-  const stream = process.stdout;
-
-  if (!isWritableStream(stream) || stream.isTTY === false) {
-    return () => {};
-  }
-
-  let frameIndex = 0;
-  let active = true;
-  const padding = " ".repeat(message.length + 2);
-
-  const render = () => {
-    if (!active) return;
-    const frame = SPINNER_FRAMES[frameIndex];
-    frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
-    stream.write(`\r${frame} ${message}`);
-  };
-
-  render();
-  const timer = setInterval(render, FRAME_INTERVAL_MS);
-
-  const stop = () => {
-    if (!active) return;
-    active = false;
-    clearInterval(timer);
-    stream.write(`\r${padding}\r`);
-  };
-
-  return stop;
-}

package/src/utils/terminal.ts

@@ -1,327 +0,0 @@
-import fs from "node:fs";
-import { platform } from "node:os";
-import { ReadStream, WriteStream } from "node:tty";
-
-/**
- * Terminal streams used by the CLI (stdin/stdout/stderr) and their raw-mode
- * teardown helper.
- *
- * When the current process is not a TTY, this may fall back to `/dev/tty` so
- * interactive child processes can still read/write correctly.
- */
-export interface TerminalStreams {
-  stdin: NodeJS.ReadStream;
-  stdout: NodeJS.WriteStream;
-  stderr: NodeJS.WriteStream;
-  stdinFd?: number;
-  stdoutFd?: number;
-  stderrFd?: number;
-  usingFallback: boolean;
-  exitRawMode: () => void;
-}
-
-const DEV_TTY_PATH = "/dev/tty";
-// 端末モードのリセット:
-// - ESC[?1l: application cursor keys (DECCKM) を無効化
-// - ESC>: keypad mode を normal/numeric に戻す
-// WSL2/Windowsの矢印キー入力が壊れるケースを抑止する。
-const TERMINAL_RESET_SEQUENCE = "\u001b[?1l\u001b>";
-
-let cachedStreams: TerminalStreams | null = null;
-
-/**
- * Stdio configuration for launching an interactive child process (via `execa`),
- * plus a cleanup hook to be called after the child exits.
- */
-export interface ChildStdio {
-  stdin: "inherit" | { file: string; append?: boolean };
-  stdout: "inherit" | { file: string; append?: boolean };
-  stderr: "inherit" | { file: string; append?: boolean };
-  cleanup: () => void;
-}
-
-const DEFAULT_ACK_MESSAGE =
-  "Review the error details, then press Enter to continue...";
-
-function isProcessTTY(): boolean {
-  return Boolean(
-    process.stdin.isTTY &&
-    process.stdout.isTTY &&
-    process.stderr.isTTY &&
-    typeof (process.stdin as NodeJS.ReadStream).setRawMode === "function",
-  );
-}
-
-function createTerminalStreams(): TerminalStreams {
-  if (isProcessTTY()) {
-    const exitRawMode = () => {
-      const stream = process.stdin as NodeJS.ReadStream;
-      if (typeof stream.setRawMode === "function") {
-        try {
-          stream.setRawMode(false);
-        } catch {
-          // Ignore errors when resetting raw mode.
-        }
-      }
-    };
-
-    return {
-      stdin: process.stdin,
-      stdout: process.stdout,
-      stderr: process.stderr,
-      usingFallback: false,
-      exitRawMode,
-    };
-  }
-
-  // Windows では /dev/tty が利用できないため、そのまま返す。
-  if (platform() === "win32") {
-    return {
-      stdin: process.stdin,
-      stdout: process.stdout,
-      stderr: process.stderr,
-      usingFallback: false,
-      exitRawMode: () => {
-        const stream = process.stdin as NodeJS.ReadStream;
-        if (typeof stream.setRawMode === "function") {
-          try {
-            stream.setRawMode(false);
-          } catch {
-            // Ignore errors when resetting raw mode.
-          }
-        }
-      },
-    };
-  }
-
-  try {
-    const fdIn = fs.openSync(DEV_TTY_PATH, "r");
-    const fdOut = fs.openSync(DEV_TTY_PATH, "w");
-    const fdErr = fs.openSync(DEV_TTY_PATH, "w");
-
-    const stdin = new ReadStream(fdIn);
-    const stdout = new WriteStream(fdOut);
-    const stderr = new WriteStream(fdErr);
-
-    const exitRawMode = () => {
-      if (typeof stdin.setRawMode === "function") {
-        try {
-          stdin.setRawMode(false);
-        } catch {
-          // Ignore errors when resetting raw mode.
-        }
-      }
-    };
-
-    const cleanup = () => {
-      exitRawMode();
-      try {
-        stdin.destroy();
-      } catch {
-        // Ignore stdin destroy errors.
-      }
-      try {
-        stdout.destroy();
-      } catch {
-        // Ignore stdout destroy errors.
-      }
-      try {
-        stderr.destroy();
-      } catch {
-        // Ignore stderr destroy errors.
-      }
-      try {
-        fs.closeSync(fdIn);
-      } catch {
-        // Ignore close errors.
-      }
-      try {
-        fs.closeSync(fdOut);
-      } catch {
-        // Ignore close errors.
-      }
-      try {
-        fs.closeSync(fdErr);
-      } catch {
-        // Ignore close errors.
-      }
-    };
-
-    process.once("exit", cleanup);
-
-    return {
-      stdin,
-      stdout,
-      stderr,
-      stdinFd: fdIn,
-      stdoutFd: fdOut,
-      stderrFd: fdErr,
-      usingFallback: true,
-      exitRawMode,
-    };
-  } catch {
-    const exitRawMode = () => {
-      const stream = process.stdin as NodeJS.ReadStream;
-      if (typeof stream.setRawMode === "function") {
-        try {
-          stream.setRawMode(false);
-        } catch {
-          // Ignore errors when resetting raw mode.
-        }
-      }
-    };
-
-    return {
-      stdin: process.stdin,
-      stdout: process.stdout,
-      stderr: process.stderr,
-      usingFallback: false,
-      exitRawMode,
-    };
-  }
-}
-
-/**
- * Returns cached terminal streams and falls back to `/dev/tty` when needed.
- */
-export function getTerminalStreams(): TerminalStreams {
-  if (!cachedStreams) {
-    cachedStreams = createTerminalStreams();
-  }
-  return cachedStreams;
-}
-
-/**
- * Best-effort terminal mode reset for interactive sessions.
- *
- * This writes a small ANSI sequence to restore cursor-key/keypad modes, which
- * helps prevent broken arrow-key behavior on some Windows/WSL2 terminals after
- * interactive CLIs exit.
- */
-export function resetTerminalModes(
-  stdout: NodeJS.WriteStream | undefined,
-): void {
-  if (!stdout || typeof stdout.write !== "function") {
-    return;
-  }
-  if (!("isTTY" in stdout) || !stdout.isTTY) {
-    return;
-  }
-  try {
-    stdout.write(TERMINAL_RESET_SEQUENCE);
-  } catch {
-    // Ignore terminal reset errors.
-  }
-}
-
-export function writeTerminalLine(
-  message: string,
-  stream: "stdout" | "stderr" = "stdout",
-): void {
-  const terminal = getTerminalStreams();
-  const target = stream === "stderr" ? terminal.stderr : terminal.stdout;
-  const payload = message.endsWith("\n") ? message : `${message}\n`;
-
-  if (target && typeof target.write === "function") {
-    try {
-      target.write(payload);
-      return;
-    } catch {
-      // Ignore write errors and fall back to console.
-    }
-  }
-
-  if (stream === "stderr") {
-    console.error(message);
-  } else {
-    console.log(message);
-  }
-}
-
-/**
- * Creates stdio settings for launching a child process.
- *
- * When terminal streams are backed by `/dev/tty`, forwards those file
- * descriptors to the child so it remains interactive.
- */
-export function createChildStdio(): ChildStdio {
-  const terminal = getTerminalStreams();
-
-  if (!terminal.usingFallback) {
-    return {
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-      cleanup: () => {},
-    };
-  }
-
-  return {
-    stdin: { file: DEV_TTY_PATH },
-    stdout: { file: DEV_TTY_PATH },
-    stderr: { file: DEV_TTY_PATH },
-    cleanup: () => {},
-  };
-}
-
-function isInteractive(stream: NodeJS.ReadStream): boolean {
-  return Boolean(stream.isTTY);
-}
-
-/**
- * Prints a message and waits for the user to press Enter when running in an
- * interactive terminal.
- *
- * Useful for pausing on errors while ensuring raw mode is disabled.
- */
-export async function waitForUserAcknowledgement(
-  message: string = DEFAULT_ACK_MESSAGE,
-): Promise<void> {
-  const terminal = getTerminalStreams();
-  const stdin = terminal.stdin as NodeJS.ReadStream;
-  const stdout = terminal.stdout as NodeJS.WriteStream;
-
-  if (!stdin || typeof stdin.on !== "function") {
-    return;
-  }
-
-  if (!isInteractive(stdin)) {
-    return;
-  }
-
-  terminal.exitRawMode();
-
-  await new Promise<void>((resolve) => {
-    let finished = false;
-
-    function cleanup(): void {
-      if (finished) {
-        return;
-      }
-      finished = true;
-      stdin.removeListener("data", onData);
-      if (typeof stdin.pause === "function") {
-        stdin.pause();
-      }
-    }
-
-    function onData(chunk: Buffer | string): void {
-      const data = typeof chunk === "string" ? chunk : chunk.toString("utf8");
-      if (data.includes("\n") || data.includes("\r")) {
-        cleanup();
-        resolve();
-      }
-    }
-
-    if (typeof stdout?.write === "function") {
-      stdout.write(`\n${message}\n`);
-    }
-
-    if (typeof stdin.resume === "function") {
-      stdin.resume();
-    }
-
-    stdin.on("data", onData);
-    process.once("exit", cleanup);
-  });
-}

package/src/utils/webui.ts

@@ -1,43 +0,0 @@
-import * as net from "node:net";
-
-export function resolveWebUiPort(
-  portEnv: string | undefined = process.env.PORT,
-  defaultPort = 3001,
-): number {
-  if (!portEnv) {
-    return defaultPort;
-  }
-
-  const port = parseInt(portEnv, 10);
-  if (Number.isNaN(port) || port <= 0 || port > 65535) {
-    return defaultPort;
-  }
-
-  return port;
-}
-
-/**
- * 指定ポートが使用中かどうかをチェック
- * @param port - チェックするポート番号
- * @returns 使用中ならtrue、利用可能ならfalse
- */
-export async function isPortInUse(port: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    const server = net.createServer();
-
-    server.once("error", (err: NodeJS.ErrnoException) => {
-      if (err.code === "EADDRINUSE") {
-        resolve(true);
-      } else {
-        // Other errors (EACCES, etc.) - treat as port not in use
-        resolve(false);
-      }
-    });
-
-    server.once("listening", () => {
-      server.close(() => resolve(false));
-    });
-
-    server.listen(port, "127.0.0.1");
-  });
-}

package/src/utils.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { getPackageVersion } from "./utils";
-import { readFile } from "fs/promises";
-import path from "node:path";
-
-describe("getPackageVersion", () => {
-  it("正常系: package.jsonが存在し、versionフィールドがある場合、バージョンを返す", async () => {
-    const version = await getPackageVersion();
-
-    // バージョンが取得できることを確認
-    expect(version).not.toBeNull();
-    expect(typeof version).toBe("string");
-
-    // セマンティックバージョニング形式かチェック（基本形式）
-    if (version) {
-      expect(version).toMatch(/^\d+\.\d+\.\d+/);
-    }
-  });
-
-  it("正常系: 取得したバージョンがpackage.jsonのversionと一致する", async () => {
-    const version = await getPackageVersion();
-
-    // package.jsonから直接読み取ってバージョンを確認
-    const packageJsonContent = await readFile(
-      path.resolve(process.cwd(), "package.json"),
-      "utf-8",
-    );
-    const packageJson = JSON.parse(packageJsonContent);
-
-    expect(version).toBe(packageJson.version);
-  });
-
-  it("正常系: プレリリースバージョンも正しく取得できる", async () => {
-    // 注: このテストは実際のpackage.jsonのバージョンがプレリリース形式の場合にパスする
-    // 現在のバージョンが通常バージョンの場合、このテストはスキップされる
-    const version = await getPackageVersion();
-
-    if (version && version.includes("-")) {
-      // プレリリース識別子を含むバージョン（例: "2.0.0-beta.1"）
-      expect(version).toMatch(/^\d+\.\d+\.\d+-[a-zA-Z0-9.-]+/);
-    }
-  });
-});