@akiojin/gwt 4.12.1 → 6.0.0

package/src/logging/reader.ts

@@ -1,240 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { formatDate } from "./logger.js";
-
-export interface LogFileInfo {
-  date: string;
-  path: string;
-  mtimeMs: number;
-}
-
-export type LogTargetReason =
-  | "worktree"
-  | "worktree-inaccessible"
-  | "current-working-directory"
-  | "working-directory"
-  | "working-directory-fallback"
-  | "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 {
-  const cwdBase = path.basename(cwd) || "workspace";
-  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`);
-}
-
-export function getTodayLogDate(): string {
-  return formatDate(new Date());
-}
-
-export async function readLogFileLines(filePath: string): Promise<string[]> {
-  try {
-    const content = await fs.readFile(filePath, "utf-8");
-    return content.split("\n").filter(Boolean);
-  } catch (error) {
-    const err = error as NodeJS.ErrnoException;
-    if (err.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-}
-
-export async function listLogFiles(logDir: string): Promise<LogFileInfo[]> {
-  try {
-    const entries = await fs.readdir(logDir, { withFileTypes: true });
-    const files: LogFileInfo[] = [];
-
-    for (const entry of entries) {
-      if (!entry.isFile()) continue;
-      if (!LOG_FILENAME_PATTERN.test(entry.name)) continue;
-
-      const date = entry.name.replace(/\.jsonl$/, "");
-      const fullPath = path.join(logDir, entry.name);
-      try {
-        const stat = await fs.stat(fullPath);
-        files.push({ date, path: fullPath, mtimeMs: stat.mtimeMs });
-      } catch {
-        // Ignore stat errors per-file
-      }
-    }
-
-    return files.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  } catch (error) {
-    const err = error as NodeJS.ErrnoException;
-    if (err.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-}
-
-const getLatestLogMtimeWithContent = async (
-  logDir: string,
-): Promise<number | null> => {
-  const files = await listLogFiles(logDir);
-  for (const file of files) {
-    const lines = await readLogFileLines(file.path);
-    if (lines.length > 0) {
-      return file.mtimeMs;
-    }
-  }
-  return null;
-};
-
-export async function selectLogTargetByRecency(
-  primary: LogTargetResolution,
-  fallback: LogTargetResolution,
-): Promise<LogTargetResolution> {
-  if (!primary.logDir || !primary.sourcePath) {
-    return primary;
-  }
-  if (!fallback.logDir || !fallback.sourcePath) {
-    return primary;
-  }
-  if (primary.logDir === fallback.logDir) {
-    return primary;
-  }
-  if (primary.reason !== "worktree") {
-    return primary;
-  }
-
-  const [primaryMtime, fallbackMtime] = await Promise.all([
-    getLatestLogMtimeWithContent(primary.logDir),
-    getLatestLogMtimeWithContent(fallback.logDir),
-  ]);
-
-  if (
-    fallbackMtime !== null &&
-    (primaryMtime === null || fallbackMtime > primaryMtime)
-  ) {
-    return {
-      ...fallback,
-      reason: "working-directory-fallback",
-    };
-  }
-  return primary;
-}
-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,
-): Promise<LogFileInfo[]> {
-  const files = await listLogFiles(logDir);
-  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/logging/rotation.ts

@@ -1,25 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-/**
- * Delete log files older than `keepDays` from the given directory.
- * This is called at startup to enforce 7-day retention without size limits.
- */
-export function pruneOldLogs(logDir: string, keepDays = 7): void {
-  if (!fs.existsSync(logDir)) return;
-
-  const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1000;
-
-  for (const entry of fs.readdirSync(logDir)) {
-    const full = path.join(logDir, entry);
-    try {
-      const stat = fs.statSync(full);
-      if (!stat.isFile()) continue;
-      if (stat.mtime.getTime() < cutoff) {
-        fs.unlinkSync(full);
-      }
-    } catch {
-      // Ignore individual file errors to avoid breaking startup
-    }
-  }
-}

package/src/opentui/index.solid.ts

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

package/src/repositories/git.repository.ts

@@ -1,129 +0,0 @@
-import { execa } from "execa";
-import { GitError } from "../git.js";
-
-/**
- * Git操作のための低レベルRepository
- * execaの直接呼び出しをカプセル化
- */
-export class GitRepository {
-  async execute(args: string[], options?: { cwd?: string }): Promise<string> {
-    try {
-      const { stdout } = await execa("git", args, options);
-      return stdout;
-    } catch (error) {
-      throw new GitError(`Git command failed: git ${args.join(" ")}`, error);
-    }
-  }
-
-  async isRepository(): Promise<boolean> {
-    try {
-      await this.execute(["rev-parse", "--git-dir"]);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async getRepositoryRoot(): Promise<string> {
-    const stdout = await this.execute(["rev-parse", "--show-toplevel"]);
-    return stdout.trim();
-  }
-
-  async getCurrentBranch(): Promise<string | null> {
-    try {
-      const stdout = await this.execute(["branch", "--show-current"]);
-      return stdout.trim() || null;
-    } catch {
-      return null;
-    }
-  }
-
-  async getBranches(options: { remote?: boolean }): Promise<string[]> {
-    const args = ["branch"];
-    if (options.remote) {
-      args.push("-r");
-    }
-    args.push("--format=%(refname:short)");
-
-    const stdout = await this.execute(args);
-    return stdout
-      .split("\n")
-      .filter((line) => line.trim())
-      .filter((line) => !line.includes("HEAD"));
-  }
-
-  async createBranch(branchName: string, baseBranch?: string): Promise<void> {
-    const args = ["checkout", "-b", branchName];
-    if (baseBranch) {
-      args.push(baseBranch);
-    }
-    await this.execute(args);
-  }
-
-  async deleteBranch(branchName: string, force = false): Promise<void> {
-    const args = ["branch", force ? "-D" : "-d", branchName];
-    await this.execute(args);
-  }
-
-  async deleteRemoteBranch(branchName: string): Promise<void> {
-    await this.execute(["push", "origin", "--delete", branchName]);
-  }
-
-  async getStatus(options?: { cwd?: string }): Promise<string> {
-    return await this.execute(
-      ["status", "--porcelain"],
-      options?.cwd ? options : undefined,
-    );
-  }
-
-  async hasChanges(workdir?: string): Promise<boolean> {
-    const status = await this.getStatus(workdir ? { cwd: workdir } : undefined);
-    return status.trim().length > 0;
-  }
-
-  async fetch(options?: { all?: boolean; prune?: boolean }): Promise<void> {
-    const args = ["fetch"];
-    if (options?.all) args.push("--all");
-    if (options?.prune) args.push("--prune");
-    await this.execute(args);
-  }
-
-  async push(options?: { upstream?: boolean; branch?: string }): Promise<void> {
-    const args = ["push"];
-    if (options?.upstream && options?.branch) {
-      args.push("--set-upstream", "origin", options.branch);
-    }
-    await this.execute(args);
-  }
-
-  async commit(message: string, options?: { all?: boolean }): Promise<void> {
-    const args = ["commit", "-m", message];
-    if (options?.all) args.push("-a");
-    await this.execute(args);
-  }
-
-  async add(files: string[] | "."): Promise<void> {
-    const args = ["add"];
-    if (Array.isArray(files)) {
-      args.push(...files);
-    } else {
-      args.push(files);
-    }
-    await this.execute(args);
-  }
-
-  async stash(message?: string): Promise<void> {
-    const args = ["stash", "push"];
-    if (message) args.push("-m", message);
-    await this.execute(args);
-  }
-
-  async checkout(target: string): Promise<void> {
-    await this.execute(["checkout", target]);
-  }
-
-  async getChangedFilesCount(workdir?: string): Promise<number> {
-    const status = await this.getStatus(workdir ? { cwd: workdir } : undefined);
-    return status.split("\n").filter((line) => line.trim()).length;
-  }
-}

package/src/repositories/github.repository.ts

@@ -1,83 +0,0 @@
-import { execa } from "execa";
-import chalk from "chalk";
-import type { GitHubPRResponse } from "../cli/ui/types.js";
-
-/**
- * GitHub CLI操作のための低レベルRepository
- */
-export class GitHubRepository {
-  async execute(args: string[]): Promise<string> {
-    try {
-      const { stdout } = await execa("gh", args);
-      return stdout;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(
-        `GitHub CLI command failed: gh ${args.join(" ")}\n${message}`,
-      );
-    }
-  }
-
-  async isAvailable(): Promise<boolean> {
-    try {
-      await this.execute(["--version"]);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async isAuthenticated(): Promise<boolean> {
-    try {
-      await this.execute(["api", "user"]);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async fetchPullRequests(options: {
-    state?: "all" | "open" | "closed" | "merged";
-    limit?: number;
-    head?: string;
-  }): Promise<GitHubPRResponse[]> {
-    const args = ["pr", "list"];
-
-    if (options.state) {
-      args.push("--state", options.state);
-    }
-
-    if (options.head) {
-      args.push("--head", options.head);
-    }
-
-    args.push(
-      "--json",
-      "number,title,state,headRefName,mergedAt,author",
-      "--limit",
-      String(options.limit || 100),
-    );
-
-    const stdout = await this.execute(args);
-
-    if (!stdout || stdout.trim() === "") {
-      return [];
-    }
-
-    return JSON.parse(stdout);
-  }
-
-  async fetchRemoteUpdates(): Promise<void> {
-    try {
-      await execa("git", ["fetch", "--all", "--prune"]);
-    } catch {
-      if (process.env.DEBUG_CLEANUP) {
-        console.log(
-          chalk.yellow(
-            "Debug: Failed to fetch remote updates, continuing anyway",
-          ),
-        );
-      }
-    }
-  }
-}

package/src/repositories/worktree.repository.ts

@@ -1,77 +0,0 @@
-import { execa } from "execa";
-import { WorktreeError } from "../worktree.js";
-
-export interface WorktreeData {
-  path: string;
-  head: string;
-  branch: string;
-}
-
-/**
- * Git Worktree操作のための低レベルRepository
- */
-export class WorktreeRepository {
-  async execute(args: string[], options?: { cwd?: string }): Promise<string> {
-    try {
-      const { stdout } = await execa("git", ["worktree", ...args], options);
-      return stdout;
-    } catch (error) {
-      throw new WorktreeError(
-        `Worktree command failed: git worktree ${args.join(" ")}`,
-        error,
-      );
-    }
-  }
-
-  async list(): Promise<WorktreeData[]> {
-    const stdout = await this.execute(["list", "--porcelain"]);
-    const worktrees: WorktreeData[] = [];
-    const lines = stdout.split("\n");
-
-    let currentWorktree: Partial<WorktreeData> = {};
-
-    for (const line of lines) {
-      if (line.startsWith("worktree ")) {
-        currentWorktree.path = line.substring(9);
-      } else if (line.startsWith("HEAD ")) {
-        currentWorktree.head = line.substring(5);
-      } else if (line.startsWith("branch ")) {
-        currentWorktree.branch = line.substring(7).replace("refs/heads/", "");
-      } else if (line === "") {
-        if (currentWorktree.path) {
-          worktrees.push(currentWorktree as WorktreeData);
-          currentWorktree = {};
-        }
-      }
-    }
-
-    if (currentWorktree.path) {
-      worktrees.push(currentWorktree as WorktreeData);
-    }
-
-    return worktrees;
-  }
-
-  async add(worktreePath: string, branchName: string): Promise<void> {
-    await this.execute(["add", worktreePath, branchName]);
-  }
-
-  async remove(worktreePath: string, force = false): Promise<void> {
-    const args = ["remove"];
-    if (force) args.push("--force");
-    args.push(worktreePath);
-    await this.execute(args);
-  }
-
-  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);
-  }
-}