@akiojin/gwt 4.10.0 → 4.12.0

package/src/launcher.ts

@@ -6,8 +6,18 @@
  */
 
 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" });
 
@@ -122,14 +132,32 @@ export async function launchCodingAgent(
     ...(options.sharedEnv ?? {}),
     ...(agent.env ?? {}),
   };
+  const workingDir = options.cwd ?? process.cwd();
+  const captureOutput = shouldCaptureAgentOutput(env);
 
   // execa共通オプション（cwdがundefinedの場合は含めない）
   const execaOptions = {
     stdio: "inherit" as const,
-    ...(options.cwd ? { cwd: options.cwd } : {}),
+    ...(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,
@@ -143,23 +171,55 @@ export async function launchCodingAgent(
   switch (agent.type) {
     case "path": {
       // 絶対パスで直接実行
-      await execa(agent.command, args, execaOptions);
+      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経由でパッケージ実行
-      // bunx [package] [args...]
-      await execa("bunx", [agent.command, ...args], execaOptions);
-      logger.info({ agentId: agent.id }, "Coding agent completed (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);
-      await execa(resolvedPath, args, execaOptions);
+      if (captureOutput) {
+        await runWithCapture(resolvedPath, args);
+      } else {
+        await execa(resolvedPath, args, execaOptions);
+      }
       logger.info({ agentId: agent.id }, "Coding agent completed (command)");
       break;
     }

package/src/logging/agentOutput.ts

@@ -0,0 +1,216 @@
+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

@@ -19,17 +19,36 @@ const LEVEL_LABELS: Record<number, string> = {
   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())) {
-      const hours = String(date.getHours()).padStart(2, "0");
-      const minutes = String(date.getMinutes()).padStart(2, "0");
-      const seconds = String(date.getSeconds()).padStart(2, "0");
       return {
-        label: `${hours}:${minutes}:${seconds}`,
+        label: formatLocalTimeParts(date),
         timestamp: date.getTime(),
       };
     }

package/src/logging/logger.ts

@@ -31,6 +31,11 @@ export function createLogger(config: LoggerConfig = {}): Logger {
   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 });
@@ -54,21 +59,40 @@ export function createLogger(config: LoggerConfig = {}): Logger {
     const destinationStream = pino.destination({
       dest: destination,
       sync: true,
+      append: true,
     });
     return pino(options, destinationStream);
   }
 
-  const transport = pino.transport({
-    targets: [
-      {
-        target: "pino/file",
-        options: { destination, mkdir: true, append: true },
-        level,
-      },
-    ],
-  });
+  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),
+        );
+      }
+    }
+  }
 
-  return pino(options, transport);
+  const destinationStream = pino.destination({
+    dest: destination,
+    sync: false,
+    append: true,
+  });
+  return pino(options, destinationStream);
 }
 
 /** Convenience logger for quick use (category defaults to "default"). */

package/src/logging/reader.ts

@@ -9,6 +9,25 @@ export interface LogFileInfo {
   mtimeMs: number;
 }
 
+export type LogTargetReason =
+  | "worktree"
+  | "worktree-inaccessible"
+  | "current-working-directory"
+  | "working-directory"
+  | "no-worktree";
+
+export interface LogTargetBranch {
+  name: string;
+  isCurrent?: boolean;
+  worktree?: { path: string; isAccessible?: boolean } | undefined;
+}
+
+export interface LogTargetResolution {
+  logDir: string | null;
+  sourcePath: string | null;
+  reason: LogTargetReason;
+}
+
 const LOG_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
 
 export function resolveLogDir(cwd: string = process.cwd()): string {
@@ -16,6 +35,46 @@ export function resolveLogDir(cwd: string = process.cwd()): string {
   return path.join(os.homedir(), ".gwt", "logs", cwdBase);
 }
 
+export function resolveLogTarget(
+  branch: LogTargetBranch | null,
+  workingDirectory: string = process.cwd(),
+): LogTargetResolution {
+  if (!branch) {
+    return {
+      logDir: resolveLogDir(workingDirectory),
+      sourcePath: workingDirectory,
+      reason: "working-directory",
+    };
+  }
+
+  const worktreePath = branch.worktree?.path;
+  if (worktreePath) {
+    const accessible = branch.worktree?.isAccessible !== false;
+    if (accessible) {
+      return {
+        logDir: resolveLogDir(worktreePath),
+        sourcePath: worktreePath,
+        reason: "worktree",
+      };
+    }
+    return {
+      logDir: null,
+      sourcePath: worktreePath,
+      reason: "worktree-inaccessible",
+    };
+  }
+
+  if (branch.isCurrent) {
+    return {
+      logDir: resolveLogDir(workingDirectory),
+      sourcePath: workingDirectory,
+      reason: "current-working-directory",
+    };
+  }
+
+  return { logDir: null, sourcePath: null, reason: "no-worktree" };
+}
+
 export function buildLogFilePath(logDir: string, date: string): string {
   return path.join(logDir, `${date}.jsonl`);
 }
@@ -66,6 +125,23 @@ export async function listLogFiles(logDir: string): Promise<LogFileInfo[]> {
   }
 }
 
+export async function clearLogFiles(logDir: string): Promise<number> {
+  const files = await listLogFiles(logDir);
+  let cleared = 0;
+  for (const file of files) {
+    try {
+      await fs.truncate(file.path, 0);
+      cleared += 1;
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      if (err.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  return cleared;
+}
+
 export async function listRecentLogFiles(
   logDir: string,
   days = 7,
@@ -74,3 +150,44 @@ export async function listRecentLogFiles(
   const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
   return files.filter((file) => file.mtimeMs >= cutoff);
 }
+
+export interface LogReadResult {
+  date: string;
+  lines: string[];
+}
+
+export async function readLogLinesForDate(
+  logDir: string,
+  preferredDate: string,
+): Promise<LogReadResult | null> {
+  const files = await listLogFiles(logDir);
+  if (files.length === 0) {
+    return null;
+  }
+
+  const ordered: LogFileInfo[] = [];
+  const preferred = files.find((file) => file.date === preferredDate);
+  if (preferred) {
+    ordered.push(preferred);
+  }
+  for (const file of files) {
+    if (preferred && file.date === preferred.date) {
+      continue;
+    }
+    ordered.push(file);
+  }
+
+  for (const file of ordered) {
+    const lines = await readLogFileLines(file.path);
+    if (lines.length > 0) {
+      return { date: file.date, lines };
+    }
+  }
+
+  const fallback = files[0];
+  if (!fallback) {
+    return { date: preferredDate, lines: [] };
+  }
+  const fallbackDate = preferred?.date ?? fallback.date;
+  return { date: fallbackDate, lines: [] };
+}

package/src/opentui/index.solid.ts

@@ -0,0 +1 @@
+export { renderSolidApp } from "../cli/ui/index.solid.js";

package/src/repositories/worktree.repository.ts

@@ -66,4 +66,12 @@ export class WorktreeRepository {
   async prune(): Promise<void> {
     await this.execute(["prune"]);
   }
+
+  async repair(worktreePaths?: string[]): Promise<void> {
+    const args = ["repair"];
+    if (worktreePaths && worktreePaths.length > 0) {
+      args.push(...worktreePaths);
+    }
+    await this.execute(args);
+  }
 }