@akiojin/gwt 4.12.1 → 6.0.0

package/src/services/codingAgentResolver.ts

@@ -1,375 +0,0 @@
-import { execa } from "execa";
-import { platform } from "os";
-import { getCodingAgentById } from "../config/tools.js";
-import { CLAUDE_CODE_TOOL } from "../config/builtin-coding-agents.js";
-import {
-  CODEX_DEFAULT_ARGS,
-  CLAUDE_PERMISSION_SKIP_ARGS,
-  shouldEnableCodexSkillsFlag,
-  withCodexSkillsFlag,
-} from "../shared/codingAgentConstants.js";
-import { prepareCodingAgentExecution } from "./codingAgentCommandResolver.js";
-import type { CodingAgentLaunchOptions } from "../types/tools.js";
-import { createLogger } from "../logging/logger.js";
-import { findCommand } from "../utils/command.js";
-
-const logger = createLogger({ category: "resolver" });
-
-const DETECTION_COMMAND = platform() === "win32" ? "where" : "which";
-const MIN_BUN_MAJOR = 1;
-
-export const CLAUDE_CLI_PACKAGE = "@anthropic-ai/claude-code@latest";
-export const CODEX_CLI_PACKAGE = "@openai/codex@latest";
-
-export type ResolverErrorCode =
-  | "COMMAND_NOT_FOUND"
-  | "BUNX_NOT_FOUND"
-  | "BUN_TOO_OLD"
-  | "CUSTOM_TOOL_NOT_FOUND";
-
-export interface ResolvedCommand {
-  command: string;
-  args: string[];
-  usesFallback: boolean;
-  env?: NodeJS.ProcessEnv;
-}
-
-export class CodingAgentResolutionError extends Error {
-  constructor(
-    public code: ResolverErrorCode,
-    message: string,
-    public hints?: string[],
-  ) {
-    super(message);
-    this.name = "CodingAgentResolutionError";
-  }
-}
-
-async function commandExists(command: string): Promise<boolean> {
-  try {
-    await execa(DETECTION_COMMAND, [command], { shell: true });
-    logger.debug({ command, exists: true }, "Command check");
-    return true;
-  } catch {
-    logger.debug({ command, exists: false }, "Command check");
-    return false;
-  }
-}
-
-/**
- * コマンドのフルパスを取得
- * node-ptyはシェルを経由しないため、フルパスが必要
- */
-async function resolveCommandPath(command: string): Promise<string | null> {
-  try {
-    const { stdout } = await execa(DETECTION_COMMAND, [command], {
-      shell: true,
-    });
-    const fullPath = stdout.trim().split("\n")[0];
-    logger.debug({ command, fullPath }, "Command path resolved");
-    return fullPath || null;
-  } catch {
-    logger.debug({ command, fullPath: null }, "Command path resolution failed");
-    return null;
-  }
-}
-
-let bunxCheckPromise: Promise<void> | null = null;
-
-async function ensureBunxAvailable(): Promise<void> {
-  if (!bunxCheckPromise) {
-    bunxCheckPromise = (async () => {
-      const bunxExists = await commandExists("bunx");
-      if (!bunxExists) {
-        throw new CodingAgentResolutionError(
-          "BUNX_NOT_FOUND",
-          "bunx command not found. Install Bun 1.0+ so bunx is available on PATH.",
-          [
-            "Install Bun: https://bun.sh/docs/installation",
-            "After installation, restart your terminal so bunx is on PATH.",
-          ],
-        );
-      }
-
-      try {
-        const { stdout } = await execa("bun", ["--version"]);
-        const version = stdout.trim();
-        logger.debug({ bunVersion: version }, "Bun version detected");
-        const major = parseInt(version.split(".")[0] ?? "0", 10);
-        if (!Number.isFinite(major) || major < MIN_BUN_MAJOR) {
-          throw new CodingAgentResolutionError(
-            "BUN_TOO_OLD",
-            `Detected Bun ${version}. Bun ${MIN_BUN_MAJOR}.0+ is required for bunx fallback execution.`,
-            [
-              "Upgrade Bun: curl -fsSL https://bun.sh/install | bash",
-              "Verify with 'bun --version' (needs >= 1.0)",
-            ],
-          );
-        }
-      } catch (error: unknown) {
-        if (error instanceof CodingAgentResolutionError) {
-          throw error;
-        }
-        const err = error as NodeJS.ErrnoException;
-        if (err?.code === "ENOENT") {
-          throw new CodingAgentResolutionError(
-            "BUNX_NOT_FOUND",
-            "bun command not found while verifying bunx. Install Bun 1.0+ and ensure it is on PATH.",
-            [
-              "Install Bun: https://bun.sh/docs/installation",
-              "After installation, run 'bun --version' to confirm.",
-            ],
-          );
-        }
-        throw new CodingAgentResolutionError(
-          "BUN_TOO_OLD",
-          `Failed to verify Bun version: ${err?.message ?? "unknown error"}`,
-        );
-      }
-    })();
-  }
-
-  try {
-    await bunxCheckPromise;
-  } catch (error) {
-    bunxCheckPromise = null;
-    throw error;
-  }
-}
-
-export interface ClaudeCommandOptions {
-  mode?: "normal" | "continue" | "resume";
-  skipPermissions?: boolean;
-  extraArgs?: string[];
-  sessionId?: string | null;
-}
-
-export function buildClaudeArgs(options: ClaudeCommandOptions = {}): string[] {
-  const args: string[] = [];
-  const sessionId =
-    options.sessionId && options.sessionId.trim().length > 0
-      ? options.sessionId.trim()
-      : null;
-
-  switch (options.mode) {
-    case "continue":
-      if (sessionId) {
-        args.push("--resume", sessionId);
-      } else {
-        args.push("-c");
-      }
-      break;
-    case "resume":
-      if (sessionId) {
-        args.push("--resume", sessionId);
-      } else {
-        args.push("-r");
-      }
-      break;
-    default:
-      break;
-  }
-
-  if (options.skipPermissions) {
-    args.push(...CLAUDE_PERMISSION_SKIP_ARGS);
-  }
-
-  if (options.extraArgs?.length) {
-    args.push(...options.extraArgs);
-  }
-
-  return args;
-}
-
-export async function resolveClaudeCommand(
-  options: ClaudeCommandOptions = {},
-): Promise<ResolvedCommand> {
-  const args = buildClaudeArgs(options);
-  const envOverrides = CLAUDE_CODE_TOOL.env
-    ? { env: { ...CLAUDE_CODE_TOOL.env } as NodeJS.ProcessEnv }
-    : {};
-
-  // フルパスを取得（node-ptyはシェルを経由しないため必要）
-  const claudePath = await resolveCommandPath("claude");
-  if (claudePath) {
-    logger.info(
-      { command: claudePath, usesFallback: false },
-      "Claude command resolved",
-    );
-    return {
-      command: claudePath,
-      args,
-      usesFallback: false,
-      ...envOverrides,
-    };
-  }
-
-  // bunxへフォールバック
-  const bunxPath = await resolveCommandPath("bunx");
-  if (!bunxPath) {
-    await ensureBunxAvailable(); // エラーをスローする
-  }
-
-  logger.info(
-    { command: bunxPath ?? "bunx", usesFallback: true },
-    "Claude command resolved (fallback)",
-  );
-  return {
-    command: bunxPath ?? "bunx",
-    args: [CLAUDE_CLI_PACKAGE, ...args],
-    usesFallback: true,
-    ...envOverrides,
-  };
-}
-
-export interface CodexCommandOptions {
-  mode?: "normal" | "continue" | "resume";
-  bypassApprovals?: boolean;
-  extraArgs?: string[];
-  sessionId?: string | null;
-}
-
-export function buildCodexArgs(options: CodexCommandOptions = {}): string[] {
-  const args: string[] = [];
-  const sessionId =
-    options.sessionId && options.sessionId.trim().length > 0
-      ? options.sessionId.trim()
-      : null;
-
-  switch (options.mode) {
-    case "continue":
-      if (sessionId) {
-        args.push("resume", sessionId);
-      } else {
-        args.push("resume", "--last");
-      }
-      break;
-    case "resume":
-      if (sessionId) {
-        args.push("resume", sessionId);
-      } else {
-        args.push("resume");
-      }
-      break;
-    default:
-      break;
-  }
-
-  if (options.bypassApprovals) {
-    args.push("--yolo");
-  }
-
-  if (options.extraArgs?.length) {
-    args.push(...options.extraArgs);
-  }
-
-  args.push(...CODEX_DEFAULT_ARGS);
-  return args;
-}
-
-export async function resolveCodexCommand(
-  options: CodexCommandOptions = {},
-): Promise<ResolvedCommand> {
-  const codexLookup = await findCommand("codex");
-  const baseArgs = buildCodexArgs(options);
-  const args = withCodexSkillsFlag(
-    baseArgs,
-    shouldEnableCodexSkillsFlag(codexLookup.version),
-  );
-
-  // フルパスを取得（node-ptyはシェルを経由しないため必要）
-  if (codexLookup.source === "installed" && codexLookup.path) {
-    logger.info(
-      { command: codexLookup.path, usesFallback: false },
-      "Codex command resolved",
-    );
-    return {
-      command: codexLookup.path,
-      args,
-      usesFallback: false,
-    };
-  }
-
-  // bunxへフォールバック
-  const bunxPath = await resolveCommandPath("bunx");
-  if (!bunxPath) {
-    await ensureBunxAvailable(); // エラーをスローする
-  }
-
-  logger.info(
-    { command: bunxPath ?? "bunx", usesFallback: true },
-    "Codex command resolved (fallback)",
-  );
-  return {
-    command: bunxPath ?? "bunx",
-    args: [CODEX_CLI_PACKAGE, ...args],
-    usesFallback: true,
-  };
-}
-
-export interface CodingAgentCommandOptions extends CodingAgentLaunchOptions {
-  agentId: string;
-}
-
-export async function resolveCodingAgentCommand(
-  options: CodingAgentCommandOptions,
-): Promise<ResolvedCommand> {
-  const agent = await getCodingAgentById(options.agentId);
-  if (!agent) {
-    logger.error({ agentId: options.agentId }, "Coding agent not found");
-    throw new CodingAgentResolutionError(
-      "CUSTOM_TOOL_NOT_FOUND",
-      `Coding agent not found: ${options.agentId}`,
-      [
-        "Update ~/.gwt/tools.json to include this ID",
-        "Reload the Web UI after editing the agents list",
-      ],
-    );
-  }
-
-  const execution = await prepareCodingAgentExecution(agent, options);
-
-  logger.info(
-    { agentId: options.agentId, command: execution.command },
-    "Coding agent command resolved",
-  );
-
-  return {
-    command: execution.command,
-    args: execution.args,
-    usesFallback: agent.type === "bunx",
-    ...(execution.env ? { env: execution.env } : {}),
-  };
-}
-
-export async function isClaudeCodeAvailable(): Promise<boolean> {
-  try {
-    await resolveClaudeCommand();
-    return true;
-  } catch (error) {
-    if (error instanceof CodingAgentResolutionError) {
-      return false;
-    }
-    return false;
-  }
-}
-
-export async function isCodexAvailable(): Promise<boolean> {
-  try {
-    await resolveCodexCommand();
-    return true;
-  } catch (error) {
-    if (error instanceof CodingAgentResolutionError) {
-      return false;
-    }
-    return false;
-  }
-}
-
-/**
- * Test-helper: resets cached bunx availability check.
- * Not exported in type definitions to avoid production usage.
- */
-export function __resetBunxCacheForTests(): void {
-  bunxCheckPromise = null;
-}

