glab-agent 0.1.0

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

@@ -0,0 +1,244 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+
+import { compactText, truncate } from "../text.js";
+import type { GitlabIssue } from "./gitlab-glab-client.js";
+import type { AgentProvider } from "./agent-provider.js";
+import type { WorktreeInfo } from "./worktree-manager.js";
+import type { Logger } from "./logger.js";
+
+const execFileAsync = promisify(execFile);
+
+export interface AgentRunResult {
+  summary: string;
+  outputPath: string;
+}
+
+export interface AgentRunContext {
+  todoId?: number;
+  signal?: AbortSignal;
+}
+
+export interface AgentRunner {
+  run(issue: GitlabIssue, worktree: WorktreeInfo, context?: AgentRunContext): Promise<AgentRunResult>;
+}
+
+export interface AgentRunnerOptions {
+  execFileImpl?: typeof execFileAsync;
+  env?: NodeJS.ProcessEnv;
+  repoPath?: string;
+  gitlabHost?: string;
+  gitlabProjectId?: number;
+  agentDefinition?: import("./agent-config.js").AgentDefinition;
+  logger?: Logger;
+  /** Override timeout in seconds; falls back to agentDefinition.timeout_seconds if not set. */
+  timeoutSeconds?: number;
+}
+
+export class AgentRunnerError extends Error {
+  readonly summary: string;
+
+  readonly outputPath: string;
+
+  constructor(message: string, summary: string, outputPath: string) {
+    super(message);
+    this.name = "AgentRunnerError";
+    this.summary = summary;
+    this.outputPath = outputPath;
+  }
+}
+
+export function isSmokeIssue(issue: Pick<GitlabIssue, "title" | "description">): boolean {
+  return issue.title.startsWith("[smoke]") || issue.description.includes("Smoke test run:");
+}
+
+export interface AgentPromptContext {
+  issueIid: number;
+  issueTitle: string;
+  gitlabHost: string;
+  gitlabProjectId: number;
+  worktreePath: string;
+  branch: string;
+  provider: AgentProvider;
+  todoId?: number;
+  preamble?: string;
+  append?: string;
+  templatePath?: string;
+}
+
+export function buildBasePrompt(ctx: AgentPromptContext): string {
+  const p = ctx.gitlabProjectId;
+  const iid = ctx.issueIid;
+  const todoId = ctx.todoId;
+  return [
+    "你是这个项目的团队成员（AI agent），被分配处理一个 GitLab 任务。",
+    "你在项目的独立工作分支中，可以读代码、读文档、运行命令、操作 GitLab。",
+    "",
+    "## 任务",
+    `Issue #${iid}: ${truncate(ctx.issueTitle, 200)}`,
+    "",
+    "## GitLab 环境",
+    `- Host: ${ctx.gitlabHost} | Project ID: ${p}`,
+    "- GITLAB_TOKEN 和 GITLAB_HOST 已配置，可直接使用 glab 命令。",
+    "",
+    "## 基本原则",
+    "- **永远不直接 push 到默认分支**。所有代码改动通过 MR。",
+    "- **每次 @mention 都要回复**。即使不做修改，也要在 issue 上说明原因。",
+    "- **先理解再行动**。读完 issue 详情、评论、项目文档后再决定做什么。",
+    "- **参考项目设计原则**。阅读 docs/design-principles.md 和 README.md 了解项目目标。",
+    "",
+    "## 工作流程",
+    "",
+    "### 1. 理解任务",
+    `- 读 issue 详情: glab api projects/${p}/issues/${iid}`,
+    `- 读评论: glab api projects/${p}/issues/${iid}/notes`,
+    `- 读关联 issue: glab api projects/${p}/issues/${iid}/links`,
+    "- 阅读项目代码和文档，理解架构和设计原则。",
+    "- 如果存在 .glab-agent/wiki/index.md，先查阅项目知识库了解已有经验和踩坑记录。",
+    "",
+    "### 2. 判断并行动",
+    "- **明确的技术任务**（bug fix、功能实现、重构、文档）→ 实现它",
+    "- **产品方向/架构大改/引入新外部依赖** → 在 issue 上回复评估意见，不要直接实现",
+    "- **信息不足** → 在 issue 上提问，不要猜测需求",
+    "",
+    "### 3. 管理看板状态",
+    `- 开始工作时: glab api --method PUT projects/${p}/issues/${iid} --raw-field "labels=In Progress"`,
+    `- 创建 MR 后: glab api --method PUT projects/${p}/issues/${iid} --raw-field "labels=In Review"`,
+    `- 遇到无法解决的问题: glab api --method PUT projects/${p}/issues/${iid} --raw-field "labels=Error"`,
+    todoId ? `- 处理完成后: glab api --method POST todos/${todoId}/mark_as_done` : "",
+    "",
+    "### 4. 代码交付（仅当决定实现时）",
+    "1. 在当前工作目录中编码和修改。",
+    "2. 运行测试验证。",
+    "3. git add、git commit。",
+    "4. git push 并创建 MR（target_branch 用默认分支，通过 git symbolic-ref refs/remotes/origin/HEAD 查询）。",
+    `   glab api --method POST projects/${p}/merge_requests --raw-field "source_branch=${ctx.branch}" --raw-field "target_branch=<默认分支>" --raw-field "title=<MR标题>" --raw-field "description=<简要说明>"`,
+    "5. 不要关闭 issue。",
+    "",
+    "### 5. 沟通",
+    `- 发评论: glab api --method POST projects/${p}/issues/${iid}/notes --raw-field "body=<内容>"`,
+    "- 用 Markdown 格式，结构清晰。",
+    "- 像团队成员一样沟通，自然、简洁、有判断力。",
+    "- **不要**暴露内部实现细节（worktree 路径、执行器名称、PID 等）。",
+    "- **不要**输出内部思考过程。",
+    "",
+    "## 当前环境",
+    `- 分支: ${ctx.branch}`,
+    "- 工作目录: 项目的独立工作副本",
+    "",
+    "## 最终输出",
+    "标准输出不超过 5 行的简短总结（不是 GitLab 评论）。"
+  ].filter(Boolean).join("\n");
+}
+
+export function buildAgentPrompt(ctx: AgentPromptContext): string {
+  let prompt = buildBasePrompt(ctx);
+
+  if (ctx.preamble) {
+    prompt = ctx.preamble.trimEnd() + "\n\n" + prompt;
+  }
+
+  // Skills are injected via .claude/skills/*.md files (injectSkillFiles),
+  // Claude Code loads them automatically. No need to duplicate in prompt.
+
+  if (ctx.append) {
+    prompt = prompt + "\n\n" + ctx.append.trimEnd();
+  }
+
+  return prompt;
+}
+
+export async function createOutputPath(prefix: string, issueIid: number): Promise<string> {
+  const outputDir = await mkdtemp(path.join(tmpdir(), `${prefix}-issue-${issueIid}-`));
+  return path.join(outputDir, "last-message.txt");
+}
+
+export async function writeSummary(outputPath: string, summary: string): Promise<void> {
+  await writeFile(outputPath, truncate(compactText(summary), 600), "utf8");
+}
+
+export async function readSummary(outputPath: string, fallback: string): Promise<string> {
+  try {
+    const content = await readFile(outputPath, "utf8");
+    return truncate(compactText(content || fallback), 600);
+  } catch {
+    return truncate(compactText(fallback), 600);
+  }
+}
+
+export async function runSmokeTestChecks(
+  issue: GitlabIssue,
+  worktree: WorktreeInfo,
+  outputPath: string,
+  execFileImpl: typeof execFileAsync,
+  env: NodeJS.ProcessEnv,
+  repoPath?: string
+): Promise<AgentRunResult> {
+  const lines = [
+    `Smoke test issue: ${truncate(issue.title, 200)}`,
+    `Worktree: ${worktree.worktreePath}`
+  ];
+
+  try {
+    const gitStatus = await execInWorktree(execFileImpl, "git", ["status", "--short"], worktree.worktreePath, env);
+    lines.push(`git status --short: ${gitStatus.stdout ? compactText(gitStatus.stdout) : "(clean)"}`);
+
+    const testCwd = repoPath ?? worktree.worktreePath;
+    const testEnv = cleanEnvForSubprocess(env);
+    const testResult = await execInWorktree(execFileImpl, "pnpm", ["test"], testCwd, testEnv);
+    lines.push(`pnpm test (${testCwd}): ok`);
+    if (testResult.stdout) {
+      lines.push(truncate(compactText(testResult.stdout), 220));
+    }
+
+    const summary = truncate(compactText(lines.join("\n")), 600);
+    await writeFile(outputPath, summary, "utf8");
+
+    return {
+      summary,
+      outputPath
+    };
+  } catch (error) {
+    const summary = truncate(compactText(`Smoke test failed: ${String(error)}`), 600);
+    await writeFile(outputPath, summary, "utf8");
+    throw new AgentRunnerError("Smoke test execution failed.", summary, outputPath);
+  }
+}
+
+/**
+ * Remove env vars that tsx / pnpm run-script inject into the watcher process
+ * and that can break a fresh `pnpm test` subprocess (wrong NODE_PATH, stale
+ * npm lifecycle metadata, etc.).
+ */
+function cleanEnvForSubprocess(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+  const cleaned: NodeJS.ProcessEnv = { ...env };
+  // tsx injects its own module dirs into NODE_PATH; strip it so vitest resolves
+  // modules from the project's own node_modules instead.
+  delete cleaned.NODE_PATH;
+  // pnpm run-script sets these; a nested `pnpm test` invocation should start
+  // fresh rather than inheriting the parent script's lifecycle context.
+  for (const key of Object.keys(cleaned)) {
+    if (key.startsWith("npm_") || key === "PNPM_SCRIPT_SRC_DIR") {
+      delete cleaned[key];
+    }
+  }
+  return cleaned;
+}
+
+async function execInWorktree(
+  execFileImpl: typeof execFileAsync,
+  file: string,
+  args: string[],
+  cwd: string,
+  env: NodeJS.ProcessEnv
+): Promise<{ stdout: string; stderr: string }> {
+  return execFileImpl(file, args, {
+    cwd,
+    env,
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+}

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

@@ -0,0 +1,136 @@
+import { execFile } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+
+import { compactText, truncate } from "../text.js";
+import type { GitlabIssue } from "./gitlab-glab-client.js";
+import type { WorktreeInfo } from "./worktree-manager.js";
+import {
+  AgentRunnerError,
+  type AgentRunContext,
+  type AgentRunResult,
+  type AgentRunner,
+  type AgentRunnerOptions,
+  buildAgentPrompt,
+  createOutputPath,
+  isSmokeIssue,
+  runSmokeTestChecks
+} from "./agent-runner.js";
+import { createLogger, type Logger } from "./logger.js";
+
+const execFileAsync = promisify(execFile);
+
+export class ClaudeRunner implements AgentRunner {
+  private readonly execFileImpl: typeof execFileAsync;
+
+  private readonly env: NodeJS.ProcessEnv;
+
+  private readonly repoPath?: string;
+
+  private readonly gitlabHost: string;
+
+  private readonly gitlabProjectId: number;
+
+  private readonly agentDefinition?: import("./agent-config.js").AgentDefinition;
+
+  private readonly logger: Logger;
+
+  private readonly timeoutSeconds?: number;
+
+  constructor(options: AgentRunnerOptions = {}) {
+    this.execFileImpl = options.execFileImpl ?? execFileAsync;
+    this.env = options.env ?? process.env;
+    this.repoPath = options.repoPath;
+    this.gitlabHost = options.gitlabHost ?? "";
+    this.gitlabProjectId = options.gitlabProjectId ?? 0;
+    this.agentDefinition = options.agentDefinition;
+    this.logger = options.logger ?? createLogger("runner", options.agentDefinition?.name);
+    this.timeoutSeconds = options.timeoutSeconds ?? options.agentDefinition?.timeout_seconds;
+  }
+
+  async run(issue: GitlabIssue, worktree: WorktreeInfo, context?: AgentRunContext): Promise<AgentRunResult> {
+    const signal = context?.signal;
+    const outputPath = await createOutputPath("claude", issue.iid);
+
+    if (isSmokeIssue(issue)) {
+      return runSmokeTestChecks(issue, worktree, outputPath, this.execFileImpl, this.env, this.repoPath);
+    }
+
+    const prompt = buildAgentPrompt({
+      issueIid: issue.iid,
+      issueTitle: issue.title,
+      gitlabHost: this.gitlabHost,
+      gitlabProjectId: this.gitlabProjectId,
+      worktreePath: worktree.worktreePath,
+      branch: worktree.branch,
+      provider: "claude",
+      todoId: context?.todoId,
+      preamble: this.agentDefinition?.prompt.preamble,
+      append: this.agentDefinition?.prompt.append,
+      // skills injected via .claude/skills/*.md files, not in prompt
+    });
+    const claudeCommand = resolveClaudeCommand(this.env);
+
+    this.logger.info(`Executing: ${claudeCommand} -p ... cwd=${worktree.worktreePath}`);
+    this.logger.info(`Prompt (${prompt.length} chars): issue #${issue.iid} "${issue.title}"`);
+
+    const timeoutMs = this.timeoutSeconds ? this.timeoutSeconds * 1000 : 0;
+    if (this.timeoutSeconds) {
+      this.logger.info(`Timeout: ${this.timeoutSeconds}s`);
+    }
+
+    try {
+      const args = ["-p", "--output-format", "text", "--permission-mode", "bypassPermissions"];
+      if (this.agentDefinition?.model) {
+        args.push("--model", this.agentDefinition.model);
+      }
+      args.push(prompt);
+
+      const { stdout } = await this.execFileImpl(
+        claudeCommand,
+        args,
+        {
+          cwd: worktree.worktreePath,
+          encoding: "utf8",
+          maxBuffer: 10 * 1024 * 1024,
+          env: this.env,
+          ...(timeoutMs > 0 ? { timeout: timeoutMs, killSignal: "SIGTERM" } : {}),
+          ...(signal ? { signal } : {})
+        }
+      );
+
+      const summary = truncate(compactText(stdout || "Claude Code finished without a final summary."), 600);
+      this.logger.info(`Finished. Output: ${outputPath}`);
+      await writeFile(outputPath, summary, "utf8");
+
+      return {
+        summary,
+        outputPath
+      };
+    } catch (error) {
+      const execError = error as { stdout?: string; stderr?: string; message?: string; killed?: boolean };
+      const isTimeout = execError.killed === true && timeoutMs > 0;
+      const summary = isTimeout
+        ? `Timed out after ${this.timeoutSeconds}s`
+        : truncate(
+            compactText(execError.stdout || execError.stderr || execError.message || "Claude Code execution failed."),
+            600
+          );
+      if (isTimeout) {
+        this.logger.error(`Timed out after ${this.timeoutSeconds}s.`);
+      } else {
+        this.logger.error(`Failed. stderr: ${execError.stderr?.slice(0, 300) ?? "(none)"}`);
+      }
+      await writeFile(outputPath, summary, "utf8");
+      throw new AgentRunnerError(
+        isTimeout ? `Claude Code timed out after ${this.timeoutSeconds}s.` : "Claude Code execution failed.",
+        summary,
+        outputPath
+      );
+    }
+  }
+}
+
+export function resolveClaudeCommand(env: NodeJS.ProcessEnv = process.env): string {
+  return env.CLAUDE_BIN?.trim() || "claude";
+}