@zhushanwen/subagent-core 0.6.0 → 0.7.0

package/src/__tests__/append-system-prompt-assembly.test.ts

@@ -1,243 +0,0 @@
-/**
- * writeAppendSystemPromptFile 组装矩阵（W2 移交 CRAP 43.1；私有函数，经公共
- * runSpawn 驱动，与 spawn-worktree-guidance.test.ts 同 mock 模式——mock
- * temp-prompt 捕获 appendParts.join 后的完整 content）。
- *
- * 覆盖分支（session-runner.ts g. 段）：
- *   - agentConfig.systemPrompt / appendSystemPrompt 片段 / maxTurns wrap-up hint 的注入与顺序
- *   - ask_user RPC 提示的 mode 门控（rpc=gui 响应 / json=headless 不注入）
- *   - maxTurns 缺省/0 → 不注入 wrap-up hint
- *   - fork depth（env block Depth 行）与 ask_user+wrap-up 的组合互不干扰
- *
- * worktree 分支（WORKTREE_GUIDANCE_PROMPT）已由 spawn-worktree-guidance.test.ts
- * 覆盖，此处不重复。
- */
-import type { PassThrough } from "node:stream";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const captured = vi.hoisted(() => ({ content: "", calls: 0 }));
-
-vi.mock("node:child_process", async () => {
-  const { EventEmitter } = await import("node:events");
-  const { PassThrough } = await import("node:stream");
-
-  class FakeChild extends EventEmitter {
-    pid = 12345;
-    stdout = new PassThrough();
-    stdin = new PassThrough();
-    stderr = new PassThrough();
-    killed = false;
-    killSignal: string | undefined;
-    kill(sig?: string): boolean {
-      this.killed = true;
-      this.killSignal = sig;
-      return true;
-    }
-  }
-
-  return {
-    spawn: vi.fn(() => new FakeChild()),
-    execFileSync: vi.fn(() => ""),
-  };
-});
-
-vi.mock("node:fs", async () => {
-  const actual = await import("node:fs");
-  return {
-    default: {
-      ...actual,
-      mkdirSync: vi.fn(),
-      existsSync: vi.fn(() => false),
-      appendFileSync: vi.fn(),
-      writeFileSync: vi.fn(),
-      readdirSync: vi.fn(() => []),
-    },
-    mkdirSync: vi.fn(),
-    existsSync: vi.fn(() => false),
-    appendFileSync: vi.fn(),
-    writeFileSync: vi.fn(),
-    readdirSync: vi.fn(() => []),
-    promises: actual.promises,
-  };
-});
-
-vi.mock("../execution/alive-store.ts", () => ({
-  writeAliveMarker: vi.fn(),
-}));
-
-vi.mock("../execution/engine/engines/pi/temp-prompt.ts", () => ({
-  writePromptToTempFile: vi.fn(async (agent: string, content: string) => {
-    captured.calls++;
-    captured.content = content;
-    const safeName = agent.replace(/[^\w.-]+/g, "_");
-    return { dir: `/tmp/fake-${safeName}`, filePath: `/tmp/fake-${safeName}/prompt.md` };
-  }),
-  cleanupTempPrompt: vi.fn(async () => {}),
-}));
-
-import { spawn } from "node:child_process";
-
-import { createRecord } from "../execution/execution-record.ts";
-import { runSpawn, type RunOptions, type SessionRunnerContext } from "../execution/engine/engines/pi/session-runner.ts";
-
-const mockSpawn = vi.mocked(spawn);
-
-interface FakeChild {
-  pid: number;
-  stdout: PassThrough;
-  stderr: PassThrough;
-  killed: boolean;
-  killSignal: string | undefined;
-  emit(event: string, ...args: unknown[]): boolean;
-}
-
-function getLastSpawnedChild(): FakeChild {
-  const result = mockSpawn.mock.results.at(-1);
-  if (!result) throw new Error("spawn was not called yet");
-  return result.value as FakeChild;
-}
-
-/** 等待第 targetCount 次 spawn 发生（同测试多次 runSpawn 时按基线递增等待）。 */
-async function waitForSpawn(targetCount = 1, timeoutMs = 1000): Promise<void> {
-  const start = Date.now();
-  while (mockSpawn.mock.results.length < targetCount) {
-    if (Date.now() - start > timeoutMs) {
-      throw new Error(`spawn #${targetCount} not called within ${timeoutMs}ms`);
-    }
-    await new Promise((r) => setTimeout(r, 5));
-  }
-}
-
-let seq = 0;
-
-function makeRecord() {
-  seq += 1;
-  return createRecord(`append-asm-${seq}`, {
-    agent: "general-purpose",
-    model: "test/model",
-    mode: "background",
-    task: "test task",
-    slug: "append-asm",
-    startedAt: Date.now(),
-    rootSessionId: "s1",
-    parentRecordId: undefined,
-    depth: 0,
-  });
-}
-
-function makeRunOpts(overrides: Partial<RunOptions> = {}): RunOptions {
-  return {
-    resolved: { model: { provider: "test", id: "model", name: "Model", reasoning: false }, thinkingLevel: undefined },
-    agentConfig: undefined,
-    appendSystemPrompt: undefined,
-    skillPath: undefined,
-    schema: undefined,
-    maxTurns: undefined,
-    graceTurns: undefined,
-    signal: undefined,
-    onEvent: undefined,
-    ...overrides,
-  };
-}
-
-function makeCtx(overrides: Partial<SessionRunnerContext> = {}): SessionRunnerContext {
-  return {
-    cwd: "/fake/cwd",
-    agentDir: "/fake/agent",
-    skillDirs: [],
-    mainCwd: "/fake/cwd",
-    sessionRootId: "root-session-test",
-    rootCwd: "/fake/cwd",
-    ...overrides,
-  };
-}
-
-/** 跑一次 runSpawn 并捕获 appendSystemPrompt content（完成后释放子进程）。 */
-async function captureAppendContent(opts: RunOptions, ctx: SessionRunnerContext): Promise<string> {
-  const baseline = mockSpawn.mock.results.length;
-  const resultPromise = runSpawn(makeRecord(), "test task", opts, ctx);
-  await waitForSpawn(baseline + 1);
-  const content = captured.content;
-  const child = getLastSpawnedChild();
-  child.emit("close", 0);
-  await resultPromise;
-  return content;
-}
-
-describe("writeAppendSystemPromptFile 组装（经 runSpawn 驱动）", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    captured.content = "";
-    captured.calls = 0;
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("全片段组装：env block → agent body → 调用方片段 → wrap-up hint，顺序稳定", async () => {
-    const content = await captureAppendContent(
-      makeRunOpts({
-        agentConfig: { name: "worker", systemPrompt: "AGENT-BODY-MARKER" },
-        appendSystemPrompt: ["FRAG-ONE", "FRAG-TWO"],
-        maxTurns: 5,
-      }),
-      makeCtx(),
-    );
-    expect(content).toContain("AGENT-BODY-MARKER");
-    expect(content).toContain("FRAG-ONE");
-    expect(content).toContain("FRAG-TWO");
-    // maxTurns>0 → 注入 wrap-up 收尾提示（rpc steer 未接通的启动期补偿）
-    expect(content).toContain("You have a turn limit");
-    // 顺序：env block 最前，agent body 在调用方片段前，hint 在其后
-    const envIdx = content.indexOf("--- environment");
-    const bodyIdx = content.indexOf("AGENT-BODY-MARKER");
-    const fragIdx = content.indexOf("FRAG-ONE");
-    const hintIdx = content.indexOf("You have a turn limit");
-    expect(envIdx).toBeLessThan(bodyIdx);
-    expect(bodyIdx).toBeLessThan(fragIdx);
-    expect(fragIdx).toBeLessThan(hintIdx);
-  });
-
-  it("maxTurns 缺省/0 → 不注入 wrap-up hint（不限时不预告收尾）", async () => {
-    const undefinedCase = await captureAppendContent(makeRunOpts(), makeCtx());
-    expect(undefinedCase).not.toContain("You have a turn limit");
-    const zeroCase = await captureAppendContent(makeRunOpts({ maxTurns: 0 }), makeCtx());
-    expect(zeroCase).not.toContain("You have a turn limit");
-  });
-
-  it("ask_user RPC 提示 mode 门控：rpc（gui 响应）注入，json（headless）不注入", async () => {
-    const opts = makeRunOpts({ agentConfig: { name: "worker", systemPrompt: "", tools: ["ask_user"] } });
-    const rpcContent = await captureAppendContent(opts, makeCtx({ mode: "rpc" }));
-    expect(rpcContent).toContain("ask_user Tool Availability");
-    const jsonContent = await captureAppendContent(opts, makeCtx({ mode: "json" }));
-    // headless 无 UI 通道，注入会误导 LLM（W4 守卫）
-    expect(jsonContent).not.toContain("ask_user Tool Availability");
-  });
-
-  it("mode 响应但 tools 不含 ask_user → 不注入", async () => {
-    const content = await captureAppendContent(
-      makeRunOpts({ agentConfig: { name: "worker", systemPrompt: "", tools: ["read", "bash"] } }),
-      makeCtx({ mode: "rpc" }),
-    );
-    expect(content).not.toContain("ask_user Tool Availability");
-  });
-
-  it("fork 场景：parentForkDepth 传入 → env block 带 Depth 行（buildEnvBlock 取 max 语义）", async () => {
-    const content = await captureAppendContent(
-      makeRunOpts({ fork: true, parentForkDepth: 2 }),
-      makeCtx(),
-    );
-    expect(content).toContain("Depth:");
-    // 无 fork 无嵌套时不出现 Depth 行
-    const plain = await captureAppendContent(makeRunOpts(), makeCtx());
-    expect(plain).not.toContain("Depth:");
-  });
-
-  it("env block 恒为第一段：最小配置也落盘（writePromptToTempFile 必被调用）", async () => {
-    await captureAppendContent(makeRunOpts(), makeCtx());
-    expect(captured.calls).toBe(1);
-    expect(captured.content).toContain("Working directory: /fake/cwd");
-  });
-});

