nolo-cli 0.1.40 → 0.1.42

package/ai/agent/cliExecutor.ts

@@ -1,7 +1,7 @@
 /**
  * CLI Executor - 通过命令行工具执行 AI 任务
  *
- * 设计为可扩展：当前支持 Copilot CLI、Gemini CLI、Codex CLI、Claude CLI 与 Antigravity CLI。
+ * 设计为可扩展：当前支持 Copilot CLI、Gemini CLI、Codex CLI、Claude CLI、Antigravity CLI 与 Qoder CLI。
  *
  * 注意：
  * - CLI provider 与普通 model 路由共享 prompt / model / 最近文本上下文这些能力面
@@ -18,13 +18,14 @@ import { randomUUID } from "node:crypto";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
+import { StringDecoder } from "node:string_decoder";
 import { resolveLaunchableCodexCommand } from "../../connector-experimental/codexBinary";
 import { buildCliPrompt } from "./cliPrompt";
 
 // ── 类型定义 ──────────────────────────────────────────────────────────────────
 
 /** 已支持的 CLI 工具。新增时在此联合类型追加，并在 EXECUTORS 里注册实现 */
-export type CliProvider = "copilot" | "gemini" | "codex" | "claude" | "agy";
+export type CliProvider = "copilot" | "gemini" | "codex" | "claude" | "agy" | "qoder";
 
 /**
  * CLI provider 图片输入。
@@ -41,7 +42,7 @@ export interface CliImageInput {
 
 export interface CliExecuteOptions {
   model?: string;
-  timeout?: number;   // ms，默认 120_000
+  timeout?: number;   // ms；各 CLI executor 可按任务类型设置自己的默认值
   cwd?: string;
   env?: Record<string, string | undefined>;
   yolo?: boolean;     // 允许所有工具，默认 true（后台任务常用）
@@ -70,6 +71,18 @@ type CliSessionMessage = {
   content: string;
 };
 
+const DEFAULT_AGY_TIMEOUT_MS = 600_000;
+const BUFFERED_STREAMING_PROVIDERS = new Set<CliProvider>([
+  "codex",
+  "claude",
+  "agy",
+  "qoder",
+]);
+
+export function isBufferedCliStreamingProvider(provider: CliProvider): boolean {
+  return BUFFERED_STREAMING_PROVIDERS.has(provider);
+}
+
 export interface CliSessionHandle {
   sessionId: string;
   provider: CliProvider;
@@ -157,12 +170,39 @@ function normalizeProxyEnv(env: Record<string, string | undefined>): Record<stri
 }
 
 function buildCliProcessEnv(extraEnv?: Record<string, string | undefined>) {
+  const baseEnv = {
+    ...process.env,
+    ...extraEnv,
+    NO_COLOR: "1",
+  };
+
+  // Enhance PATH on macOS so GUI-launched app can find brew/local tools
+  if (process.platform === "darwin") {
+    const defaultMacPaths = [
+      `${process.env.HOME || ""}/.local/bin`,
+      "/opt/homebrew/bin",
+      "/opt/homebrew/sbin",
+      "/usr/local/bin",
+      "/usr/local/sbin",
+      `${process.env.HOME || ""}/.bun/bin`,
+      `${process.env.HOME || ""}/Library/pnpm`,
+      `${process.env.HOME || ""}/.npm-global/bin`,
+      `${process.env.HOME || ""}/bin`,
+    ];
+    const existingPath = baseEnv.PATH || "/usr/bin:/bin:/usr/sbin:/sbin";
+    const paths = existingPath.split(":");
+    for (const p of defaultMacPaths) {
+      if (p && !paths.includes(p)) {
+        paths.unshift(p); // Put brew/local paths at the front
+      }
+    }
+    baseEnv.PATH = paths.join(":");
+  }
+
   return Object.fromEntries(
-    Object.entries(normalizeProxyEnv({
-      ...process.env,
-      ...extraEnv,
-      NO_COLOR: "1",
-    })).filter((entry): entry is [string, string] => typeof entry[1] === "string")
+    Object.entries(normalizeProxyEnv(baseEnv)).filter(
+      (entry): entry is [string, string] => typeof entry[1] === "string"
+    )
   );
 }
 
@@ -176,6 +216,8 @@ function getCliProviderLabel(provider: CliProvider): string {
       return "Copilot CLI";
     case "agy":
       return "Antigravity CLI";
+    case "qoder":
+      return "Qoder CLI";
     case "gemini":
       return "Gemini CLI";
   }
@@ -192,7 +234,7 @@ function supportsModel(provider: CliProvider): boolean {
 }
 
 function supportsReasoningEffort(provider: CliProvider): boolean {
-  return provider === "claude" || provider === "copilot";
+  return provider === "claude" || provider === "copilot" || provider === "qoder";
 }
 
 function shouldPassClaudeModel(options: CliExecuteOptions): boolean {
@@ -624,8 +666,8 @@ function executeCodex(
       env: buildCliProcessEnv(options.env),
       stdio: ["ignore", "pipe", "pipe"],
     });
-    let stdout = "";
-    let stderr = "";
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
     let timer: ReturnType<typeof setTimeout> | undefined;
 
     if (timeout > 0) {
@@ -636,22 +678,24 @@ function executeCodex(
     }
 
     proc.stdout.on("data", (data: Buffer) => {
-      stdout += data.toString();
+      stdout.write(data);
     });
 
     proc.stderr.on("data", (data: Buffer) => {
-      stderr += data.toString();
+      stderr.write(data);
     });
 
     proc.on("close", (code) => {
       if (timer) clearTimeout(timer);
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
       if (code !== 0 && code !== null) {
         rmSync(tempDir, { recursive: true, force: true });
-        reject(new Error(`Codex CLI exited with code ${code}\nstderr: ${stderr}`));
+        reject(new Error(`Codex CLI exited with code ${code}\nstderr: ${stderrText}`));
         return;
       }
 
-      let text = stdout.trim();
+      let text = stdoutText.trim();
       try {
         const lastMessage = readFileSync(outputFile, "utf8").trim();
         if (lastMessage) text = lastMessage;
@@ -663,7 +707,7 @@ function executeCodex(
 
       resolve({
         text,
-        raw: stdout,
+        raw: stdoutText,
         elapsed: Date.now() - start,
       });
     });
@@ -714,8 +758,8 @@ function executeClaude(
       env: buildCliProcessEnv(options.env),
       stdio: ["ignore", "pipe", "pipe"],
     });
-    let stdout = "";
-    let stderr = "";
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
     let timer: ReturnType<typeof setTimeout> | undefined;
 
     if (timeout > 0) {
@@ -726,23 +770,25 @@ function executeClaude(
     }
 
     proc.stdout.on("data", (data: Buffer) => {
-      stdout += data.toString();
+      stdout.write(data);
     });
 
     proc.stderr.on("data", (data: Buffer) => {
-      stderr += data.toString();
+      stderr.write(data);
     });
 
     proc.on("close", (code) => {
       if (timer) clearTimeout(timer);
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
       if (code !== 0 && code !== null) {
-        reject(new Error(`Claude CLI exited with code ${code}\nstderr: ${stderr}`));
+        reject(new Error(`Claude CLI exited with code ${code}\nstderr: ${stderrText}`));
         return;
       }
 
       resolve({
-        text: stdout.trim(),
-        raw: stdout,
+        text: stdoutText.trim(),
+        raw: stdoutText,
         elapsed: Date.now() - start,
       });
     });
@@ -758,12 +804,78 @@ function formatCliTimeout(timeoutMs: number) {
   return `${Math.max(1, Math.ceil(timeoutMs / 1000))}s`;
 }
 
+function tailText(value: string, maxChars = 1200): string {
+  if (value.length <= maxChars) return value;
+  return value.slice(value.length - maxChars);
+}
+
+function createUtf8Collector() {
+  const decoder = new StringDecoder("utf8");
+  let text = "";
+  let ended = false;
+  const finish = () => {
+    if (ended) return "";
+    ended = true;
+    const chunk = decoder.end();
+    if (chunk) text += chunk;
+    return chunk;
+  };
+  return {
+    write(data: Buffer): string {
+      if (ended) return "";
+      const chunk = decoder.write(data);
+      text += chunk;
+      return chunk;
+    },
+    finish,
+    end(): string {
+      finish();
+      return text;
+    },
+    get text() {
+      return text;
+    },
+  };
+}
+
+function terminateCliProcessGroup(
+  proc: ReturnType<typeof spawn>,
+  signal: NodeJS.Signals
+) {
+  const pid = typeof proc.pid === "number" ? proc.pid : 0;
+  if (pid > 0 && process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {
+      // Fall back to the child process if the group is unavailable.
+    }
+  }
+  try {
+    proc.kill(signal);
+  } catch {
+    // Best effort cleanup only.
+  }
+}
+
+function buildAgyTimeoutError(timeout: number, stdout: string, stderr: string) {
+  const parts = [
+    `Antigravity CLI timed out after ${timeout}ms.`,
+    "agy print mode is agentic and can keep waiting for the conversation to become fully idle; prefer shorter scoped prompts or split the task into multiple turns.",
+  ];
+  const stdoutTail = tailText(stdout).trim();
+  const stderrTail = tailText(stderr).trim();
+  if (stdoutTail) parts.push(`stdout tail:\n${stdoutTail}`);
+  if (stderrTail) parts.push(`stderr tail:\n${stderrTail}`);
+  return new Error(parts.join("\n"));
+}
+
 function executeAgy(
   prompt: string,
   options: CliExecuteOptions
 ): Promise<CliExecuteResult> {
   const {
-    timeout = 120_000,
+    timeout = DEFAULT_AGY_TIMEOUT_MS,
     cwd = process.cwd(),
     yolo = true,
   } = options;
@@ -786,42 +898,142 @@ function executeAgy(
       cwd,
       env: buildCliProcessEnv(options.env),
       stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
     });
-    let stdout = "";
-    let stderr = "";
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
     let timer: ReturnType<typeof setTimeout> | undefined;
+    let forceTimer: ReturnType<typeof setTimeout> | undefined;
+    let settled = false;
+
+    const clearTimers = () => {
+      if (timer) clearTimeout(timer);
+      if (forceTimer) clearTimeout(forceTimer);
+    };
 
     if (timeout > 0) {
       timer = setTimeout(() => {
-        proc.kill("SIGTERM");
-        reject(new Error(`Antigravity CLI timed out after ${timeout}ms`));
+        if (settled) return;
+        settled = true;
+        terminateCliProcessGroup(proc, "SIGTERM");
+        forceTimer = setTimeout(() => {
+          terminateCliProcessGroup(proc, "SIGKILL");
+        }, 3_000);
+        reject(buildAgyTimeoutError(timeout, stdout.end(), stderr.end()));
       }, timeout + 1_000);
     }
 
     proc.stdout.on("data", (data: Buffer) => {
-      stdout += data.toString();
+      stdout.write(data);
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr.write(data);
+    });
+
+    proc.on("close", (code) => {
+      if (settled) {
+        clearTimers();
+        return;
+      }
+      settled = true;
+      clearTimers();
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
+      if (code !== 0 && code !== null) {
+        console.error("[cliExecutor] agy process exited with non-zero code:", code, "stderr:", stderrText);
+        reject(new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderrText}`));
+        return;
+      }
+
+      resolve({
+        text: stdoutText.trim(),
+        raw: stdoutText,
+        elapsed: Date.now() - start,
+      });
+    });
+
+    proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      console.error("[cliExecutor] agy process error event:", err);
+      reject(err);
+    });
+  });
+}
+
+function executeQoder(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    model,
+    reasoningEffort,
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = ["-p", prompt, "--cwd", cwd];
+    if (model) {
+      args.push("--model");
+      args.push(model);
+    }
+    if (reasoningEffort) {
+      args.push("--reasoning-effort");
+      args.push(reasoningEffort);
+    }
+    if (yolo) {
+      args.push("--dangerously-skip-permissions");
+    }
+
+    const start = Date.now();
+    const proc = spawn("qoder", args, {
+      cwd,
+      env: buildCliProcessEnv(options.env),
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Qoder CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      stdout.write(data);
     });
 
     proc.stderr.on("data", (data: Buffer) => {
-      stderr += data.toString();
+      stderr.write(data);
     });
 
     proc.on("close", (code) => {
       if (timer) clearTimeout(timer);
+      const stdoutText = stdout.end();
+      const stderrText = stderr.end();
       if (code !== 0 && code !== null) {
-        reject(new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderr}`));
+        console.error("[cliExecutor] qoder process exited with non-zero code:", code, "stderr:", stderrText);
+        reject(new Error(`Qoder CLI exited with code ${code}\nstderr: ${stderrText}`));
         return;
       }
 
       resolve({
-        text: stdout.trim(),
-        raw: stdout,
+        text: stdoutText.trim(),
+        raw: stdoutText,
         elapsed: Date.now() - start,
       });
     });
 
     proc.on("error", (err) => {
       if (timer) clearTimeout(timer);
+      console.error("[cliExecutor] qoder process error event:", err);
       reject(err);
     });
   });
@@ -838,6 +1050,7 @@ const EXECUTORS: Record<
   codex: executeCodex,
   claude: executeClaude,
   agy: executeAgy,
+  qoder: executeQoder,
 };
 
 function formatCliSessionTask(messages: CliSessionMessage[]): string {
@@ -874,7 +1087,7 @@ function getCliSessionOrThrow(sessionId: string): CliSessionState {
 /**
  * 执行 CLI 任务
  *
- * @param provider  CLI 工具类型（如 "copilot" | "gemini" | "codex" | "claude" | "agy"）
+ * @param provider  CLI 工具类型（如 "copilot" | "gemini" | "codex" | "claude" | "agy" | "qoder"）
  * @param prompt    完整 prompt（system prompt 已由调用方拼好）
  * @param options   执行选项
  */