package/src/services/dependency-installer.ts

@@ -1,192 +0,0 @@
-import path from "node:path";
-import { access } from "node:fs/promises";
-import { execa } from "execa";
-
-export type PackageManager = "bun" | "pnpm" | "npm";
-
-interface PackageManagerCandidate {
-  manager: PackageManager;
-  lockfile: string;
-  command: [string, ...string[]];
-}
-
-interface DetectedPackageManager {
-  manager: PackageManager;
-  lockfile: string;
-  command: [string, ...string[]];
-}
-
-export type DependencySkipReason =
-  | "missing-lockfile"
-  | "missing-binary"
-  | "install-failed"
-  | "lockfile-access-error"
-  | "unknown-error";
-
-export type DependencyInstallResult =
-  | {
-      skipped: false;
-      manager: PackageManager;
-      lockfile: string;
-    }
-  | {
-      skipped: true;
-      manager: PackageManager | null;
-      lockfile: string | null;
-      reason: DependencySkipReason;
-      message?: string;
-    };
-
-export class DependencyInstallError extends Error {
-  constructor(
-    message: string,
-    public cause?: unknown,
-  ) {
-    super(message);
-    this.name = "DependencyInstallError";
-  }
-}
-
-const INSTALL_CANDIDATES: PackageManagerCandidate[] = [
-  {
-    manager: "bun",
-    lockfile: "bun.lock",
-    command: ["bun", "install", "--frozen-lockfile"],
-  },
-  {
-    manager: "pnpm",
-    lockfile: "pnpm-lock.yaml",
-    command: ["pnpm", "install", "--frozen-lockfile"],
-  },
-  {
-    manager: "npm",
-    lockfile: "package-lock.json",
-    command: ["npm", "ci"],
-  },
-  {
-    manager: "npm",
-    lockfile: "package.json",
-    command: ["npm", "install"],
-  },
-];
-
-async function fileExists(targetPath: string): Promise<boolean> {
-  try {
-    await access(targetPath);
-    return true;
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException)?.code;
-    if (code === "ENOENT") {
-      return false;
-    }
-    throw new DependencyInstallError(
-      `Lockfile access failed: ${targetPath} (${code ?? "unknown"})`,
-      error,
-    );
-  }
-}
-
-export async function detectPackageManager(
-  worktreePath: string,
-): Promise<DetectedPackageManager | null> {
-  const normalized = path.resolve(worktreePath);
-
-  for (const candidate of INSTALL_CANDIDATES) {
-    const fullPath = path.join(normalized, candidate.lockfile);
-    if (await fileExists(fullPath)) {
-      return {
-        manager: candidate.manager,
-        lockfile: fullPath,
-        command: candidate.command,
-      };
-    }
-  }
-
-  return null;
-}
-
-export async function installDependenciesForWorktree(
-  worktreePath: string,
-): Promise<DependencyInstallResult> {
-  let detection: DetectedPackageManager | null = null;
-
-  try {
-    detection = await detectPackageManager(worktreePath);
-  } catch (error) {
-    if (error instanceof DependencyInstallError) {
-      return {
-        skipped: true,
-        manager: null,
-        lockfile: null,
-        reason: "lockfile-access-error",
-        message: error.message,
-      };
-    }
-
-    return {
-      skipped: true,
-      manager: null,
-      lockfile: null,
-      reason: "unknown-error",
-      message: error instanceof Error ? error.message : String(error),
-    };
-  }
-
-  if (!detection) {
-    return {
-      skipped: true,
-      manager: null,
-      lockfile: null,
-      reason: "missing-lockfile",
-    };
-  }
-
-  const [binary, ...args] = detection.command;
-
-  try {
-    await execa(binary, args, {
-      cwd: worktreePath,
-      stdout: "inherit",
-      stderr: "inherit",
-    });
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException)?.code;
-
-    if (code === "ENOENT") {
-      console.warn(
-        `Package manager '${binary}' was not found; skipping automatic install.`,
-      );
-      return {
-        skipped: true,
-        manager: detection.manager,
-        lockfile: detection.lockfile,
-        reason: "missing-binary",
-      };
-    }
-
-    const messageParts = [
-      `Dependency installation failed (${detection.manager}).`,
-      `Command: ${binary} ${args.join(" ")}`,
-    ];
-
-    const stderr = (error as { stderr?: string })?.stderr;
-    if (stderr) {
-      messageParts.push(stderr.trim());
-    }
-    const failureMessage = messageParts.join("\n");
-
-    return {
-      skipped: true,
-      manager: detection.manager,
-      lockfile: detection.lockfile,
-      reason: "install-failed",
-      message: failureMessage,
-    };
-  }
-
-  return {
-    skipped: false,
-    manager: detection.manager,
-    lockfile: detection.lockfile,
-  };
-}

