@akiojin/gwt 4.12.1 → 6.0.0

package/src/codex.ts

@@ -1,445 +0,0 @@
-import { execa } from "execa";
-import chalk from "chalk";
-import { platform } from "os";
-import { existsSync } from "fs";
-import {
-  createChildStdio,
-  getTerminalStreams,
-  resetTerminalModes,
-  writeTerminalLine,
-} from "./utils/terminal.js";
-import {
-  findLatestCodexSession,
-  waitForCodexSessionId,
-} from "./utils/session.js";
-import { findCommand } from "./utils/command.js";
-import {
-  runAgentWithPty,
-  shouldCaptureAgentOutput,
-} from "./logging/agentOutput.js";
-import { createLogger } from "./logging/logger.js";
-import {
-  shouldEnableCodexSkillsFlag,
-  withCodexSkillsFlag,
-} from "./shared/codingAgentConstants.js";
-
-const CODEX_CLI_PACKAGE = "@openai/codex";
-const logger = createLogger({ category: "codex" });
-
-/**
- * Reasoning effort levels supported by Codex CLI.
- */
-export type CodexReasoningEffort = "low" | "medium" | "high" | "xhigh";
-
-/**
- * Default Codex model used when no override is provided.
- */
-export const DEFAULT_CODEX_MODEL = "gpt-5.2-codex";
-
-/**
- * Default reasoning effort used when no override is provided.
- */
-export const DEFAULT_CODEX_REASONING_EFFORT: CodexReasoningEffort = "high";
-
-/**
- * Builds the default argument list for Codex CLI launch.
- *
- * @param model - Model name to pass via `--model`
- * @param reasoningEffort - Reasoning effort to pass via config
- */
-export const buildDefaultCodexArgs = (
-  model: string = DEFAULT_CODEX_MODEL,
-  reasoningEffort: CodexReasoningEffort = DEFAULT_CODEX_REASONING_EFFORT,
-): string[] => [
-  "--enable",
-  "web_search_request",
-  `--model=${model}`,
-  "--sandbox",
-  "workspace-write",
-  "-c",
-  `model_reasoning_effort=${reasoningEffort}`,
-  "-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",
-];
-
-/**
- * Error wrapper used by `launchCodexCLI` to preserve the original failure
- * while providing a user-friendly message.
- */
-export class CodexError extends Error {
-  constructor(
-    message: string,
-    public cause?: unknown,
-  ) {
-    super(message);
-    this.name = "CodexError";
-  }
-}
-
-/**
- * Launches Codex CLI in the given worktree path.
- *
- * This function resets terminal modes before and after the child process and
- * tries to detect a session id after launch (when supported).
- *
- * @param worktreePath - Worktree directory to run Codex CLI in
- * @param options - Launch options (mode/session/model/reasoning/env)
- * @returns Captured session id when available
- */
-export async function launchCodexCLI(
-  worktreePath: string,
-  options: {
-    mode?: "normal" | "continue" | "resume";
-    extraArgs?: string[];
-    bypassApprovals?: boolean;
-    envOverrides?: Record<string, string>;
-    model?: string;
-    reasoningEffort?: CodexReasoningEffort;
-    sessionId?: string | null;
-    branch?: string | null;
-    version?: string | null;
-  } = {},
-): Promise<{ sessionId?: string | null }> {
-  const terminal = getTerminalStreams();
-  const startedAt = Date.now();
-
-  try {
-    if (!existsSync(worktreePath)) {
-      throw new Error(`Worktree path does not exist: ${worktreePath}`);
-    }
-
-    writeTerminalLine(chalk.blue("🚀 Launching Codex CLI..."));
-    writeTerminalLine(chalk.gray(`   Working directory: ${worktreePath}`));
-
-    const args: string[] = [];
-    const model = options.model ?? DEFAULT_CODEX_MODEL;
-    const reasoningEffort =
-      options.reasoningEffort ?? DEFAULT_CODEX_REASONING_EFFORT;
-
-    writeTerminalLine(chalk.green(`   🎯 Model: ${model}`));
-    writeTerminalLine(chalk.green(`   🧠 Reasoning: ${reasoningEffort}`));
-
-    const resumeSessionId =
-      options.sessionId && options.sessionId.trim().length > 0
-        ? options.sessionId.trim()
-        : null;
-    const usedExplicitSessionId =
-      Boolean(resumeSessionId) &&
-      (options.mode === "continue" || options.mode === "resume");
-
-    switch (options.mode) {
-      case "continue":
-        if (resumeSessionId) {
-          args.push("resume", resumeSessionId);
-          writeTerminalLine(
-            chalk.cyan(
-              `   ⏭️  Resuming specific Codex session: ${resumeSessionId}`,
-            ),
-          );
-        } else {
-          args.push("resume", "--last");
-          writeTerminalLine(chalk.cyan("   ⏭️  Resuming last Codex session"));
-        }
-        break;
-      case "resume":
-        if (resumeSessionId) {
-          args.push("resume", resumeSessionId);
-          writeTerminalLine(
-            chalk.cyan(`   🔄 Resuming Codex session: ${resumeSessionId}`),
-          );
-        } else {
-          args.push("resume");
-          writeTerminalLine(chalk.cyan("   🔄 Resume command"));
-        }
-        break;
-      case "normal":
-      default:
-        writeTerminalLine(chalk.green("   ✨ Starting new session"));
-        break;
-    }
-
-    if (options.bypassApprovals) {
-      args.push("--yolo");
-      writeTerminalLine(chalk.yellow("   ⚠️  Bypassing approvals and sandbox"));
-    }
-
-    if (options.extraArgs && options.extraArgs.length > 0) {
-      args.push(...options.extraArgs);
-    }
-
-    const requestedVersion = options.version ?? "latest";
-    const codexLookup = await findCommand("codex");
-    const skillsFlagVersion =
-      requestedVersion === "installed"
-        ? (codexLookup.version ?? null)
-        : requestedVersion === "latest"
-          ? null
-          : requestedVersion;
-    const codexArgs = withCodexSkillsFlag(
-      buildDefaultCodexArgs(model, reasoningEffort),
-      shouldEnableCodexSkillsFlag(skillsFlagVersion),
-    );
-
-    args.push(...codexArgs);
-
-    writeTerminalLine(chalk.gray(`   📋 Args: ${args.join(" ")}`));
-
-    terminal.exitRawMode();
-    resetTerminalModes(terminal.stdout);
-
-    const env = Object.fromEntries(
-      Object.entries({
-        ...process.env,
-        ...(options.envOverrides ?? {}),
-      }).filter(
-        (entry): entry is [string, string] => typeof entry[1] === "string",
-      ),
-    );
-    const captureOutput = shouldCaptureAgentOutput(env);
-    const childStdio = captureOutput ? null : createChildStdio();
-
-    // codexLookup is used to decide local vs bunx execution
-
-    const execChild = async (child: Promise<unknown>) => {
-      try {
-        const result = (await child) as {
-          exitCode?: number | null;
-          signal?: string | null;
-        };
-        return {
-          exitCode: result.exitCode ?? 0,
-          signal: result.signal ?? null,
-        };
-      } catch (execError: unknown) {
-        // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
-        const signal = (execError as { signal?: unknown })?.signal;
-        const exitCode =
-          (execError as { exitCode?: number | null })?.exitCode ?? null;
-        if (signal === "SIGINT" || signal === "SIGTERM") {
-          return { exitCode, signal };
-        }
-        throw execError;
-      }
-    };
-    // Treat SIGINT (2), SIGTERM (15) as normal exit signals (user interrupts)
-    const isNormalExitSignal = (signal?: number | null) =>
-      signal === 2 || signal === 15;
-    const runCommand = async (command: string, commandArgs: string[]) => {
-      const runStartedAt = Date.now();
-      if (captureOutput) {
-        const result = await runAgentWithPty({
-          command,
-          args: commandArgs,
-          cwd: worktreePath,
-          env,
-          agentId: "codex-cli",
-        });
-        const durationMs = Date.now() - runStartedAt;
-        const exitCode = result.exitCode ?? null;
-        const signal = result.signal ?? null;
-        const signalIsNormal = isNormalExitSignal(signal);
-        const hasError =
-          (!signalIsNormal && signal !== null && signal !== undefined) ||
-          (exitCode !== null && exitCode !== 0);
-        if (hasError) {
-          logger.error({ exitCode, signal, durationMs }, "Codex CLI exited");
-        } else {
-          logger.info({ exitCode, signal, durationMs }, "Codex CLI exited");
-        }
-        if (signalIsNormal) {
-          return;
-        }
-        if (signal !== null && signal !== undefined) {
-          throw new Error(`Codex CLI terminated by signal ${signal}`);
-        }
-        if (exitCode !== null && exitCode !== 0) {
-          throw new Error(
-            `Codex CLI exited with code ${exitCode ?? "unknown"}`,
-          );
-        }
-        return;
-      }
-
-      if (!childStdio) {
-        return;
-      }
-
-      try {
-        const child = execa(command, commandArgs, {
-          cwd: worktreePath,
-          stdin: childStdio.stdin,
-          stdout: childStdio.stdout,
-          stderr: childStdio.stderr,
-          env,
-        });
-        const result = await execChild(child);
-        const durationMs = Date.now() - runStartedAt;
-        logger.info(
-          {
-            exitCode: result.exitCode ?? null,
-            signal: result.signal,
-            durationMs,
-          },
-          "Codex CLI exited",
-        );
-      } catch (execError: unknown) {
-        const durationMs = Date.now() - runStartedAt;
-        const exitCode =
-          (execError as { exitCode?: number | null })?.exitCode ?? null;
-        const signal =
-          (execError as { signal?: string | null })?.signal ?? null;
-        logger.error({ exitCode, signal, durationMs }, "Codex CLI failed");
-        throw execError;
-      }
-    };
-
-    // Determine execution strategy based on version selection
-    // FR-063b: "installed" option only appears when local command exists
-    let selectedVersion = requestedVersion;
-
-    if (requestedVersion === "installed" && !codexLookup.path) {
-      writeTerminalLine(
-        chalk.yellow(
-          "   ⚠️  Installed codex command not found. Falling back to latest.",
-        ),
-      );
-      selectedVersion = "latest";
-    }
-
-    // Log version information (FR-072)
-    if (selectedVersion === "installed") {
-      writeTerminalLine(chalk.green(`   📦 Version: installed`));
-    } else {
-      writeTerminalLine(chalk.green(`   📦 Version: @${selectedVersion}`));
-    }
-
-    try {
-      if (selectedVersion === "installed" && codexLookup.path) {
-        // FR-066: Use locally installed command when "installed" is selected
-        // FR-063b guarantees local command exists when this option is shown
-        writeTerminalLine(
-          chalk.green("   ✨ Using locally installed codex command"),
-        );
-        await runCommand(codexLookup.path, args);
-      } else {
-        // FR-067, FR-068: Use bunx with version suffix for latest/specific versions
-        const packageWithVersion = `${CODEX_CLI_PACKAGE}@${selectedVersion}`;
-        writeTerminalLine(chalk.cyan(`   🔄 Using bunx ${packageWithVersion}`));
-
-        await runCommand("bunx", [packageWithVersion, ...args]);
-      }
-    } finally {
-      childStdio?.cleanup();
-    }
-
-    // File-based session detection only - no stdout capture
-    // Use only file inspection with a short wait to avoid hanging
-    let capturedSessionId: string | null = null;
-    const finishedAt = Date.now();
-    try {
-      const latest = await findLatestCodexSession({
-        since: startedAt,
-        until: finishedAt + 30_000,
-        preferClosestTo: finishedAt,
-        windowMs: 10 * 60 * 1000,
-        cwd: worktreePath,
-        branch: options.branch ?? null,
-        worktrees: options.branch
-          ? [{ path: worktreePath, branch: options.branch }]
-          : null,
-      });
-      const detectedSessionId = latest?.id ?? null;
-      // When we explicitly resumed a specific session, keep that ID as the source of truth.
-      capturedSessionId = usedExplicitSessionId
-        ? resumeSessionId
-        : detectedSessionId;
-    } catch {
-      capturedSessionId = usedExplicitSessionId ? resumeSessionId : null;
-    }
-    const shouldSkipWait =
-      typeof process !== "undefined" &&
-      (process.env?.NODE_ENV === "test" || Boolean(process.env?.VITEST));
-    if (!capturedSessionId && !shouldSkipWait) {
-      capturedSessionId = await waitForCodexSessionId({
-        startedAt,
-        timeoutMs: 15_000,
-        pollIntervalMs: 1_000,
-        cwd: worktreePath,
-      });
-    }
-
-    if (capturedSessionId) {
-      writeTerminalLine(chalk.cyan(`\n   🆔 Session ID: ${capturedSessionId}`));
-      writeTerminalLine(
-        chalk.gray(`   Resume command: codex resume ${capturedSessionId}`),
-      );
-    } else {
-      writeTerminalLine(
-        chalk.yellow(
-          "\n   ℹ️  Could not determine Codex session ID automatically.",
-        ),
-      );
-    }
-
-    return capturedSessionId ? { sessionId: capturedSessionId } : {};
-  } catch (error: unknown) {
-    const err = error as NodeJS.ErrnoException;
-    const details = error instanceof Error ? error.message : String(error);
-    const errorMessage =
-      err.code === "ENOENT"
-        ? "bunx command not found. Please ensure Bun is installed so Codex CLI can run via bunx."
-        : `Failed to launch Codex CLI: ${details || "Unknown error"}`;
-
-    if (platform() === "win32") {
-      writeTerminalLine(
-        chalk.red("\n💡 Windows troubleshooting tips:"),
-        "stderr",
-      );
-      writeTerminalLine(
-        chalk.yellow(
-          "   1. Confirm that Bun is installed and bunx is available",
-        ),
-        "stderr",
-      );
-      writeTerminalLine(
-        chalk.yellow(
-          '   2. Run "bunx @openai/codex@latest -- --help" to verify the setup',
-        ),
-        "stderr",
-      );
-      writeTerminalLine(
-        chalk.yellow("   3. Restart your terminal or IDE to refresh PATH"),
-        "stderr",
-      );
-    }
-
-    throw new CodexError(errorMessage, error);
-  } finally {
-    terminal.exitRawMode();
-    resetTerminalModes(terminal.stdout);
-  }
-}
-
-/**
- * Checks whether Codex CLI is available via `bunx` in the current environment.
- */
-export async function isCodexAvailable(): Promise<boolean> {
-  try {
-    await execa("bunx", [`${CODEX_CLI_PACKAGE}@latest`, "--help"]);
-    return true;
-  } catch (error: unknown) {
-    const err = error as NodeJS.ErrnoException;
-    if (err.code === "ENOENT") {
-      writeTerminalLine(chalk.yellow("\n⚠️  bunx command not found"), "stderr");
-    }
-    return false;
-  }
-}

