@akiojin/gwt 4.12.1 → 5.1.0

package/src/launcher.ts

@@ -1,235 +0,0 @@
-/**
- * コーディングエージェント起動機能
- *
- * コーディングエージェントの起動処理を管理します。
- * 3つの実行タイプ（path, bunx, command）をサポートします。
- */
-
-import { execa } from "execa";
-import chalk from "chalk";
-import type { CodingAgent, CodingAgentLaunchOptions } from "./types/tools.js";
-import { createLogger } from "./logging/logger.js";
-import {
-  runAgentWithPty,
-  shouldCaptureAgentOutput,
-} from "./logging/agentOutput.js";
-import {
-  parsePackageCommand,
-  resolveVersionSuffix,
-} from "./utils/npmRegistry.js";
-import { writeTerminalLine } from "./utils/terminal.js";
-
-const logger = createLogger({ category: "launcher" });
-
-/**
- * コマンド名をPATH環境変数から解決
- *
- * Unix/Linuxではwhichコマンド、Windowsではwhereコマンドを使用して、
- * コマンド名を絶対パスに解決します。
- *
- * @param commandName - 解決するコマンド名
- * @returns コマンドの絶対パス
- * @throws コマンドが見つからない場合
- */
-export async function resolveCommand(commandName: string): Promise<string> {
-  const whichCommand = process.platform === "win32" ? "where" : "which";
-
-  try {
-    const result = await execa(whichCommand, [commandName]);
-
-    // where（Windows）は複数行返す可能性があるため、最初の行のみ取得
-    const resolvedPath = (result.stdout.split("\n")[0] ?? "").trim();
-
-    if (!resolvedPath) {
-      logger.error({ commandName }, "Command not found in PATH");
-      throw new Error(
-        `Command "${commandName}" not found in PATH.\n` +
-          `Please ensure the command is installed and available in your PATH environment variable.`,
-      );
-    }
-
-    logger.debug({ commandName, resolvedPath }, "Command resolved");
-    return resolvedPath;
-  } catch (error) {
-    // which/whereコマンド自体が失敗した場合
-    if (error instanceof Error) {
-      logger.error(
-        { commandName, error: error.message },
-        "Command resolution failed",
-      );
-      throw new Error(
-        `Failed to resolve command "${commandName}".\n` +
-          `Error: ${error.message}\n` +
-          `Please ensure the command is installed and available in your PATH environment variable.`,
-      );
-    }
-    throw error;
-  }
-}
-
-/**
- * 引数配列を構築
- *
- * defaultArgs + modeArgs[mode] + extraArgs の順で引数を結合します。
- * 未定義のフィールドは空配列として扱います。
- *
- * @param agent - コーディングエージェント定義
- * @param options - 起動オプション
- * @returns 結合された引数配列
- */
-function buildArgs(
-  agent: CodingAgent,
-  options: CodingAgentLaunchOptions,
-): string[] {
-  const args: string[] = [];
-
-  // 1. defaultArgs
-  if (agent.defaultArgs) {
-    args.push(...agent.defaultArgs);
-  }
-
-  // 2. modeArgs[mode]
-  const mode = options.mode || "normal";
-  const modeArgs = agent.modeArgs[mode];
-  if (modeArgs) {
-    args.push(...modeArgs);
-  }
-
-  // 3. extraArgs
-  if (options.extraArgs) {
-    args.push(...options.extraArgs);
-  }
-
-  logger.debug(
-    {
-      agentId: agent.id,
-      mode: options.mode ?? "normal",
-      argsCount: args.length,
-    },
-    "Args built",
-  );
-  return args;
-}
-
-/**
- * コーディングエージェントを起動
- *
- * エージェントの実行タイプ（path/bunx/command）に応じて適切な方法で起動します。
- * stdio: "inherit" で起動するため、エージェントの入出力は親プロセスに継承されます。
- *
- * @param agent - コーディングエージェント定義
- * @param options - 起動オプション
- * @throws 起動に失敗した場合
- */
-export async function launchCodingAgent(
-  agent: CodingAgent,
-  options: CodingAgentLaunchOptions = {},
-): Promise<void> {
-  const args = buildArgs(agent, options);
-
-  const env = {
-    ...process.env,
-    ...(options.sharedEnv ?? {}),
-    ...(agent.env ?? {}),
-  };
-  const workingDir = options.cwd ?? process.cwd();
-  const captureOutput = shouldCaptureAgentOutput(env);
-
-  // execa共通オプション（cwdがundefinedの場合は含めない）
-  const execaOptions = {
-    stdio: "inherit" as const,
-    ...(workingDir ? { cwd: workingDir } : {}),
-    env,
-  };
-
-  const runWithCapture = async (command: string, commandArgs: string[]) => {
-    const result = await runAgentWithPty({
-      command,
-      args: commandArgs,
-      cwd: workingDir,
-      env,
-      agentId: agent.id,
-    });
-    if (result.signal !== null && result.signal !== undefined) {
-      throw new Error(`Coding agent terminated by signal ${result.signal}`);
-    }
-    if (result.exitCode !== null && result.exitCode !== 0) {
-      throw new Error(`Coding agent exited with code ${result.exitCode}`);
-    }
-  };
-
-  logger.info(
-    {
-      agentId: agent.id,
-      agentType: agent.type,
-      command: agent.command,
-      mode: options.mode ?? "normal",
-    },
-    "Launching coding agent",
-  );
-
-  switch (agent.type) {
-    case "path": {
-      // 絶対パスで直接実行
-      if (captureOutput) {
-        await runWithCapture(agent.command, args);
-      } else {
-        await execa(agent.command, args, execaOptions);
-      }
-      logger.info({ agentId: agent.id }, "Coding agent completed (path)");
-      break;
-    }
-
-    case "bunx": {
-      // bunx経由でパッケージ実行
-      // バージョン指定がある場合はパッケージ名に付与
-      const { packageName, version: embeddedVersion } = parsePackageCommand(
-        agent.command,
-      );
-      const selectedVersion = options.version ?? embeddedVersion ?? "latest";
-      const versionSuffix = resolveVersionSuffix(selectedVersion);
-      const packageWithVersion = `${packageName}${versionSuffix}`;
-
-      // FR-072: Log version information
-      if (selectedVersion === "installed") {
-        writeTerminalLine(chalk.green(`   📦 Version: installed`));
-      } else {
-        writeTerminalLine(chalk.green(`   📦 Version: @${selectedVersion}`));
-      }
-      writeTerminalLine(chalk.cyan(`   🔄 Using bunx ${packageWithVersion}`));
-
-      // bunx [package@version] [args...]
-      const bunxCommand = captureOutput ? await resolveCommand("bunx") : "bunx";
-      if (captureOutput) {
-        await runWithCapture(bunxCommand, [packageWithVersion, ...args]);
-      } else {
-        await execa("bunx", [packageWithVersion, ...args], execaOptions);
-      }
-      logger.info(
-        { agentId: agent.id, version: selectedVersion },
-        "Coding agent completed (bunx)",
-      );
-      break;
-    }
-
-    case "command": {
-      // PATH解決 → 実行
-      const resolvedPath = await resolveCommand(agent.command);
-      if (captureOutput) {
-        await runWithCapture(resolvedPath, args);
-      } else {
-        await execa(resolvedPath, args, execaOptions);
-      }
-      logger.info({ agentId: agent.id }, "Coding agent completed (command)");
-      break;
-    }
-
-    default: {
-      // TypeScriptの型チェックで到達不可能だが、実行時の安全性のため
-      const exhaustiveCheck: never = agent.type;
-      throw new Error(
-        `Unknown agent execution type: ${exhaustiveCheck as string}`,
-      );
-    }
-  }
-}