package/src/__tests__/fr4-get-state-handshake.test.ts

@@ -1,125 +0,0 @@
-import { describe, expect,it } from "vitest";
-
-import { parseSpawnLine } from "../execution/engine/engines/pi/spawn-event-adapter";
-import { sendGetStateCommand } from "../execution/engine/engines/pi/stdin-writer";
-
-describe("FR-4: get_state RPC handshake", () => {
-  describe("sendGetStateCommand", () => {
-    it("should write get_state command to stdin", () => {
-      const written: string[] = [];
-      const child = {
-        stdin: {
-          destroyed: false,
-          write: (data: string) => {
-            written.push(data);
-            return true;
-          },
-        },
-      } as unknown as Parameters<typeof sendGetStateCommand>[0];
-
-      const id = sendGetStateCommand(child);
-
-      expect(written).toHaveLength(1);
-      const parsed = JSON.parse(written[0]);
-      expect(parsed.type).toBe("get_state");
-      expect(parsed.id).toBe(id);
-      expect(typeof parsed.id).toBe("string");
-    });
-
-    it("should not write if stdin is destroyed", () => {
-      const written: string[] = [];
-      const child = {
-        stdin: {
-          destroyed: true,
-          write: (data: string) => {
-            written.push(data);
-            return true;
-          },
-        },
-      } as unknown as Parameters<typeof sendGetStateCommand>[0];
-
-      sendGetStateCommand(child);
-
-      expect(written).toHaveLength(0);
-    });
-
-    it("should not write if stdin is null", () => {
-      const child = {
-        stdin: null,
-      } as unknown as Parameters<typeof sendGetStateCommand>[0];
-
-      // Should not throw
-      sendGetStateCommand(child);
-    });
-  });
-
-  describe("parseSpawnLine: get_state response", () => {
-    it("should parse get_state response correctly", () => {
-      const line = JSON.stringify({
-        type: "response",
-        command: "get_state",
-        success: true,
-        id: "test-req-id",
-        data: {
-          sessionFile: "/path/to/session.jsonl",
-          sessionId: "session-123",
-        },
-      });
-
-      const parsed = parseSpawnLine(line);
-      expect(parsed).not.toBeNull();
-      expect(parsed!.kind).toBe("response");
-      if (parsed!.kind === "response") {
-        expect(parsed!.command).toBe("get_state");
-        expect(parsed!.success).toBe(true);
-        expect(parsed!.id).toBe("test-req-id");
-        expect(parsed!.data).toEqual({
-          sessionFile: "/path/to/session.jsonl",
-          sessionId: "session-123",
-        });
-      }
-    });
-
-    it("should parse get_state error response", () => {
-      const line = JSON.stringify({
-        type: "response",
-        command: "get_state",
-        success: false,
-        id: "test-req-id",
-        error: "session not initialized",
-      });
-
-      const parsed = parseSpawnLine(line);
-      expect(parsed).not.toBeNull();
-      expect(parsed!.kind).toBe("response");
-      if (parsed!.kind === "response") {
-        expect(parsed!.command).toBe("get_state");
-        expect(parsed!.success).toBe(false);
-        expect(parsed!.error).toBe("session not initialized");
-      }
-    });
-
-    it("should parse get_state response without id (notification)", () => {
-      const line = JSON.stringify({
-        type: "response",
-        command: "get_state",
-        success: true,
-        data: { sessionId: "session-456" },
-      });
-
-      const parsed = parseSpawnLine(line);
-      expect(parsed).not.toBeNull();
-      expect(parsed!.kind).toBe("response");
-      if (parsed!.kind === "response") {
-        expect(parsed!.command).toBe("get_state");
-        expect(parsed!.id).toBeUndefined();
-      }
-    });
-  });
-
-  // [B8] 删除原 "get_state response matching in stdout pump" describe 块（3 case）：
-  // 该块在测试内重写了 session-runner 的 response matching 逻辑（Map<id,resolver> +
-  //  delete + resolver(data)），断言的是测试自己复制的逻辑而非生产代码——tautological
-  // （同义反复），无法捕获生产 matching 的真实回归。真实覆盖已在 run-spawn-rpc-mode.test.ts
-  // （端到端跑 session-runner 的 stdout pump + get_state 握手）中存在，此处删除不减覆盖。
-});