package/src/config/__tests__/saveSession.test.ts

@@ -1,143 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdir, rm } from "fs/promises";
-import { join } from "path";
-import { tmpdir } from "os";
-import { saveSession, loadSession } from "../index.js";
-
-describe("saveSession", () => {
-  let testDir: string;
-  let testRepoRoot: string;
-
-  beforeEach(async () => {
-    // Create a unique temporary directory for each test
-    testDir = join(
-      tmpdir(),
-      `gwt-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    testRepoRoot = join(testDir, "test-repo");
-    await mkdir(testRepoRoot, { recursive: true });
-  });
-
-  afterEach(async () => {
-    // Clean up temporary directory
-    try {
-      await rm(testDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  it("should save toolVersion to session history", async () => {
-    // Arrange
-    const sessionData = {
-      lastWorktreePath: testRepoRoot,
-      lastBranch: "feature/test",
-      lastUsedTool: "claude-code",
-      toolLabel: "Claude Code",
-      mode: "normal" as const,
-      model: "opus",
-      reasoningLevel: "high",
-      skipPermissions: false,
-      toolVersion: "2.1.1",
-      timestamp: Date.now(),
-      repositoryRoot: testRepoRoot,
-    };
-
-    // Act
-    await saveSession(sessionData);
-    const loaded = await loadSession(testRepoRoot);
-
-    // Assert
-    expect(loaded).not.toBeNull();
-    expect(loaded?.history).toHaveLength(1);
-    expect(loaded?.history?.[0]?.toolVersion).toBe("2.1.1");
-  });
-
-  it("should save latest toolVersion when not provided", async () => {
-    // Arrange
-    const sessionData = {
-      lastWorktreePath: testRepoRoot,
-      lastBranch: "feature/test",
-      lastUsedTool: "claude-code",
-      toolLabel: "Claude Code",
-      mode: "normal" as const,
-      model: "opus",
-      timestamp: Date.now(),
-      repositoryRoot: testRepoRoot,
-    };
-
-    // Act
-    await saveSession(sessionData);
-    const loaded = await loadSession(testRepoRoot);
-
-    // Assert
-    expect(loaded).not.toBeNull();
-    expect(loaded?.history).toHaveLength(1);
-    expect(loaded?.history?.[0]?.toolVersion).toBe("latest");
-  });
-
-  it("should preserve toolVersion across multiple saves", async () => {
-    // Arrange - first save with version 1.0.0
-    await saveSession({
-      lastWorktreePath: testRepoRoot,
-      lastBranch: "feature/test",
-      lastUsedTool: "claude-code",
-      toolLabel: "Claude Code",
-      toolVersion: "1.0.0",
-      timestamp: Date.now() - 1000,
-      repositoryRoot: testRepoRoot,
-    });
-
-    // Act - second save with version 2.0.0
-    await saveSession({
-      lastWorktreePath: testRepoRoot,
-      lastBranch: "feature/test",
-      lastUsedTool: "claude-code",
-      toolLabel: "Claude Code",
-      toolVersion: "2.0.0",
-      timestamp: Date.now(),
-      repositoryRoot: testRepoRoot,
-    });
-
-    const loaded = await loadSession(testRepoRoot);
-
-    // Assert - should have 2 entries with different versions
-    expect(loaded?.history).toHaveLength(2);
-    // History is stored oldest first (newest at the end)
-    expect(loaded?.history?.[0]?.toolVersion).toBe("1.0.0");
-    expect(loaded?.history?.[1]?.toolVersion).toBe("2.0.0");
-  });
-
-  it("should not add to history when skipHistory is true", async () => {
-    // Arrange - first save
-    await saveSession({
-      lastWorktreePath: testRepoRoot,
-      lastBranch: "feature/test",
-      lastUsedTool: "claude-code",
-      toolLabel: "Claude Code",
-      toolVersion: "1.0.0",
-      timestamp: Date.now(),
-      repositoryRoot: testRepoRoot,
-    });
-
-    // Act - second save with skipHistory
-    await saveSession(
-      {
-        lastWorktreePath: testRepoRoot,
-        lastBranch: "feature/test",
-        lastUsedTool: "claude-code",
-        toolLabel: "Claude Code",
-        toolVersion: "2.0.0",
-        timestamp: Date.now(),
-        repositoryRoot: testRepoRoot,
-      },
-      { skipHistory: true },
-    );
-
-    const loaded = await loadSession(testRepoRoot);
-
-    // Assert - should still have only 1 entry
-    expect(loaded?.history).toHaveLength(1);
-    expect(loaded?.history?.[0]?.toolVersion).toBe("1.0.0");
-  });
-});

package/src/config/builtin-coding-agents.ts

@@ -1,87 +0,0 @@
-/**
- * ビルトインコーディングエージェント定義
- *
- * Claude Code、Codex、Gemini の CodingAgent 形式定義
- */
-
-import type { CodingAgent } from "../types/tools.js";
-import {
-  CLAUDE_PERMISSION_SKIP_ARGS,
-  CODEX_DEFAULT_ARGS,
-} from "../shared/codingAgentConstants.js";
-
-/**
- * Claude Code のビルトイン定義
- */
-export const CLAUDE_CODE_TOOL: CodingAgent = {
-  id: "claude-code",
-  displayName: "Claude Code",
-  type: "bunx",
-  command: "@anthropic-ai/claude-code",
-  modeArgs: {
-    normal: [],
-    continue: ["-c"],
-    resume: ["-r"],
-  },
-  permissionSkipArgs: Array.from(CLAUDE_PERMISSION_SKIP_ARGS),
-  env: {
-    ENABLE_LSP_TOOL: "true",
-  },
-};
-
-/**
- * Codex のビルトイン定義
- */
-export const CODEX_CLI_TOOL: CodingAgent = {
-  id: "codex-cli",
-  displayName: "Codex",
-  type: "bunx",
-  command: "@openai/codex",
-  defaultArgs: Array.from(CODEX_DEFAULT_ARGS),
-  modeArgs: {
-    normal: [],
-    continue: ["resume", "--last"],
-    resume: ["resume"],
-  },
-};
-
-/**
- * Gemini のビルトイン定義
- */
-export const GEMINI_CLI_TOOL: CodingAgent = {
-  id: "gemini-cli",
-  displayName: "Gemini",
-  type: "bunx",
-  command: "@google/gemini-cli",
-  modeArgs: {
-    normal: [],
-    continue: ["-r", "latest"],
-    resume: ["-r", "latest"],
-  },
-  permissionSkipArgs: ["-y"],
-};
-
-/**
- * OpenCode のビルトイン定義
- */
-export const OPENCODE_TOOL: CodingAgent = {
-  id: "opencode",
-  displayName: "OpenCode",
-  type: "bunx",
-  command: "opencode-ai",
-  modeArgs: {
-    normal: [],
-    continue: ["-c"],
-    resume: ["-s"],
-  },
-};
-
-/**
- * すべてのビルトインコーディングエージェント
- */
-export const BUILTIN_CODING_AGENTS: CodingAgent[] = [
-  CLAUDE_CODE_TOOL,
-  CODEX_CLI_TOOL,
-  GEMINI_CLI_TOOL,
-  OPENCODE_TOOL,
-];