package/src/logging/agentOutput.ts

@@ -1,216 +0,0 @@
-import * as pty from "node-pty";
-import type { IPty } from "node-pty";
-import { createLogger } from "./logger.js";
-import { resolveLogDir } from "./reader.js";
-import { getTerminalStreams } from "../utils/terminal.js";
-
-export const CAPTURE_AGENT_OUTPUT_ENV = "GWT_CAPTURE_AGENT_OUTPUT";
-
-export function shouldCaptureAgentOutput(
-  env: NodeJS.ProcessEnv = process.env,
-): boolean {
-  const raw = env[CAPTURE_AGENT_OUTPUT_ENV];
-  if (raw === undefined) {
-    // Default to false to avoid PTY stdin/stdout conflicts with OpenTUI.
-    // Set GWT_CAPTURE_AGENT_OUTPUT=true to enable agent output logging.
-    return false;
-  }
-  const normalized = String(raw).trim().toLowerCase();
-  if (!normalized) {
-    return false;
-  }
-  return normalized === "true" || normalized === "1";
-}
-
-// eslint-disable-next-line no-control-regex
-const ANSI_PATTERN = new RegExp("\\u001b\\[[0-9;]*[A-Za-z]", "g");
-
-export function stripAnsi(value: string): string {
-  return value.replace(ANSI_PATTERN, "");
-}
-
-export interface AgentOutputLineBuffer {
-  push: (chunk: string) => void;
-  flush: () => void;
-}
-
-export function createAgentOutputLineBuffer(
-  onLine: (line: string) => void,
-): AgentOutputLineBuffer {
-  let buffer = "";
-
-  const push = (chunk: string) => {
-    const normalized = chunk.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    buffer += normalized;
-    while (true) {
-      const index = buffer.indexOf("\n");
-      if (index === -1) {
-        break;
-      }
-      const line = buffer.slice(0, index);
-      buffer = buffer.slice(index + 1);
-      onLine(line);
-    }
-  };
-
-  const flush = () => {
-    if (!buffer) {
-      return;
-    }
-    const line = buffer;
-    buffer = "";
-    onLine(line);
-  };
-
-  return { push, flush };
-}
-
-export interface AgentOutputCaptureOptions {
-  command: string;
-  args: string[];
-  cwd: string;
-  env: NodeJS.ProcessEnv;
-  agentId: string;
-}
-
-export interface AgentOutputCaptureResult {
-  exitCode: number | null;
-  signal?: number | null;
-}
-
-const normalizeEnv = (env: NodeJS.ProcessEnv): Record<string, string> =>
-  Object.fromEntries(
-    Object.entries(env).filter(
-      (entry): entry is [string, string] => typeof entry[1] === "string",
-    ),
-  );
-
-const getTerminalSize = (terminal: ReturnType<typeof getTerminalStreams>) => {
-  const stdout = terminal.stdout as
-    | (NodeJS.WriteStream & { columns?: number; rows?: number })
-    | undefined;
-  const cols = stdout?.columns ?? process.stdout.columns ?? 80;
-  const rows = stdout?.rows ?? process.stdout.rows ?? 24;
-  return { cols, rows };
-};
-
-export async function runAgentWithPty(
-  options: AgentOutputCaptureOptions,
-): Promise<AgentOutputCaptureResult> {
-  const terminal = getTerminalStreams();
-  const { cols, rows } = getTerminalSize(terminal);
-  const logDir = resolveLogDir(options.cwd);
-  const stdoutLogger = createLogger({
-    category: "agent.stdout",
-    logDir,
-    base: { agentId: options.agentId },
-  });
-  const stderrLogger = createLogger({
-    category: "agent.stderr",
-    logDir,
-    base: { agentId: options.agentId },
-  });
-
-  const normalizedEnv = normalizeEnv(options.env);
-  const ptyProcess: IPty = pty.spawn(options.command, options.args, {
-    name: process.env.TERM ?? "xterm-256color",
-    cols,
-    rows,
-    cwd: options.cwd,
-    env: normalizedEnv,
-  });
-
-  const lineBuffer = createAgentOutputLineBuffer((line) => {
-    const cleaned = stripAnsi(line).trimEnd();
-    if (!cleaned) {
-      return;
-    }
-    stdoutLogger.info(cleaned);
-  });
-
-  const stdout = terminal.stdout;
-  const writeToTerminal =
-    stdout && typeof stdout.write === "function"
-      ? stdout.write.bind(stdout)
-      : null;
-
-  ptyProcess.onData((data) => {
-    if (writeToTerminal) {
-      try {
-        writeToTerminal(data);
-      } catch {
-        // Ignore terminal write errors.
-      }
-    }
-    lineBuffer.push(data);
-  });
-
-  const stdin = terminal.stdin;
-  const handleInput = (chunk: Buffer | string) => {
-    const data = typeof chunk === "string" ? chunk : chunk.toString("utf8");
-    ptyProcess.write(data);
-  };
-
-  const stdinWasRaw =
-    stdin &&
-    typeof (stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw ===
-      "boolean"
-      ? (stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw
-      : undefined;
-
-  if (stdin && typeof stdin.on === "function") {
-    if (stdin.isTTY && typeof stdin.setRawMode === "function") {
-      try {
-        stdin.setRawMode(true);
-      } catch {
-        // Ignore raw mode errors.
-      }
-    }
-    if (typeof stdin.resume === "function") {
-      stdin.resume();
-    }
-    stdin.on("data", handleInput);
-  }
-
-  const handleResize = () => {
-    const next = getTerminalSize(terminal);
-    try {
-      ptyProcess.resize(next.cols, next.rows);
-    } catch {
-      // Ignore resize errors.
-    }
-  };
-  if (process.stdout && typeof process.stdout.on === "function") {
-    process.stdout.on("resize", handleResize);
-  }
-
-  return await new Promise<AgentOutputCaptureResult>((resolve) => {
-    ptyProcess.onExit(({ exitCode, signal }) => {
-      lineBuffer.flush();
-      if (stdin && typeof stdin.off === "function") {
-        stdin.off("data", handleInput);
-      }
-      if (stdin && typeof stdin.pause === "function") {
-        stdin.pause();
-      }
-      if (stdin && stdin.isTTY && typeof stdin.setRawMode === "function") {
-        try {
-          stdin.setRawMode(Boolean(stdinWasRaw));
-        } catch {
-          // Ignore raw mode restore errors.
-        }
-      }
-      if (process.stdout && typeof process.stdout.off === "function") {
-        process.stdout.off("resize", handleResize);
-      }
-      if (exitCode !== null && exitCode !== 0) {
-        stderrLogger.error(
-          { exitCode, signal },
-          "Agent exited with non-zero code",
-        );
-      }
-      const normalizedSignal = signal ?? null;
-      resolve({ exitCode, signal: normalizedSignal });
-    });
-  });
-}

package/src/logging/formatter.ts

@@ -1,125 +0,0 @@
-export interface FormattedLogEntry {
-  id: string;
-  raw: Record<string, unknown>;
-  timestamp: number | null;
-  timeLabel: string;
-  levelLabel: string;
-  category: string;
-  message: string;
-  summary: string;
-  json: string;
-}
-
-const LEVEL_LABELS: Record<number, string> = {
-  10: "TRACE",
-  20: "DEBUG",
-  30: "INFO",
-  40: "WARN",
-  50: "ERROR",
-  60: "FATAL",
-};
-
-const LOCAL_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
-  hour: "2-digit",
-  minute: "2-digit",
-  second: "2-digit",
-  hour12: false,
-});
-
-const formatLocalTimeParts = (date: Date): string => {
-  const parts = LOCAL_TIME_FORMATTER.formatToParts(date);
-  const get = (type: Intl.DateTimeFormatPartTypes) =>
-    parts.find((part) => part.type === type)?.value;
-  const hour = get("hour");
-  const minute = get("minute");
-  const second = get("second");
-
-  if (!hour || !minute || !second) {
-    return LOCAL_TIME_FORMATTER.format(date);
-  }
-
-  return `${hour}:${minute}:${second}`;
-};
-
-const formatTimeLabel = (
-  value: unknown,
-): { label: string; timestamp: number | null } => {
-  if (typeof value === "string" || typeof value === "number") {
-    const date = new Date(value);
-    if (!Number.isNaN(date.getTime())) {
-      return {
-        label: formatLocalTimeParts(date),
-        timestamp: date.getTime(),
-      };
-    }
-  }
-
-  return { label: "--:--:--", timestamp: null };
-};
-
-const formatLevelLabel = (value: unknown): string => {
-  if (typeof value === "number") {
-    return LEVEL_LABELS[value] ?? `LEVEL-${value}`;
-  }
-  if (typeof value === "string") {
-    return value.toUpperCase();
-  }
-  return "UNKNOWN";
-};
-
-const resolveMessage = (entry: Record<string, unknown>): string => {
-  if (typeof entry.msg === "string") {
-    return entry.msg;
-  }
-  if (typeof entry.message === "string") {
-    return entry.message;
-  }
-  if (entry.msg !== undefined) {
-    return String(entry.msg);
-  }
-  return "";
-};
-
-export function parseLogLines(
-  lines: string[],
-  options: { limit?: number } = {},
-): FormattedLogEntry[] {
-  const entries: FormattedLogEntry[] = [];
-
-  lines.forEach((line, index) => {
-    if (!line.trim()) return;
-    try {
-      const parsed = JSON.parse(line) as Record<string, unknown>;
-      const { label: timeLabel, timestamp } = formatTimeLabel(parsed.time);
-      const levelLabel = formatLevelLabel(parsed.level);
-      const category =
-        typeof parsed.category === "string" ? parsed.category : "unknown";
-      const message = resolveMessage(parsed);
-      const summary =
-        `[${timeLabel}] [${levelLabel}] [${category}] ${message}`.trim();
-      const json = JSON.stringify(parsed, null, 2);
-      const id = `${timestamp ?? "unknown"}-${index}`;
-
-      entries.push({
-        id,
-        raw: parsed,
-        timestamp,
-        timeLabel,
-        levelLabel,
-        category,
-        message,
-        summary,
-        json,
-      });
-    } catch {
-      // Skip malformed JSON lines
-    }
-  });
-
-  const limit = options.limit ?? 100;
-  if (entries.length <= limit) {
-    return [...entries].reverse();
-  }
-
-  return entries.slice(-limit).reverse();
-}