package/src/__tests__/session-runner.test.ts

@@ -1,69 +0,0 @@
-/**
- * session-runner message_update 分流测试。
- *
- * 核心回归点：toolcall_delta（工具入参 JSON 增量）不得被当成 text_delta
- * forward 到 subagent overlay 的 streaming content——否则 assistant 正文会
- * 原样流出 {"path":"..."}{"command":"..."} 工具参数 JSON 串，表现为对话末尾
- * JSON 与 text 混杂、无 ICON+title 工具卡片前缀（用户实际报告的现象）。
- *
- * 根因：pi-ai AssistantMessageEvent 的 type 集合含 text_delta / thinking_delta /
- * toolcall_delta / signature_delta 等（见 @earendil-works/pi-ai types.d.ts）。
- * 旧实现 `ame?.delta !== undefined` 反向排除（只拦 thinking_delta），toolcall_delta
- * 因带 delta 字段被误判为 text_delta。正向判定（只放行 text_delta）根治。
- */
-import { describe, it, expect } from "vitest";
-import { mapAssistantMessageDelta } from "../execution/engine/engines/pi/session-runner.js";
-
-describe("mapAssistantMessageDelta: assistantMessageEvent → streaming 事件分流", () => {
-  it("text_delta → forward 为 text_delta", () => {
-    expect(mapAssistantMessageDelta({ type: "text_delta", delta: "hello" })).toEqual({
-      type: "text_delta",
-      delta: "hello",
-    });
-  });
-
-  it("thinking_delta → forward 为 thinking_delta（走独立通道，不进 text stream）", () => {
-    expect(mapAssistantMessageDelta({ type: "thinking_delta", delta: "思考" })).toEqual({
-      type: "thinking_delta",
-      delta: "思考",
-    });
-  });
-
-  it("thinking_delta 缺 delta 兜底空串（不抛错，与旧实现行为一致）", () => {
-    expect(mapAssistantMessageDelta({ type: "thinking_delta" })).toEqual({
-      type: "thinking_delta",
-      delta: "",
-    });
-  });
-
-  it("toolcall_delta → null（工具入参 JSON 增量绝不混入 text）", () => {
-    // 核心回归：旧实现 ame?.delta !== undefined 会把 toolcall_delta 当 text_delta
-    expect(mapAssistantMessageDelta({ type: "toolcall_delta", delta: '{"path":"/x"}' })).toBeNull();
-  });
-
-  it("toolcall_delta 的部分 JSON 片段也不混入（流式累积的中间态）", () => {
-    expect(mapAssistantMessageDelta({ type: "toolcall_delta", delta: '{"path":"' })).toBeNull();
-    expect(mapAssistantMessageDelta({ type: "toolcall_delta", delta: "/Users/foo/bar" })).toBeNull();
-    expect(mapAssistantMessageDelta({ type: "toolcall_delta", delta: '"}}' })).toBeNull();
-  });
-
-  it("其他带 delta 的 type（signature_delta 等未来扩展）也不混入 text", () => {
-    expect(mapAssistantMessageDelta({ type: "signature_delta", delta: "sig-xyz" })).toBeNull();
-  });
-
-  it("非 delta 事件（start/end/done 等）返回 null", () => {
-    expect(mapAssistantMessageDelta({ type: "text_start" })).toBeNull();
-    expect(mapAssistantMessageDelta({ type: "text_end" })).toBeNull();
-    expect(mapAssistantMessageDelta({ type: "toolcall_start" })).toBeNull();
-    expect(mapAssistantMessageDelta({ type: "toolcall_end" })).toBeNull();
-    expect(mapAssistantMessageDelta({ type: "done" })).toBeNull();
-  });
-
-  it("缺 type 或缺 delta 的异常输入返回 null（不抛错）", () => {
-    expect(mapAssistantMessageDelta({})).toBeNull();
-    // text_delta 缺 delta → null（无法 forward 空 delta 增量）
-    expect(mapAssistantMessageDelta({ type: "text_delta" })).toBeNull();
-    // 有 delta 无 type → null（未知来源，不放行）
-    expect(mapAssistantMessageDelta({ delta: "x" })).toBeNull();
-  });
-});