package/src/services/git.service.ts

@@ -1,115 +0,0 @@
-import { GitRepository } from "../repositories/git.repository.js";
-import { BranchInfo } from "../cli/ui/types.js";
-
-/**
- * Git操作のビジネスロジックを管理するService
- */
-export class GitService {
-  constructor(private readonly repository: GitRepository) {}
-
-  async isValidRepository(): Promise<boolean> {
-    return await this.repository.isRepository();
-  }
-
-  async getAllBranches(): Promise<BranchInfo[]> {
-    const [localBranches, remoteBranches, currentBranch] = await Promise.all([
-      this.getLocalBranchesInfo(),
-      this.getRemoteBranchesInfo(),
-      this.repository.getCurrentBranch(),
-    ]);
-
-    // 現在のブランチ情報を設定
-    if (currentBranch) {
-      localBranches.forEach((branch) => {
-        if (branch.name === currentBranch) {
-          branch.isCurrent = true;
-        }
-      });
-    }
-
-    return [...localBranches, ...remoteBranches];
-  }
-
-  private async getLocalBranchesInfo(): Promise<BranchInfo[]> {
-    const branches = await this.repository.getBranches({ remote: false });
-    return branches.map((name) => ({
-      name,
-      type: "local" as const,
-      branchType: this.getBranchType(name),
-      isCurrent: false,
-    }));
-  }
-
-  private async getRemoteBranchesInfo(): Promise<BranchInfo[]> {
-    const branches = await this.repository.getBranches({ remote: true });
-    return branches.map((name) => ({
-      name,
-      type: "remote" as const,
-      branchType: this.getBranchType(name.replace(/^origin\//, "")),
-      isCurrent: false,
-    }));
-  }
-
-  private getBranchType(branchName: string): BranchInfo["branchType"] {
-    if (branchName.startsWith("feature/")) return "feature";
-    if (branchName.startsWith("bugfix/") || branchName.startsWith("bug/"))
-      return "bugfix";
-    if (branchName.startsWith("hotfix/")) return "hotfix";
-    if (branchName.startsWith("release/")) return "release";
-    if (branchName === "main" || branchName === "master") return "main";
-    if (branchName === "develop" || branchName === "dev") return "develop";
-    return "other";
-  }
-
-  async createFeatureBranch(
-    taskName: string,
-    baseBranch: string,
-  ): Promise<string> {
-    const branchName = `feature/${taskName}`;
-    await this.repository.createBranch(branchName, baseBranch);
-    return branchName;
-  }
-
-  async deleteBranch(
-    branchName: string,
-    options?: {
-      force?: boolean;
-      remote?: boolean;
-    },
-  ): Promise<void> {
-    if (options?.remote) {
-      await this.repository.deleteRemoteBranch(branchName);
-    } else {
-      await this.repository.deleteBranch(branchName, options?.force);
-    }
-  }
-
-  async hasUncommittedChanges(workdir?: string): Promise<boolean> {
-    return await this.repository.hasChanges(workdir);
-  }
-
-  async getChangedFilesCount(workdir?: string): Promise<number> {
-    return await this.repository.getChangedFilesCount(workdir);
-  }
-
-  async commitAllChanges(message: string): Promise<void> {
-    await this.repository.add(".");
-    await this.repository.commit(message, { all: true });
-  }
-
-  async pushChanges(branchName: string): Promise<void> {
-    await this.repository.push({ upstream: true, branch: branchName });
-  }
-
-  async stashChanges(message?: string): Promise<void> {
-    await this.repository.stash(message);
-  }
-
-  async discardAllChanges(): Promise<void> {
-    await this.repository.checkout(".");
-  }
-
-  async fetchRemoteUpdates(): Promise<void> {
-    await this.repository.fetch({ all: true, prune: true });
-  }
-}