package/src/logging/logger.ts

@@ -1,106 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import pino, { type LoggerOptions, type Logger } from "pino";
-import { pruneOldLogs } from "./rotation.js";
-
-type Category = "cli" | "server" | "worker" | string;
-
-export interface LoggerConfig {
-  level?: string;
-  logDir?: string;
-  filename?: string;
-  category?: Category;
-  base?: Record<string, unknown>;
-  keepDays?: number;
-  /** For tests or sync writes use pino.destination sync */
-  sync?: boolean;
-}
-
-/**
- * Create a pino logger with unified structure and category field.
- * - Writes to a single file stream (no per-component files)
- * - Adds `category` to each log record
- * - Prunes files older than keepDays at startup
- */
-export function createLogger(config: LoggerConfig = {}): Logger {
-  const level = config.level ?? process.env.LOG_LEVEL ?? "info";
-  const cwdBase = path.basename(process.cwd()) || "workspace";
-  const defaultLogDir = path.join(os.homedir(), ".gwt", "logs", cwdBase);
-  const logDir = config.logDir ?? defaultLogDir;
-  const filename = config.filename ?? `${formatDate(new Date())}.jsonl`;
-  const category = config.category ?? "default";
-  const keepDays = config.keepDays ?? 7;
-  const platform = os.platform();
-  const isWSL =
-    platform === "linux" && os.release().toLowerCase().includes("microsoft");
-  const preferDirectDestination =
-    platform === "win32" || isWSL || process.env.GWT_LOGGER_TRANSPORT === "0";
-
-  if (!fs.existsSync(logDir)) {
-    fs.mkdirSync(logDir, { recursive: true });
-  }
-
-  // Startup rotation
-  pruneOldLogs(logDir, keepDays);
-
-  const destination = path.join(logDir, filename);
-
-  const options: LoggerOptions = {
-    level,
-    base: {
-      category,
-      ...(config.base ?? {}),
-    },
-    timestamp: pino.stdTimeFunctions.isoTime,
-  };
-
-  if (config.sync) {
-    const destinationStream = pino.destination({
-      dest: destination,
-      sync: true,
-      append: true,
-    });
-    return pino(options, destinationStream);
-  }
-
-  if (!preferDirectDestination) {
-    try {
-      const transport = pino.transport({
-        targets: [
-          {
-            target: "pino/file",
-            options: { destination, mkdir: true, append: true },
-            level,
-          },
-        ],
-      });
-
-      return pino(options, transport);
-    } catch (error) {
-      if (process.env.DEBUG_LOGGER) {
-        console.error(
-          "Logger transport disabled; falling back to direct file destination.",
-          error instanceof Error ? error.message : String(error),
-        );
-      }
-    }
-  }
-
-  const destinationStream = pino.destination({
-    dest: destination,
-    sync: false,
-    append: true,
-  });
-  return pino(options, destinationStream);
-}
-
-/** Convenience logger for quick use (category defaults to "default"). */
-export const logger = createLogger();
-
-export function formatDate(date: Date): string {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}