glab-agent 0.1.0

package/src/local-agent/process-manager.ts

@@ -0,0 +1,193 @@
+import { readFile, writeFile, unlink, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import os from "node:os";
+
+import { agentPidPath, agentLogPath, agentStateDir } from "./agent-config.js";
+import { rotateIfNeeded } from "./log-rotate.js";
+
+const execFileAsync = promisify(execFile);
+
+export async function readPid(repoPath: string, agentName: string): Promise<number | undefined> {
+  try {
+    const content = await readFile(agentPidPath(repoPath, agentName), "utf8");
+    const pid = Number.parseInt(content.trim(), 10);
+    return Number.isNaN(pid) ? undefined : pid;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function writePid(repoPath: string, agentName: string, pid: number): Promise<void> {
+  const pidFile = agentPidPath(repoPath, agentName);
+  await mkdir(path.dirname(pidFile), { recursive: true });
+  await writeFile(pidFile, String(pid), "utf8");
+}
+
+export async function removePid(repoPath: string, agentName: string): Promise<void> {
+  try {
+    await unlink(agentPidPath(repoPath, agentName));
+  } catch {
+    // ignore
+  }
+}
+
+export function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code !== "ESRCH";
+  }
+}
+
+export interface AgentProcessStatus {
+  name: string;
+  pid?: number;
+  alive: boolean;
+}
+
+export async function getAgentStatus(repoPath: string, agentName: string): Promise<AgentProcessStatus> {
+  const pid = await readPid(repoPath, agentName);
+  return {
+    name: agentName,
+    pid,
+    alive: pid !== undefined && isPidAlive(pid)
+  };
+}
+
+export async function startAgent(
+  repoPath: string,
+  agentName: string,
+  scriptDir: string,
+  installDir: string
+): Promise<number> {
+  const existing = await getAgentStatus(repoPath, agentName);
+  if (existing.alive) {
+    throw new Error(`Agent "${agentName}" is already running (PID ${existing.pid}).`);
+  }
+
+  const logDir = agentLogPath(repoPath, agentName);
+  await mkdir(logDir, { recursive: true });
+  await mkdir(agentStateDir(repoPath), { recursive: true });
+
+  const tsxPath = path.join(installDir, "node_modules", ".bin", "tsx");
+  const child = spawn(
+    tsxPath,
+    [path.join(scriptDir, "watcher.ts"), "watch", "--agent", agentName, "--project", repoPath],
+    {
+      cwd: installDir,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
+      env: { ...process.env, AGENT_PROJECT_DIR: repoPath }
+    }
+  );
+
+  // Rotate log files if they exceed size threshold before opening
+  await rotateIfNeeded(path.join(logDir, "watcher.log"));
+  await rotateIfNeeded(path.join(logDir, "watcher.err"));
+
+  // Redirect stdout/stderr to log files
+  const { createWriteStream } = await import("node:fs");
+  const outLog = createWriteStream(path.join(logDir, "watcher.log"), { flags: "a" });
+  const errLog = createWriteStream(path.join(logDir, "watcher.err"), { flags: "a" });
+  child.stdout?.pipe(outLog);
+  child.stderr?.pipe(errLog);
+
+  child.unref();
+
+  if (child.pid === undefined) {
+    throw new Error(`Failed to start agent "${agentName}".`);
+  }
+
+  await writePid(repoPath, agentName, child.pid);
+  return child.pid;
+}
+
+export async function stopAgent(repoPath: string, agentName: string): Promise<boolean> {
+  const status = await getAgentStatus(repoPath, agentName);
+  if (!status.alive || status.pid === undefined) {
+    await removePid(repoPath, agentName);
+    return false;
+  }
+
+  // Send SIGTERM to the process group so both tsx and the child node process
+  // receive it. startAgent uses detached:true which makes tsx the group leader.
+  try {
+    process.kill(-status.pid, "SIGTERM");
+  } catch {
+    try {
+      process.kill(status.pid, "SIGTERM");
+    } catch {
+      // already dead
+    }
+  }
+
+  // Wait for the process to actually die (gives shutdown handler time to
+  // update GitLab status to offline before we clean up the PID file).
+  const deadline = Date.now() + 10_000;
+  while (Date.now() < deadline && isPidAlive(status.pid)) {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+
+  await removePid(repoPath, agentName);
+  return true;
+}
+
+// ── LaunchD Plist Generation ─────────────────────────────────────────────────
+
+export function generateLaunchdPlist(
+  agentName: string,
+  repoPath: string,
+  scriptDir: string,
+  installDir: string
+): string {
+  const projectName = path.basename(path.resolve(repoPath));
+  const label = `com.glab-agent.${projectName}.${agentName}`;
+  const logDir = agentLogPath(repoPath, agentName);
+  const tsxPath = path.join(installDir, "node_modules", ".bin", "tsx");
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${tsxPath}</string>
+    <string>${path.join(scriptDir, "watcher.ts")}</string>
+    <string>watch</string>
+    <string>--agent</string>
+    <string>${agentName}</string>
+    <string>--project</string>
+    <string>${repoPath}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${installDir}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${path.dirname(process.execPath)}:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:${os.homedir()}/.local/bin</string>
+    <key>AGENT_PROJECT_DIR</key>
+    <string>${repoPath}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ExitTimeOut</key>
+  <integer>15</integer>
+  <key>StandardOutPath</key>
+  <string>${path.join(logDir, "watcher.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${path.join(logDir, "watcher.err")}</string>
+</dict>
+</plist>`;
+}
+
+export function launchdPlistPath(agentName: string, repoPath: string): string {
+  const projectName = path.basename(path.resolve(repoPath));
+  return path.join(os.homedir(), "Library", "LaunchAgents", `com.glab-agent.${projectName}.${agentName}.plist`);
+}

package/src/local-agent/reply-runner.ts

@@ -0,0 +1,111 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import { compactText, truncate } from "../text.js";
+import { resolveClaudeCommand } from "./claude-runner.js";
+import type { ReplyContext } from "./mr-actions.js";
+import { createLogger, type Logger } from "./logger.js";
+
+const execFileAsync = promisify(execFile);
+
+export interface ReplyRunnerOptions {
+  execFileImpl?: typeof execFileAsync;
+  env?: NodeJS.ProcessEnv;
+  repoPath: string;
+  logger?: Logger;
+}
+
+export class ReplyRunner {
+  private readonly execFileImpl: typeof execFileAsync;
+
+  private readonly env: NodeJS.ProcessEnv;
+
+  private readonly repoPath: string;
+
+  private readonly logger: Logger;
+
+  constructor(options: ReplyRunnerOptions) {
+    this.execFileImpl = options.execFileImpl ?? execFileAsync;
+    this.env = options.env ?? process.env;
+    this.repoPath = options.repoPath;
+    this.logger = options.logger ?? createLogger("reply");
+  }
+
+  async generateReply(context: ReplyContext): Promise<string> {
+    const prompt = buildReplyPrompt(context);
+    const claudeCommand = resolveClaudeCommand(this.env);
+
+    this.logger.info(`Reply for ${context.targetType} !${context.targetIid} (${prompt.length} chars)`);
+
+    try {
+      const { stdout } = await this.execFileImpl(
+        claudeCommand,
+        ["-p", "--output-format", "text", "--permission-mode", "bypassPermissions", prompt],
+        {
+          cwd: this.repoPath,
+          encoding: "utf8",
+          maxBuffer: 10 * 1024 * 1024,
+          env: this.env
+        }
+      );
+
+      return truncate(compactText(stdout || "（无回复内容）"), 2000);
+    } catch (error) {
+      const execError = error as { stdout?: string; stderr?: string; message?: string };
+      this.logger.error(`Reply generation failed: ${execError.stderr?.slice(0, 300) ?? String(error).slice(0, 300)}`);
+      // If Claude produced partial output, use that
+      if (execError.stdout) {
+        return truncate(compactText(execError.stdout), 2000);
+      }
+      throw error;
+    }
+  }
+}
+
+export function buildReplyPrompt(ctx: ReplyContext): string {
+  const targetLabel = ctx.targetType === "MergeRequest" ? `MR !${ctx.targetIid}` : `Issue #${ctx.targetIid}`;
+  const notesBlock = ctx.recentNotes.length > 0
+    ? ctx.recentNotes.map((n, i) => `  ${i + 1}. ${truncate(n, 300)}`).join("\n")
+    : "  （无历史评论）";
+
+  const descriptionBlock = ctx.targetDescription
+    ? `\n## ${ctx.targetType === "MergeRequest" ? "MR" : "Issue"} 描述\n${truncate(ctx.targetDescription, 2000)}\n`
+    : "";
+
+  return [
+    `你是这个项目的团队成员（AI agent），有人在 ${targetLabel} 上 @mention 了你。`,
+    "你在项目仓库中工作，可以读取代码、文档和配置来理解项目。",
+    "",
+    "## 你的身份",
+    "像一个熟悉项目的资深开发者一样思考和回复。",
+    "参考项目的设计原则（docs/design-principles.md）、产品定位（README.md）和现有架构来回应。",
+    "不要机械地分析代码 diff，要站在产品和团队的角度回答。",
+    "",
+    "## 上下文",
+    `- ${targetLabel}: ${ctx.targetTitle}`,
+    `- @mention 内容: ${ctx.mentionBody}`,
+    `- GitLab: ${ctx.gitlabHost} | Project ID: ${ctx.projectId}`,
+    descriptionBlock,
+    "## 最近评论",
+    notesBlock,
+    "",
+    "## 查询更多信息",
+    ctx.targetType === "MergeRequest"
+      ? [
+          `- MR 详情: glab api projects/${ctx.projectId}/merge_requests/${ctx.targetIid}`,
+          `- MR 变更: glab api projects/${ctx.projectId}/merge_requests/${ctx.targetIid}/changes`,
+          `- MR 讨论: glab api projects/${ctx.projectId}/merge_requests/${ctx.targetIid}/notes`
+        ].join("\n")
+      : [
+          `- Issue 详情: glab api projects/${ctx.projectId}/issues/${ctx.targetIid}`,
+          `- Issue 评论: glab api projects/${ctx.projectId}/issues/${ctx.targetIid}/notes`
+        ].join("\n"),
+    "",
+    "## 输出要求",
+    "- 输出就是将要发到 GitLab 的回复，用 Markdown 格式。",
+    "- 不要输出内部思考过程（如 'Let me think...'、'Now I have...'）。",
+    "- 结构清晰：用标题、列表、粗体组织，方便在 GitLab 上阅读。",
+    "- 不要修改代码或创建文件。",
+    "- 如果 @mention 要求评估需求或方案，给出你作为团队成员的判断和建议。"
+  ].join("\n");
+}

package/src/local-agent/repo-cache.ts

@@ -0,0 +1,144 @@
+import { execFile } from "node:child_process";
+import { mkdir, readdir, stat, rm } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export interface RepoCacheOptions {
+  cacheDir: string;               // e.g., ".glab-agent/repo-cache"
+  execFileImpl?: typeof execFileAsync;
+}
+
+export interface CachedRepo {
+  repoPath: string;     // path to the cached bare clone
+  repoUrl: string;      // original URL
+  lastUsed: Date;
+}
+
+export class RepoCache {
+  private readonly cacheDir: string;
+  private readonly execFileImpl: typeof execFileAsync;
+
+  constructor(options: RepoCacheOptions) {
+    this.cacheDir = options.cacheDir;
+    this.execFileImpl = options.execFileImpl ?? execFileAsync;
+  }
+
+  /**
+   * Get or create a cached bare clone of the given repo URL.
+   * If already cached, just fetches updates. If not, does a bare clone.
+   * Returns the path to the cached bare repo.
+   */
+  async ensureRepo(repoUrl: string): Promise<string> {
+    await mkdir(this.cacheDir, { recursive: true });
+
+    const key = RepoCache.cacheKey(repoUrl);
+    const repoPath = path.join(this.cacheDir, `${key}.git`);
+
+    let exists = false;
+    try {
+      await stat(repoPath);
+      exists = true;
+    } catch {
+      exists = false;
+    }
+
+    if (exists) {
+      await this.runGit(repoPath, ["fetch", "--all"]);
+    } else {
+      await this.runGit(this.cacheDir, ["clone", "--bare", repoUrl, `${key}.git`]);
+    }
+
+    return repoPath;
+  }
+
+  /**
+   * Create a worktree from a cached repo.
+   * Returns the worktree path.
+   */
+  async createWorktree(repoUrl: string, branch: string, worktreePath: string): Promise<string> {
+    const repoPath = await this.ensureRepo(repoUrl);
+    await this.runGit(repoPath, ["worktree", "add", worktreePath, branch]);
+    return worktreePath;
+  }
+
+  /**
+   * List all cached repos with their sizes and last-used dates.
+   */
+  async listCached(): Promise<CachedRepo[]> {
+    let entries: string[];
+    try {
+      entries = await readdir(this.cacheDir);
+    } catch {
+      return [];
+    }
+
+    const results: CachedRepo[] = [];
+
+    for (const entry of entries) {
+      if (!entry.endsWith(".git")) continue;
+
+      const repoPath = path.join(this.cacheDir, entry);
+
+      let lastUsed: Date;
+      try {
+        const statResult = await stat(repoPath);
+        lastUsed = statResult.mtime;
+      } catch {
+        continue;
+      }
+
+      let repoUrl = "";
+      try {
+        const output = await this.runGit(repoPath, ["config", "--get", "remote.origin.url"]);
+        repoUrl = output.trim();
+      } catch {
+        // If we can't read the URL, skip
+        continue;
+      }
+
+      results.push({ repoPath, repoUrl, lastUsed });
+    }
+
+    return results;
+  }
+
+  /**
+   * Remove a cached repo by URL.
+   */
+  async evict(repoUrl: string): Promise<boolean> {
+    const key = RepoCache.cacheKey(repoUrl);
+    const repoPath = path.join(this.cacheDir, `${key}.git`);
+
+    try {
+      await stat(repoPath);
+    } catch {
+      return false;
+    }
+
+    await rm(repoPath, { recursive: true, force: true });
+    return true;
+  }
+
+  /**
+   * Get the cache directory path for a given repo URL.
+   * Uses SHA-256 hash of the URL for the directory name.
+   */
+  static cacheKey(repoUrl: string): string {
+    return createHash("sha256").update(repoUrl).digest("hex").slice(0, 16);
+  }
+
+  private async runGit(cwd: string, args: string[]): Promise<string> {
+    try {
+      const { stdout } = await this.execFileImpl("git", ["-C", cwd, ...args], {
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      return stdout;
+    } catch (error) {
+      throw new Error(`git command failed (${args.join(" ")}): ${String(error)}`);
+    }
+  }
+}

package/src/local-agent/report.ts

@@ -0,0 +1,183 @@
+import { readMetrics } from "./metrics.js";
+import type { MetricEvent } from "./metrics.js";
+
+export interface ReportOptions {
+  sinceDays: number; // default 7
+}
+
+export interface ReportResult {
+  agentName: string;
+  period: { from: Date; to: Date };
+  total: number;
+  completed: number;
+  failed: number;
+  timedOut: number;
+  cycleErrors: number;
+  successRate: number; // 0-100
+  avgDurationMs: number | null; // completed only
+  topFailures: { error: string; count: number }[];
+  recentRuns: {
+    event: string;
+    issueIid?: number;
+    issueTitle?: string;
+    durationMs?: number;
+    timestamp: string;
+    error?: string;
+  }[];
+}
+
+export async function generateReport(
+  metricsDir: string,
+  agentName: string,
+  options: ReportOptions
+): Promise<ReportResult> {
+  const { sinceDays } = options;
+  const now = new Date();
+  const sinceDate = new Date(now.getTime() - sinceDays * 24 * 60 * 60 * 1000);
+
+  const allEvents = await readMetrics(metricsDir, agentName);
+  const events = allEvents.filter((e) => new Date(e.timestamp) >= sinceDate);
+
+  let completed = 0;
+  let failed = 0;
+  let timedOut = 0;
+  let cycleErrors = 0;
+  const completedDurations: number[] = [];
+  const failureMap = new Map<string, number>();
+
+  for (const e of events) {
+    if (e.event === "run_complete") {
+      completed++;
+      if (e.durationMs !== undefined) {
+        completedDurations.push(e.durationMs);
+      }
+    } else if (e.event === "run_failed") {
+      failed++;
+      const errorKey = e.error ?? "Unknown error";
+      failureMap.set(errorKey, (failureMap.get(errorKey) ?? 0) + 1);
+    } else if (e.event === "run_timeout") {
+      timedOut++;
+      const errorKey = e.error ?? "Timeout";
+      failureMap.set(errorKey, (failureMap.get(errorKey) ?? 0) + 1);
+    } else if (e.event === "cycle_error") {
+      cycleErrors++;
+    }
+  }
+
+  const denominator = completed + failed + timedOut;
+  const successRate = denominator > 0 ? (completed / denominator) * 100 : 0;
+
+  const avgDurationMs =
+    completedDurations.length > 0
+      ? completedDurations.reduce((a, b) => a + b, 0) / completedDurations.length
+      : null;
+
+  const topFailures = Array.from(failureMap.entries())
+    .map(([error, count]) => ({ error, count }))
+    .sort((a, b) => b.count - a.count)
+    .slice(0, 5);
+
+  const runEvents = events.filter(
+    (e) => e.event === "run_complete" || e.event === "run_failed" || e.event === "run_timeout"
+  );
+  // Sort newest first and take last 10
+  const recentRuns = runEvents
+    .slice()
+    .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+    .slice(0, 10)
+    .map((e) => ({
+      event: e.event,
+      issueIid: e.issueIid,
+      issueTitle: e.issueTitle,
+      durationMs: e.durationMs,
+      timestamp: e.timestamp,
+      error: e.error
+    }));
+
+  return {
+    agentName,
+    period: { from: sinceDate, to: now },
+    total: completed + failed + timedOut,
+    completed,
+    failed,
+    timedOut,
+    cycleErrors,
+    successRate,
+    avgDurationMs,
+    topFailures,
+    recentRuns
+  };
+}
+
+export function formatMs(ms: number): string {
+  const totalSeconds = Math.round(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  if (minutes > 0) return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+  return `${seconds}s`;
+}
+
+export function formatReport(result: ReportResult): string {
+  const { agentName, period, total, completed, failed, timedOut, cycleErrors, successRate, avgDurationMs, topFailures, recentRuns } = result;
+
+  if (total === 0) {
+    const sinceDays = Math.round(
+      (period.to.getTime() - period.from.getTime()) / (24 * 60 * 60 * 1000)
+    );
+    return `No metrics data found for agent '${agentName}' in the last ${sinceDays} days.`;
+  }
+
+  const sinceDays = Math.round(
+    (period.to.getTime() - period.from.getTime()) / (24 * 60 * 60 * 1000)
+  );
+
+  const lines: string[] = [];
+  const header = `📊 Agent Report: ${agentName} (last ${sinceDays} days)`;
+  lines.push(header);
+  lines.push("═".repeat(header.length));
+  lines.push("");
+
+  // Counts line
+  const timeoutPart = timedOut > 0 ? ` | ${timedOut} timeout` : "";
+  const cyclePart = cycleErrors > 0 ? ` | ${cycleErrors} cycle_error` : "";
+  lines.push(`Runs: ${total} total | ${completed} completed | ${failed} failed${timeoutPart}${cyclePart}`);
+
+  // Success rate
+  lines.push(`Success rate: ${successRate.toFixed(1)}%`);
+
+  // Avg duration
+  if (avgDurationMs !== null) {
+    lines.push(`Avg duration: ${formatMs(avgDurationMs)} (completed only)`);
+  }
+
+  // Top failures
+  if (topFailures.length > 0) {
+    lines.push("");
+    lines.push("Top failures:");
+    for (let i = 0; i < topFailures.length; i++) {
+      const { error, count } = topFailures[i];
+      const plural = count === 1 ? "occurrence" : "occurrences";
+      lines.push(`  ${i + 1}. ${error} (${count} ${plural})`);
+    }
+  }
+
+  // Recent runs
+  if (recentRuns.length > 0) {
+    lines.push("");
+    lines.push("Recent runs:");
+    for (const run of recentRuns) {
+      const icon = run.event === "run_complete" ? "✅" : "❌";
+      const issueStr = run.issueIid !== undefined ? `#${run.issueIid}` : "(no issue)";
+      const rawTitle = run.issueTitle ?? "(no title)";
+      const title = rawTitle.length > 40 ? rawTitle.slice(0, 37) + "..." : rawTitle;
+      const titlePadded = `"${title}"`.padEnd(44);
+      const durationStr = run.durationMs !== undefined ? formatMs(run.durationMs) : "-";
+      const dateStr = run.timestamp.slice(0, 10);
+      lines.push(`  ${icon} ${issueStr.padEnd(6)} ${titlePadded}  ${durationStr.padEnd(8)}  ${dateStr}`);
+    }
+  }
+
+  return lines.join("\n");
+}