nolo-cli 0.1.8 → 0.1.10

package/ai/agent/cliExecutor.ts

@@ -0,0 +1,733 @@
+/**
+ * CLI Executor - 通过命令行工具执行 AI 任务
+ *
+ * 设计为可扩展：当前支持 Copilot CLI、Gemini CLI、Codex CLI 与 Claude CLI。
+ *
+ * 注意：
+ * - CLI provider 与普通 model 路由共享 prompt / model / 最近文本上下文这些能力面
+ * - 但 CLI 不暴露本仓库可编排的 tool-calls 协议，因此这里只返回文本结果
+ * - 对缺少稳定增量输出协议的 CLI，流式接口允许退化为“完成后一次性回传”
+ *
+ * 使用方式：
+ *   import { executeCli } from "ai/agent/cliExecutor";
+  *   const result = await executeCli("copilot", prompt, { model: "claude-haiku-4.5" });
+ */
+
+import { exec, spawn } from "child_process";
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { buildCliPrompt } from "./cliPrompt";
+
+// ── 类型定义 ──────────────────────────────────────────────────────────────────
+
+/** 已支持的 CLI 工具。新增时在此联合类型追加，并在 EXECUTORS 里注册实现 */
+export type CliProvider = "copilot" | "gemini" | "codex" | "claude";
+
+export interface CliExecuteOptions {
+  model?: string;
+  timeout?: number;   // ms，默认 120_000
+  cwd?: string;
+  yolo?: boolean;     // 允许所有工具，默认 true（后台任务常用）
+}
+
+export interface CliExecuteResult {
+  text: string;       // 解析后的纯文本回复
+  raw: string;        // 原始 stdout
+  elapsed: number;    // 耗时 ms
+}
+
+type CliSessionMessage = {
+  role: "user" | "assistant";
+  content: string;
+};
+
+export interface CliSessionHandle {
+  sessionId: string;
+  provider: CliProvider;
+}
+
+export interface CliSessionState extends CliSessionHandle {
+  systemPrompt?: string;
+  options: CliExecuteOptions;
+  messages: CliSessionMessage[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface CliSessionTurnResult extends CliExecuteResult {
+  sessionId: string;
+}
+
+const cliSessions = new Map<string, CliSessionState>();
+
+// ── 各 provider 实现 ─────────────────────────────────────────────────────────
+
+/**
+ * Copilot CLI 执行器
+ * 调用 gh copilot -- -p "..." --silent
+ */
+function executeCopilot(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    model,
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "NO_COLOR=1",
+      "gh copilot --",
+      `-p ${JSON.stringify(prompt)}`,
+      "--silent",
+      "--disable-builtin-mcps",
+      "--stream off",
+      "--no-color",
+    ];
+    if (model) args.push(`--model ${model}`);
+    if (yolo) args.push("--yolo");
+
+    const cmd = args.join(" ");
+    const start = Date.now();
+
+    exec(
+      cmd,
+      { timeout, cwd, env: { ...process.env } },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.killed && (error as any).signal === "SIGTERM") {
+            return reject(new Error(`Copilot CLI timed out after ${timeout}ms`));
+          }
+          return reject(
+            new Error(`Copilot CLI failed: ${error.message}\nstderr: ${stderr}`)
+          );
+        }
+
+        const text = stdout
+          .split("\n")
+          .filter((l) => !l.includes("A new release of gh is available"))
+          .filter((l) => !l.includes("To upgrade, run:"))
+          .filter((l) => !l.includes("https://github.com/cli/cli/releases"))
+          .join("\n")
+          .trim();
+
+        resolve({ text, raw: stdout, elapsed: Date.now() - start });
+      }
+    );
+  });
+}
+
+function normalizeGeminiContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && typeof (part as any).text === "string") {
+          return (part as any).text;
+        }
+        return "";
+      })
+      .join("");
+  }
+  if (content && typeof content === "object" && typeof (content as any).text === "string") {
+    return (content as any).text;
+  }
+  return "";
+}
+
+function extractGeminiEventText(event: any): string {
+  if (event?.type === "message" && event.role === "assistant") {
+    return normalizeGeminiContent(event.content);
+  }
+  if (event?.type === "result" && typeof event.result === "string") {
+    return event.result;
+  }
+  return "";
+}
+
+function parseGeminiStreamJson(stdout: string): string {
+  const parts: string[] = [];
+
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    try {
+      const event = JSON.parse(trimmed);
+      const text = extractGeminiEventText(event);
+      if (text) parts.push(text);
+    } catch {
+      // ignore malformed lines
+    }
+  }
+
+  return parts.join("");
+}
+
+function executeGemini(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    model = "gemini-3-flash-preview",
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "NO_COLOR=1",
+      "NODE_OPTIONS='--no-deprecation'",
+      "gemini",
+      `-p ${JSON.stringify(prompt)}`,
+      "--output-format stream-json",
+      `-m ${JSON.stringify(model)}`,
+    ];
+    if (yolo) args.push("--yolo");
+    args.push("-e none");
+
+    const cmd = args.join(" ");
+    const start = Date.now();
+
+    exec(
+      cmd,
+      { timeout, cwd, env: { ...process.env } },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.killed && (error as any).signal === "SIGTERM") {
+            return reject(new Error(`Gemini CLI timed out after ${timeout}ms`));
+          }
+          return reject(
+            new Error(`Gemini CLI failed: ${error.message}\nstderr: ${stderr}`)
+          );
+        }
+
+        resolve({
+          text: parseGeminiStreamJson(stdout),
+          raw: stdout,
+          elapsed: Date.now() - start,
+        });
+      }
+    );
+  });
+}
+
+function executeCodex(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    model,
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const tempDir = mkdtempSync(join(tmpdir(), "codex-exec-"));
+    const outputFile = join(tempDir, "last-message.txt");
+    const args = [
+      "exec",
+      "--skip-git-repo-check",
+      "--ephemeral",
+      "--color",
+      "never",
+      "--output-last-message",
+      outputFile,
+      "--cd",
+      cwd,
+    ];
+    if (model) {
+      args.push("--model");
+      args.push(model);
+    }
+    if (yolo) {
+      args.push("--sandbox");
+      args.push("danger-full-access");
+    }
+    const start = Date.now();
+    const proc = spawn("codex", [...args, prompt], {
+      cwd,
+      env: { ...process.env, NO_COLOR: "1" },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Codex CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        rmSync(tempDir, { recursive: true, force: true });
+        reject(new Error(`Codex CLI exited with code ${code}\nstderr: ${stderr}`));
+        return;
+      }
+
+      let text = stdout.trim();
+      try {
+        const lastMessage = readFileSync(outputFile, "utf8").trim();
+        if (lastMessage) text = lastMessage;
+      } catch {
+        // Fall back to raw stdout when the output file is missing.
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+
+      resolve({
+        text,
+        raw: stdout,
+        elapsed: Date.now() - start,
+      });
+    });
+
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      rmSync(tempDir, { recursive: true, force: true });
+      reject(err);
+    });
+  });
+}
+
+function executeClaude(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    model,
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = ["-p", prompt];
+    if (model) {
+      args.push("--model");
+      args.push(model);
+    }
+    if (yolo) {
+      args.push("--permission-mode");
+      args.push("bypassPermissions");
+    }
+
+    const start = Date.now();
+    const proc = spawn("claude", args, {
+      cwd,
+      env: { ...process.env, NO_COLOR: "1" },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Claude CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Claude CLI exited with code ${code}\nstderr: ${stderr}`));
+        return;
+      }
+
+      resolve({
+        text: stdout.trim(),
+        raw: stdout,
+        elapsed: Date.now() - start,
+      });
+    });
+
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+// ── 注册表（新增 CLI 工具时在这里加） ────────────────────────────────────────
+
+const EXECUTORS: Record<
+  CliProvider,
+  (prompt: string, options: CliExecuteOptions) => Promise<CliExecuteResult>
+> = {
+  copilot: executeCopilot,
+  gemini: executeGemini,
+  codex: executeCodex,
+  claude: executeClaude,
+};
+
+function formatCliSessionTask(messages: CliSessionMessage[]): string {
+  return messages
+    .map((message, index) => {
+      const speaker = message.role === "user" ? "用户" : "助手";
+      return `[${index + 1}] ${speaker}\n${message.content.trim()}`;
+    })
+    .join("\n\n");
+}
+
+function buildCliSessionPrompt(session: CliSessionState, userInput: string): string {
+  const transcript = formatCliSessionTask([
+    ...session.messages,
+    { role: "user", content: userInput },
+  ]);
+
+  return buildCliPrompt(
+    session.systemPrompt,
+    [
+      "以下是当前对话，请基于完整上下文继续回答最后一条用户消息。",
+      transcript,
+    ].join("\n\n"),
+  );
+}
+
+function getCliSessionOrThrow(sessionId: string): CliSessionState {
+  const session = cliSessions.get(sessionId);
+  if (!session) {
+    throw new Error(`Unknown CLI session: "${sessionId}"`);
+  }
+  return session;
+}
+
+// ── 公开 API ──────────────────────────────────────────────────────────────────
+
+/**
+ * 执行 CLI 任务
+ *
+ * @param provider  CLI 工具类型（如 "copilot" | "gemini" | "codex" | "claude"）
+ * @param prompt    完整 prompt（system prompt 已由调用方拼好）
+ * @param options   执行选项
+ */
+export async function executeCli(
+  provider: CliProvider,
+  prompt: string,
+  options: CliExecuteOptions = {}
+): Promise<CliExecuteResult> {
+  const executor = EXECUTORS[provider];
+  if (!executor) {
+    throw new Error(`Unknown CLI provider: "${provider}". Supported: ${Object.keys(EXECUTORS).join(", ")}`);
+  }
+  return executor(prompt, options);
+}
+
+export { buildCliPrompt };
+
+export function startCliSession(
+  provider: CliProvider,
+  options: CliExecuteOptions & { systemPrompt?: string } = {},
+): CliSessionHandle {
+  if (!EXECUTORS[provider]) {
+    throw new Error(`Unknown CLI provider: "${provider}". Supported: ${Object.keys(EXECUTORS).join(", ")}`);
+  }
+
+  const sessionId = randomUUID();
+  cliSessions.set(sessionId, {
+    sessionId,
+    provider,
+    systemPrompt: options.systemPrompt,
+    options: {
+      model: options.model,
+      timeout: options.timeout,
+      cwd: options.cwd,
+      yolo: options.yolo,
+    },
+    messages: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  });
+
+  return { sessionId, provider };
+}
+
+export function getCliSession(sessionId: string): CliSessionState | null {
+  return cliSessions.get(sessionId) ?? null;
+}
+
+export function closeCliSession(sessionId: string): boolean {
+  return cliSessions.delete(sessionId);
+}
+
+export async function executeCliSessionTurn(
+  sessionId: string,
+  userInput: string,
+  options: Partial<CliExecuteOptions> = {},
+): Promise<CliSessionTurnResult> {
+  const trimmedInput = userInput.trim();
+  if (!trimmedInput) {
+    throw new Error("CLI session turn requires non-empty user input.");
+  }
+
+  const session = getCliSessionOrThrow(sessionId);
+  const prompt = buildCliSessionPrompt(session, trimmedInput);
+  const result = await executeCli(session.provider, prompt, {
+    ...session.options,
+    ...options,
+  });
+
+  session.messages.push(
+    { role: "user", content: trimmedInput },
+    { role: "assistant", content: result.text },
+  );
+  session.updatedAt = Date.now();
+
+  return {
+    ...result,
+    sessionId: session.sessionId,
+  };
+}
+
+export async function executeCliSessionTurnStreaming(
+  sessionId: string,
+  userInput: string,
+  options: Partial<CliExecuteOptions> & { onChunk: (chunk: string) => void },
+): Promise<CliSessionTurnResult> {
+  const trimmedInput = userInput.trim();
+  if (!trimmedInput) {
+    throw new Error("CLI session turn requires non-empty user input.");
+  }
+
+  const session = getCliSessionOrThrow(sessionId);
+  const prompt = buildCliSessionPrompt(session, trimmedInput);
+  const result = await executeCliStreaming(session.provider, prompt, {
+    ...session.options,
+    ...options,
+  });
+
+  session.messages.push(
+    { role: "user", content: trimmedInput },
+    { role: "assistant", content: result.text },
+  );
+  session.updatedAt = Date.now();
+
+  return {
+    ...result,
+    sessionId: session.sessionId,
+  };
+}
+
+/** 忽略 gh 版本更新提示行 */
+function filterNoiseLine(line: string): boolean {
+  return (
+    !line.includes("A new release of gh is available") &&
+    !line.includes("To upgrade, run:") &&
+    !line.includes("https://github.com/cli/cli/releases")
+  );
+}
+
+/**
+ * 流式执行 Copilot CLI，通过 onChunk 回调逐块返回输出
+ * 使用 spawn 替代 exec，不缓冲 stdout
+ */
+export function executeCliStreaming(
+  provider: CliProvider,
+  prompt: string,
+  options: CliExecuteOptions & { onChunk: (chunk: string) => void }
+): Promise<CliExecuteResult> {
+  if (provider === "gemini") {
+    return executeGeminiStreaming(prompt, options);
+  }
+  if (provider === "codex") {
+    return executeCli(provider, prompt, options).then((result) => {
+      if (result.text) options.onChunk(result.text);
+      return result;
+    });
+  }
+  if (provider === "claude") {
+    return executeCli(provider, prompt, options).then((result) => {
+      if (result.text) options.onChunk(result.text);
+      return result;
+    });
+  }
+  if (provider !== "copilot") {
+    return executeCli(provider, prompt, options);
+  }
+
+  const { model, timeout = 120_000, cwd = process.cwd(), yolo = true, onChunk } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "copilot", "--",
+      "-p", prompt,
+      "--silent",
+      "--disable-builtin-mcps",
+    ];
+    if (model) { args.push("--model"); args.push(model); }
+    if (yolo) args.push("--yolo");
+
+    const start = Date.now();
+    const proc = spawn("gh", args, {
+      cwd,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+
+    let raw = "";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Copilot CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      const chunk = data.toString();
+      raw += chunk;
+      // 过滤噪音行后再推送
+      const cleaned = chunk
+        .split("\n")
+        .filter(filterNoiseLine)
+        .join("\n");
+      if (cleaned) onChunk(cleaned);
+    });
+
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Copilot CLI exited with code ${code}`));
+        return;
+      }
+      const text = raw
+        .split("\n")
+        .filter(filterNoiseLine)
+        .join("\n")
+        .trim();
+      resolve({ text, raw, elapsed: Date.now() - start });
+    });
+
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+function executeGeminiStreaming(
+  prompt: string,
+  options: CliExecuteOptions & { onChunk: (chunk: string) => void }
+): Promise<CliExecuteResult> {
+  const {
+    model = "gemini-3-flash-preview",
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+    onChunk,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = ["-p", prompt, "--output-format", "stream-json", "-m", model];
+    if (yolo) args.push("--yolo");
+    args.push("-e", "none");
+
+    const start = Date.now();
+    const proc = spawn("gemini", args, {
+      cwd,
+      env: { ...process.env, NO_COLOR: "1", NODE_OPTIONS: "--no-deprecation" },
+    });
+
+    let raw = "";
+    let stderr = "";
+    let lineBuffer = "";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    const flushLineBuffer = () => {
+      const trimmed = lineBuffer.trim();
+      if (!trimmed) return;
+      try {
+        const event = JSON.parse(trimmed);
+        const text = extractGeminiEventText(event);
+        if (text) onChunk(text);
+      } catch {
+        // ignore partial or malformed lines
+      }
+      lineBuffer = "";
+    };
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Gemini CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      const chunk = data.toString();
+      raw += chunk;
+      lineBuffer += chunk;
+
+      let newlineIndex = lineBuffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = lineBuffer.slice(0, newlineIndex).trim();
+        lineBuffer = lineBuffer.slice(newlineIndex + 1);
+        if (line) {
+          try {
+            const event = JSON.parse(line);
+            const text = extractGeminiEventText(event);
+            if (text) onChunk(text);
+          } catch {
+            // ignore malformed lines
+          }
+        }
+        newlineIndex = lineBuffer.indexOf("\n");
+      }
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      flushLineBuffer();
+
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Gemini CLI exited with code ${code}\nstderr: ${stderr}`));
+        return;
+      }
+
+      resolve({
+        text: parseGeminiStreamJson(raw),
+        raw,
+        elapsed: Date.now() - start,
+      });
+    });
+
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}