@@ -1060,7 +1273,7 @@ export function executeCliStreaming(
       })
     );
   }
-  if (provider === "agy") {
+  if (provider === "agy" || provider === "qoder") {
     return withCleanup(
       executor(resolved.prompt, resolved.options).then((result) => {
         const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
@@ -1099,10 +1312,10 @@ export function executeCliStreaming(
     const start = Date.now();
     const proc = spawn("gh", args, {
       cwd,
-      env: { ...process.env, NO_COLOR: "1" },
+      env: buildCliProcessEnv(resolved.options.env),
     });
 
-    let raw = "";
+    const stdout = createUtf8Collector();
     let timer: ReturnType<typeof setTimeout> | undefined;
 
     if (timeout > 0) {
@@ -1113,8 +1326,7 @@ export function executeCliStreaming(
     }
 
     proc.stdout.on("data", (data: Buffer) => {
-      const chunk = data.toString();
-      raw += chunk;
+      const chunk = stdout.write(data);
       // 过滤噪音行后再推送
       const cleaned = chunk
         .split("\n")
@@ -1125,6 +1337,7 @@ export function executeCliStreaming(
 
     proc.on("close", (code) => {
       if (timer) clearTimeout(timer);
+      const raw = stdout.end();
       if (code !== 0 && code !== null) {
         reject(new Error(`Copilot CLI exited with code ${code}`));
         return;
@@ -1169,11 +1382,14 @@ function executeGeminiStreaming(
     const start = Date.now();
     const proc = spawn("gemini", args, {
       cwd,
-      env: { ...process.env, NO_COLOR: "1", NODE_OPTIONS: "--no-deprecation" },
+      env: buildCliProcessEnv({
+        ...options.env,
+        NODE_OPTIONS: "--no-deprecation",
+      }),
     });
 
-    let raw = "";
-    let stderr = "";
+    const stdout = createUtf8Collector();
+    const stderr = createUtf8Collector();
     let lineBuffer = "";
     let timer: ReturnType<typeof setTimeout> | undefined;
 
@@ -1198,8 +1414,7 @@ function executeGeminiStreaming(
     }
 
     proc.stdout.on("data", (data: Buffer) => {
-      const chunk = data.toString();
-      raw += chunk;
+      const chunk = stdout.write(data);
       lineBuffer += chunk;
 
       let newlineIndex = lineBuffer.indexOf("\n");
@@ -1220,15 +1435,18 @@ function executeGeminiStreaming(
     });
 
     proc.stderr.on("data", (data: Buffer) => {
-      stderr += data.toString();
+      stderr.write(data);
     });
 
     proc.on("close", (code) => {
       if (timer) clearTimeout(timer);
+      lineBuffer += stdout.finish();
+      const raw = stdout.text;
+      const stderrText = stderr.end();
       flushLineBuffer();
 
       if (code !== 0 && code !== null) {
-        reject(new Error(`Gemini CLI exited with code ${code}\nstderr: ${stderr}`));
+        reject(new Error(`Gemini CLI exited with code ${code}\nstderr: ${stderrText}`));
         return;
       }
 

package/ai/agent/contextCompiler.ts

@@ -0,0 +1,107 @@
+// Simple deterministic hash for cache-key purposes (browser + server compatible)
+function createHash(_algo: string) {
+  let buf = "";
+  return {
+    update(s: string) { buf += s; return this; },
+    digest(_enc: string) {
+      // FNV-1a 32-bit, hex-padded to 8 chars
+      let h = 0x811c9dc5;
+      for (let i = 0; i < buf.length; i++) {
+        h ^= buf.charCodeAt(i);
+        h = (h * 0x01000193) >>> 0;
+      }
+      return h.toString(16).padStart(8, "0");
+    },
+  };
+}
+
+export type ContextLayerOwner =
+  | "platform"
+  | "agent"
+  | "user"
+  | "runtime";
+
+export type ContextLayerCacheScope = "static" | "session" | "turn";
+
+export type ContextLayer = {
+  id: string;
+  owner: ContextLayerOwner;
+  content?: string | null;
+  tokenBudget?: number;
+  cacheScope?: ContextLayerCacheScope;
+};
+
+export type CompiledContextLayer = {
+  id: string;
+  owner: ContextLayerOwner;
+  content: string;
+  cacheScope: ContextLayerCacheScope;
+  charCount: number;
+  estimatedTokens: number;
+  tokenBudget?: number;
+  budgetStatus?: "within-budget" | "over-budget";
+};
+
+export type CompiledContext = {
+  content: string;
+  layers: CompiledContextLayer[];
+  cacheProfile: {
+    stablePrefixHash: string;
+    stablePrefixLayerIds: string[];
+    stablePrefixCharCount: number;
+    stablePrefixEstimatedTokens: number;
+  };
+};
+
+const hasLayerContent = (
+  layer: ContextLayer
+): layer is ContextLayer & { content: string } => Boolean(layer.content);
+
+export const estimateContextTokens = (content: string): number =>
+  Math.ceil(content.length / 4);
+
+export const compileContextLayers = (
+  layers: ContextLayer[]
+): CompiledContext => {
+  const compiledLayers = layers
+    .filter(hasLayerContent)
+    .map((layer): CompiledContextLayer => {
+      const estimatedTokens = estimateContextTokens(layer.content);
+      return {
+        id: layer.id,
+        owner: layer.owner,
+        content: layer.content,
+        cacheScope: layer.cacheScope ?? "turn",
+        charCount: layer.content.length,
+        estimatedTokens,
+        tokenBudget: layer.tokenBudget,
+        budgetStatus:
+          typeof layer.tokenBudget === "number"
+            ? estimatedTokens <= layer.tokenBudget
+              ? "within-budget"
+              : "over-budget"
+            : undefined,
+      };
+    });
+  const stablePrefixLayers: CompiledContextLayer[] = [];
+  for (const layer of compiledLayers) {
+    if (layer.cacheScope === "turn") break;
+    stablePrefixLayers.push(layer);
+  }
+  const stablePrefixContent = stablePrefixLayers
+    .map((layer) => layer.content)
+    .join("\n\n");
+
+  return {
+    content: compiledLayers.map((layer) => layer.content).join("\n\n"),
+    layers: compiledLayers,
+    cacheProfile: {
+      stablePrefixHash: createHash("sha256")
+        .update(stablePrefixContent)
+        .digest("hex"),
+      stablePrefixLayerIds: stablePrefixLayers.map((layer) => layer.id),
+      stablePrefixCharCount: stablePrefixContent.length,
+      stablePrefixEstimatedTokens: estimateContextTokens(stablePrefixContent),
+    },
+  };
+};

package/ai/agent/contextLayerContract.ts

@@ -0,0 +1,44 @@
+type ContextLayerContractOptions = {
+  hasRememberMemoryTool?: boolean;
+  hasDocTools?: boolean;
+};
+
+export const buildContextLayerContractBlock = (
+  options: ContextLayerContractOptions = {}
+): string => {
+  const lines = [
+    "--- 上下文分层约定 ---",
+    "不要把所有信息都塞进同一层。优先利用已有的 memory / knowledge / doc，而不是把它们混成一段长对话。",
+    "",
+    "层次边界：",
+    "1. memory layer：放短到中期、可复用但不必永久挂载的偏好、近期共识和压缩后的经验；要短、可检索、可替换。",
+    "2. knowledge layer：放稳定规则、长期有效事实和每轮都会反复依赖的说明；优先通过 prompt / references 自动加载。",
+    "3. doc layer：放需要跨轮次持续维护的外部工作台，例如 runbook、mission、incident、checkpoint、idea backlog、experiment log；需要时显式读取和更新。",
+    "",
+    "写入原则：",
+    "- 临时步骤、原始长日志、一次性思路，不要直接写进 memory 或 knowledge。",
+    "- 稳定行为规则、长期固定约束，优先沉淀到 knowledge layer。",
+    "- 用户偏好、最近形成的协作共识、近期反复有用的经验，优先沉淀到 memory layer。",
+    "- 需要跨轮次接力的任务状态、运行手册、事故记录、检查点，优先写入 doc layer。",
+    "",
+    "读取原则：",
+    "- 先用 knowledge layer 解决稳定规则问题。",
+    "- 再用 memory layer 补充近期偏好和延续性。",
+    "- 需要真实运行现场、任务状态或可共享工作台时，再读 doc layer。",
+    "- 当前用户输入始终高于 recent memory；recent memory 高于过旧的 doc 推断。",
+  ];
+
+  if (options.hasRememberMemoryTool) {
+    lines.push(
+      "- 当某条偏好、近期共识或复用经验对未来明显有帮助时，可以调用 rememberMemory，但要写成简洁可复用的一句话；只有当前 dialog 明确绑定了 space，且内容属于共享协作规则时才写 space memory。"
+    );
+  }
+
+  if (options.hasDocTools) {
+    lines.push(
+      "- 当任务需要 24h 连续运行、跨 dialog 接力或人工与 agent 共读时，优先把 mission / runbook / incident / checkpoint / idea backlog / experiment log 写入 doc layer。"
+    );
+  }
+
+  return lines.join("\n");
+};