alvin-bot 4.18.0 → 4.18.2

package/test/async-agent-parser-streamjson.test.ts

@@ -1,273 +0,0 @@
-/**
- * v4.13 — parseOutputFileStatus support for `claude -p --output-format stream-json`.
- *
- * The SDK's built-in Task tool writes its sub-agent output in one JSONL
- * format (events with `message.stop_reason: "end_turn"`). The new v4.13
- * dispatch mechanism spawns `claude -p --output-format stream-json`
- * which writes a DIFFERENT format:
- *
- *   - Assistant messages have `message.stop_reason: null` (streaming shape)
- *   - A final `{"type":"result","subtype":"success","stop_reason":"end_turn",...}`
- *     event marks completion explicitly
- *   - `result.duration_ms`, `total_cost_usd`, `num_turns`, `usage`
- *     are the authoritative completion signals
- *
- * The parser must recognize BOTH formats. v4.13 adds detection for the
- * result-event format while preserving backward compat with the existing
- * SDK-internal format (tested in the sibling test files).
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import os from "os";
-import { resolve } from "path";
-import { parseOutputFileStatus } from "../src/services/async-agent-parser.js";
-
-const TMP_BASE = resolve(
-  os.tmpdir(),
-  `alvin-parser-streamjson-${process.pid}`,
-);
-
-beforeEach(() => {
-  fs.mkdirSync(TMP_BASE, { recursive: true });
-});
-afterEach(() => {
-  try {
-    fs.rmSync(TMP_BASE, { recursive: true, force: true });
-  } catch {
-    /* ignore */
-  }
-});
-
-describe("parseOutputFileStatus — stream-json format (v4.13)", () => {
-  it("returns 'completed' when final event is type:result + subtype:success", async () => {
-    const path = resolve(TMP_BASE, "stream-success.jsonl");
-    const lines = [
-      { type: "system", subtype: "init", session_id: "s1" },
-      {
-        type: "assistant",
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text: "The answer is 42." }],
-          stop_reason: null, // streaming shape — NOT end_turn yet
-        },
-        session_id: "s1",
-      },
-      {
-        type: "result",
-        subtype: "success",
-        stop_reason: "end_turn",
-        session_id: "s1",
-        total_cost_usd: 0.01,
-        duration_ms: 500,
-        usage: { input_tokens: 10, output_tokens: 5 },
-        result: "The answer is 42.",
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("The answer is 42.");
-      expect(status.output).not.toMatch(/interrupted|partial/i);
-    }
-  });
-
-  it("extracts tokens from result.usage when using stream-json format", async () => {
-    const path = resolve(TMP_BASE, "stream-tokens.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "x" }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "result",
-        subtype: "success",
-        stop_reason: "end_turn",
-        usage: { input_tokens: 1234, output_tokens: 567 },
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.tokensUsed).toEqual({ input: 1234, output: 567 });
-    }
-  });
-
-  it("recognises 'failed' state when result.is_error is true", async () => {
-    const path = resolve(TMP_BASE, "stream-failed.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "I tried..." }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "result",
-        subtype: "error_max_turns",
-        is_error: true,
-        stop_reason: "max_turns",
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    // With an is_error result + text content, we still deliver the text
-    // as completed (better to give the user SOMETHING than nothing).
-    // The delivery layer can annotate differently if it chooses.
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("I tried...");
-    }
-  });
-
-  it("returns 'running' when stream-json events are present but no result yet", async () => {
-    const path = resolve(TMP_BASE, "stream-running.jsonl");
-    const lines = [
-      { type: "system", subtype: "init", session_id: "s1" },
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Thinking..." }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "tool_use", name: "Bash", input: {} }],
-          stop_reason: null,
-        },
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("running");
-  });
-
-  it("aggregates text from ALL assistant messages when result arrives", async () => {
-    const path = resolve(TMP_BASE, "stream-multi-text.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "First thought." }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "user",
-        message: { content: [{ type: "tool_result", content: "ok" }] },
-      },
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Continuing..." }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "user",
-        message: { content: [{ type: "tool_result", content: "ok" }] },
-      },
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Final answer." }],
-          stop_reason: null,
-        },
-      },
-      { type: "result", subtype: "success", stop_reason: "end_turn" },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      // All three text blocks must be present
-      expect(status.output).toContain("First thought");
-      expect(status.output).toContain("Continuing");
-      expect(status.output).toContain("Final answer");
-    }
-  });
-
-  it("prefers result.result field as authoritative output when available", async () => {
-    // The stream-json's result event has a `result` field with the
-    // already-concatenated final answer. Use it directly when present
-    // (more accurate than re-aggregating from streaming chunks).
-    const path = resolve(TMP_BASE, "stream-result-field.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Intermediate chunk" }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "result",
-        subtype: "success",
-        stop_reason: "end_turn",
-        result: "FINAL AUTHORITATIVE ANSWER",
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("FINAL AUTHORITATIVE ANSWER");
-    }
-  });
-
-  it("handles result event with only partial fields (defensive)", async () => {
-    const path = resolve(TMP_BASE, "stream-result-minimal.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Some output" }],
-          stop_reason: null,
-        },
-      },
-      { type: "result" }, // no subtype, no result field, no usage
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("Some output");
-    }
-  });
-});

package/test/async-agent-parser.test.ts

@@ -1,322 +0,0 @@
-/**
- * Fix #17 (Stage 2) — async-agent-parser unit tests.
- *
- * Two pure helpers:
- *   parseAsyncLaunchedToolResult(text) → { agentId, outputFile } | null
- *   parseOutputFileStatus(path) → { state: "running"|"completed"|"failed"|"missing" }
- *
- * Format details captured from the live SDK probe in
- * docs/superpowers/specs/sdk-async-agent-outputfile-format.md
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import os from "os";
-import { resolve } from "path";
-import {
-  parseAsyncLaunchedToolResult,
-  parseOutputFileStatus,
-} from "../src/services/async-agent-parser.js";
-
-describe("parseAsyncLaunchedToolResult — plain text format (Stage 2)", () => {
-  it("extracts agentId and output_file from the real SDK tool-result text", () => {
-    const text = `Async agent launched successfully.
-agentId: a9e9c5913b2faec71 (internal ID - do not mention to user. Use SendMessage with to: 'a9e9c5913b2faec71' to continue this agent.)
-The agent is working in the background. You will be notified automatically when it completes.
-Do not duplicate this agent's work — avoid working with the same files or topics it is using.
-output_file: /private/tmp/claude-502/-Users-alvin-de-Projects-alvin-bot/abc/tasks/a9e9c5913b2faec71.output
-If asked, you can check progress before completion by using Read or Bash tail on the output file.`;
-
-    const info = parseAsyncLaunchedToolResult(text);
-    expect(info).not.toBeNull();
-    expect(info?.agentId).toBe("a9e9c5913b2faec71");
-    expect(info?.outputFile).toBe(
-      "/private/tmp/claude-502/-Users-alvin-de-Projects-alvin-bot/abc/tasks/a9e9c5913b2faec71.output",
-    );
-  });
-
-  it("returns null for ordinary tool result text (e.g. Read output)", () => {
-    expect(parseAsyncLaunchedToolResult("file contents here")).toBeNull();
-  });
-
-  it("returns null for an empty string", () => {
-    expect(parseAsyncLaunchedToolResult("")).toBeNull();
-  });
-
-  it("returns null when the marker line is missing", () => {
-    expect(
-      parseAsyncLaunchedToolResult("agentId: x\noutput_file: /tmp/a"),
-    ).toBeNull();
-  });
-
-  it("returns null when output_file line is missing", () => {
-    const text =
-      "Async agent launched successfully.\nagentId: abc123\nMore prose";
-    expect(parseAsyncLaunchedToolResult(text)).toBeNull();
-  });
-
-  it("returns null when agentId line is missing", () => {
-    const text =
-      "Async agent launched successfully.\noutput_file: /tmp/a\nMore prose";
-    expect(parseAsyncLaunchedToolResult(text)).toBeNull();
-  });
-
-  it("trims whitespace around extracted values", () => {
-    const text = `Async agent launched successfully.
-agentId:    abc-with-spaces   (something)
-output_file:    /tmp/path with spaces.output   `;
-    const info = parseAsyncLaunchedToolResult(text);
-    expect(info?.agentId).toBe("abc-with-spaces");
-    // Path can contain spaces — we just trim leading/trailing
-    expect(info?.outputFile).toBe("/tmp/path with spaces.output");
-  });
-
-  it("handles input that is an array of content blocks (Anthropic SDK shape)", () => {
-    const blocks = [
-      { type: "text", text: "Async agent launched successfully.\nagentId: id1\noutput_file: /tmp/o1\n" },
-    ];
-    const info = parseAsyncLaunchedToolResult(blocks);
-    expect(info?.agentId).toBe("id1");
-    expect(info?.outputFile).toBe("/tmp/o1");
-  });
-
-  it("handles non-string input gracefully", () => {
-    expect(parseAsyncLaunchedToolResult(null)).toBeNull();
-    expect(parseAsyncLaunchedToolResult(undefined)).toBeNull();
-    expect(parseAsyncLaunchedToolResult(42 as unknown as string)).toBeNull();
-  });
-});
-
-const TMP_BASE = resolve(os.tmpdir(), `alvin-parser-${process.pid}`);
-
-beforeEach(() => {
-  fs.mkdirSync(TMP_BASE, { recursive: true });
-});
-
-afterEach(() => {
-  try {
-    fs.rmSync(TMP_BASE, { recursive: true, force: true });
-  } catch { /* ignore */ }
-});
-
-async function writeJsonl(name: string, lines: object[]): Promise<string> {
-  const path = resolve(TMP_BASE, name);
-  fs.writeFileSync(
-    path,
-    lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-    "utf-8",
-  );
-  return path;
-}
-
-describe("parseOutputFileStatus — JSONL completion detection (Stage 2)", () => {
-  it("returns 'missing' when the file doesn't exist", async () => {
-    const status = await parseOutputFileStatus(`${TMP_BASE}/nonexistent.jsonl`);
-    expect(status.state).toBe("missing");
-  });
-
-  it("returns 'missing' for an empty file", async () => {
-    const path = resolve(TMP_BASE, "empty.jsonl");
-    fs.writeFileSync(path, "", "utf-8");
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("missing");
-  });
-
-  it("returns 'running' when the file has events but no end_turn", async () => {
-    const path = await writeJsonl("running.jsonl", [
-      {
-        type: "user",
-        isSidechain: true,
-        agentId: "x",
-        message: { role: "user", content: "do the thing" },
-      },
-      {
-        type: "assistant",
-        isSidechain: true,
-        agentId: "x",
-        message: {
-          role: "assistant",
-          content: [{ type: "tool_use", name: "Bash", input: { command: "ls" } }],
-          stop_reason: "tool_use",
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("running");
-  });
-
-  it("returns 'completed' with the final text when stop_reason is end_turn", async () => {
-    const path = await writeJsonl("completed.jsonl", [
-      {
-        type: "user",
-        isSidechain: true,
-        agentId: "x",
-        message: { role: "user", content: "p" },
-      },
-      {
-        type: "assistant",
-        isSidechain: true,
-        agentId: "x",
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text: "Final report: it works!" }],
-          stop_reason: "end_turn",
-          usage: { input_tokens: 100, output_tokens: 50 },
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("Final report: it works!");
-      expect(status.tokensUsed).toEqual({ input: 100, output: 50 });
-    }
-  });
-
-  it("concatenates multiple text blocks in the final assistant message", async () => {
-    const path = await writeJsonl("multi-block.jsonl", [
-      {
-        type: "assistant",
-        isSidechain: true,
-        agentId: "x",
-        message: {
-          role: "assistant",
-          content: [
-            { type: "thinking", text: "let me think" },
-            { type: "text", text: "Part one." },
-            { type: "text", text: "Part two." },
-          ],
-          stop_reason: "end_turn",
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toBe("Part one.\n\nPart two.");
-      // thinking blocks are NOT included
-      expect(status.output).not.toContain("let me think");
-    }
-  });
-
-  it("ignores assistant messages with stop_reason !== end_turn (still running)", async () => {
-    const path = await writeJsonl("intermediate.jsonl", [
-      {
-        type: "assistant",
-        isSidechain: true,
-        agentId: "x",
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text: "checking..." }],
-          stop_reason: "tool_use",
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("running");
-  });
-
-  it("uses the LAST end_turn assistant message when there are multiple turns", async () => {
-    const path = await writeJsonl("multi-turn.jsonl", [
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "first answer" }],
-          stop_reason: "end_turn",
-        },
-      },
-      {
-        type: "user",
-        agentId: "x",
-        message: { content: [{ type: "tool_result", content: "..." }] },
-      },
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "second and final answer" }],
-          stop_reason: "end_turn",
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toBe("second and final answer");
-    }
-  });
-
-  it("survives partial final lines (mid-write)", async () => {
-    const path = resolve(TMP_BASE, "partial.jsonl");
-    fs.writeFileSync(
-      path,
-      JSON.stringify({
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "checking" }],
-          stop_reason: "tool_use",
-        },
-      }) +
-        "\n" +
-        '{"type":"assistant","agentId":"x","mes',
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    // Partial line is ignored; only the complete event counts
-    expect(status.state).toBe("running");
-  });
-
-  it("survives unparseable lines (skip them, keep checking)", async () => {
-    const path = resolve(TMP_BASE, "garbage.jsonl");
-    fs.writeFileSync(
-      path,
-      "garbage line\n" +
-        JSON.stringify({
-          type: "assistant",
-          agentId: "x",
-          message: {
-            content: [{ type: "text", text: "the answer" }],
-            stop_reason: "end_turn",
-          },
-        }) +
-        "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toBe("the answer");
-    }
-  });
-
-  it("only tail-reads large files (does not load entire content into memory)", async () => {
-    const path = resolve(TMP_BASE, "huge.jsonl");
-    // Write a 200KB padding stream of 'running' events, then an end_turn
-    const padding = JSON.stringify({
-      type: "assistant",
-      agentId: "x",
-      message: { content: [{ type: "text", text: "x".repeat(500) }], stop_reason: "tool_use" },
-    });
-    let buf = "";
-    for (let i = 0; i < 200; i++) buf += padding + "\n";
-    buf +=
-      JSON.stringify({
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "FINAL" }],
-          stop_reason: "end_turn",
-        },
-      }) + "\n";
-    fs.writeFileSync(path, buf, "utf-8");
-    expect(fs.statSync(path).size).toBeGreaterThan(100_000);
-
-    const status = await parseOutputFileStatus(path, { maxTailBytes: 8192 });
-    // Tail should still find the last end_turn
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toBe("FINAL");
-    }
-  });
-});