@ai-devkit/agent-manager 0.37.0 → 0.39.0

package/src/__tests__/harnesses/devin/DevinSessionParser.test.ts

@@ -0,0 +1,218 @@
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { DevinSessionParser } from "../../../harnesses/devin/DevinSessionParser.js";
+import { writeDatabase } from "./fixtures.js";
+
+describe("DevinSessionParser", () => {
+  let tmpDir: string;
+  let dbPath: string;
+  let parser: DevinSessionParser;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devin-parser-test-"));
+    dbPath = path.join(tmpDir, "sessions.db");
+    parser = new DevinSessionParser();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function openDb(): Database.Database {
+    return new Database(dbPath, { readonly: true });
+  }
+
+  it("returns user and assistant messages in node order, skipping system", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "system", content: "preamble" },
+        { sessionId: "s", nodeId: 2, role: "user", content: "hello", isUserInput: true },
+        { sessionId: "s", nodeId: 3, role: "assistant", content: "hi" },
+        // Later turn roots a fresh preamble chain:
+        { sessionId: "s", nodeId: 4, role: "system", content: "more preamble" },
+        { sessionId: "s", nodeId: 5, role: "user", content: "again", isUserInput: true },
+        { sessionId: "s", nodeId: 6, role: "assistant", content: "done" },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([
+        { role: "user", content: "hello" },
+        { role: "assistant", content: "hi" },
+        { role: "user", content: "again" },
+        { role: "assistant", content: "done" },
+      ]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("dedupes sibling revisions by message_id keeping the highest node_id", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "assistant", content: "draft", messageId: "m1" },
+        { sessionId: "s", nodeId: 2, role: "assistant", content: "final", messageId: "m1" },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([
+        { role: "assistant", content: "final" },
+      ]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("skips non-input user nodes and empty content", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "user", content: "wrapper", isUserInput: false },
+        { sessionId: "s", nodeId: 2, role: "user", content: "   ", isUserInput: true },
+        { sessionId: "s", nodeId: 3, role: "user", content: "real", isUserInput: true },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([{ role: "user", content: "real" }]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("includes tools and thinking only in verbose mode", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        {
+          sessionId: "s",
+          nodeId: 1,
+          role: "assistant",
+          content: "working",
+          thinking: "hmm",
+          toolCalls: [{ function: { name: "exec" } }],
+        },
+        { sessionId: "s", nodeId: 2, role: "tool", content: "tool output", name: "exec" },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([
+        { role: "assistant", content: "working" },
+      ]);
+      expect(parser.getConversation(db, "s", { verbose: true })).toEqual([
+        { role: "assistant", content: "[thinking] hmm" },
+        { role: "assistant", content: "working" },
+        { role: "assistant", content: "[tool: exec]" },
+        { role: "assistant", content: "[tool: exec] tool output" },
+      ]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("honors tail and bounds the query window", () => {
+    writeDatabase(dbPath, {
+      nodes: Array.from({ length: 30 }, (_, i) => ({
+        sessionId: "s",
+        nodeId: i + 1,
+        role: "user" as const,
+        content: `msg-${i + 1}`,
+        isUserInput: true,
+      })),
+    });
+    const db = openDb();
+    try {
+      const convo = parser.getConversation(db, "s", { tail: 3 });
+      expect(convo).toEqual([
+        { role: "user", content: "msg-28" },
+        { role: "user", content: "msg-29" },
+        { role: "user", content: "msg-30" },
+      ]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("skips malformed chat_message rows and missing sessions", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, raw: "{not json" },
+        { sessionId: "s", nodeId: 2, role: "assistant", content: "ok" },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getConversation(db, "s")).toEqual([
+        { role: "assistant", content: "ok" },
+      ]);
+      expect(parser.getConversation(db, "missing")).toEqual([]);
+    } finally {
+      db.close();
+    }
+  });
+
+  it("reports session stats from the frontier node and latest prompt", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "user", content: "go", createdAt: 100 },
+        { sessionId: "s", nodeId: 2, role: "assistant", content: "done", createdAt: 200 },
+      ],
+      prompts: [
+        { sessionId: "s", content: "first task", timestamp: 100 },
+        { sessionId: "s", content: "/mcp", timestamp: 300 },
+        { sessionId: "s", content: "latest task", timestamp: 200 },
+        { sessionId: "s", content: "!shell", timestamp: 400, isShell: 1 },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getSessionStats(db, "s")).toEqual({
+        lastRole: "assistant",
+        lastTimeUpdated: 200_000,
+        summary: "latest task",
+      });
+      expect(parser.getSessionStats(db, "missing")).toEqual({
+        lastRole: null,
+        lastTimeUpdated: 0,
+        summary: "",
+      });
+    } finally {
+      db.close();
+    }
+  });
+
+  it("falls back to the first is_user_input node for the summary", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "user", content: "wrapper", isUserInput: false },
+        { sessionId: "s", nodeId: 2, role: "user", content: "real first", isUserInput: true },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getFirstUserMessage(db, "s")).toBe("real first");
+    } finally {
+      db.close();
+    }
+  });
+
+  it("falls back to the last is_user_input node for the working-on summary", () => {
+    writeDatabase(dbPath, {
+      nodes: [
+        { sessionId: "s", nodeId: 1, role: "user", content: "first", isUserInput: true },
+        { sessionId: "s", nodeId: 2, role: "user", content: "wrapper", isUserInput: false },
+        { sessionId: "s", nodeId: 3, role: "user", content: "last real", isUserInput: true },
+      ],
+    });
+    const db = openDb();
+    try {
+      expect(parser.getLastUserPrompt(db, "s")).toBe("last real");
+      expect(parser.getLastUserPrompt(db, "missing")).toBe("");
+    } finally {
+      db.close();
+    }
+  });
+});

package/src/__tests__/harnesses/devin/fixtures.ts

@@ -0,0 +1,144 @@
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as path from "path";
+
+export interface DevinSessionInput {
+  id: string;
+  directory: string;
+  title?: string | null;
+  timeCreated: number;
+  lastActivityAt?: number;
+  mainChainId?: number | null;
+  hidden?: number;
+}
+
+export interface DevinNodeInput {
+  nodeId: number;
+  parentNodeId?: number | null;
+  role: string;
+  content?: string;
+  messageId?: string;
+  createdAt?: number;
+  isUserInput?: boolean;
+  toolCalls?: { name?: string; function?: { name?: string } }[];
+  thinking?: string;
+  name?: string;
+  /** Raw chat_message text; when set, other fields are ignored. */
+  raw?: string;
+}
+
+export interface DevinPromptInput {
+  sessionId: string;
+  content: string;
+  timestamp?: number;
+  isShell?: number;
+}
+
+export function writeDatabase(
+  dbPath: string,
+  data: {
+    sessions?: DevinSessionInput[];
+    nodes?: (DevinNodeInput & { sessionId: string })[];
+    prompts?: DevinPromptInput[];
+  },
+): void {
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  try {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        working_directory TEXT NOT NULL,
+        backend_type TEXT NOT NULL DEFAULT 'local',
+        model TEXT NOT NULL DEFAULT 'test-model',
+        agent_mode TEXT NOT NULL DEFAULT 'normal',
+        created_at INTEGER NOT NULL,
+        last_activity_at INTEGER NOT NULL,
+        title TEXT,
+        main_chain_id INTEGER,
+        hidden INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS message_nodes (
+        row_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        node_id INTEGER NOT NULL,
+        parent_node_id INTEGER,
+        chat_message TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        UNIQUE(session_id, node_id)
+      );
+      CREATE TABLE IF NOT EXISTS prompt_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        session_id TEXT NOT NULL,
+        is_shell INTEGER NOT NULL DEFAULT 0
+      );
+    `);
+
+    const insertSession = db.prepare(`
+      INSERT INTO sessions (id, working_directory, created_at, last_activity_at, title, main_chain_id, hidden)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const session of data.sessions ?? []) {
+      insertSession.run(
+        session.id,
+        session.directory,
+        session.timeCreated,
+        session.lastActivityAt ?? session.timeCreated,
+        session.title ?? null,
+        session.mainChainId ?? null,
+        session.hidden ?? 0,
+      );
+    }
+
+    const insertNode = db.prepare(`
+      INSERT INTO message_nodes (session_id, node_id, parent_node_id, chat_message, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    for (const node of data.nodes ?? []) {
+      const chatMessage =
+        node.raw ??
+        JSON.stringify({
+          message_id: node.messageId ?? `msg-${node.nodeId}`,
+          role: node.role,
+          content: node.content ?? "",
+          ...(node.toolCalls ? { tool_calls: node.toolCalls } : {}),
+          ...(node.thinking ? { thinking: { thinking: node.thinking } } : {}),
+          ...(node.name ? { name: node.name } : {}),
+          ...(node.isUserInput !== undefined
+            ? { metadata: { is_user_input: node.isUserInput } }
+            : {}),
+        });
+      insertNode.run(
+        node.sessionId,
+        node.nodeId,
+        node.parentNodeId ?? null,
+        chatMessage,
+        node.createdAt ?? 1000 + node.nodeId,
+      );
+    }
+
+    const insertPrompt = db.prepare(`
+      INSERT INTO prompt_history (session_id, content, timestamp, is_shell)
+      VALUES (?, ?, ?, ?)
+    `);
+    for (const prompt of data.prompts ?? []) {
+      insertPrompt.run(
+        prompt.sessionId,
+        prompt.content,
+        prompt.timestamp ?? 1000,
+        prompt.isShell ?? 0,
+      );
+    }
+  } finally {
+    db.close();
+  }
+}
+
+export function writeLocks(locksDir: string, locks: Record<string, number | string>): void {
+  fs.mkdirSync(locksDir, { recursive: true });
+  for (const [sessionId, pid] of Object.entries(locks)) {
+    fs.writeFileSync(path.join(locksDir, `${sessionId}.lock`), String(pid));
+  }
+}

package/src/__tests__/harnesses/pi/durable/PiCliProbe.test.ts

@@ -1,9 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
+import { PiCliProbe } from "../../../../harnesses/pi/durable/PiCliProbe.js";
 
 describe("PiCliProbe", () => {
   it("validates documented JSON mode and session capabilities", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    expect(api).toHaveProperty("PiCliProbe");
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: "pi 0.52.8", stderr: "" })
@@ -11,8 +10,7 @@ describe("PiCliProbe", () => {
         stdout: "--mode json\n--session-id <uuid>\n--session <path|id>",
         stderr: "",
       });
-    const Probe = api.PiCliProbe as new (options: unknown) => any;
-    await expect(new Probe({ executable: "fake-pi", exec }).validate()).resolves.toEqual({
+    await expect(new PiCliProbe({ executable: "fake-pi", exec }).validate()).resolves.toEqual({
       executable: "fake-pi",
       version: "pi 0.52.8",
     });
@@ -23,17 +21,15 @@ describe("PiCliProbe", () => {
   });
 
   it("rejects unsupported and unavailable CLIs with sanitized errors", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.PiCliProbe as new (options: unknown) => any;
     await expect(
-      new Probe({
+      new PiCliProbe({
         exec: vi
           .fn()
           .mockResolvedValueOnce({ stdout: "", stderr: "" })
           .mockResolvedValueOnce({ stdout: "--print only", stderr: "" }),
       }).validate(),
     ).rejects.toMatchObject({ code: "PI_CLI_UNSUPPORTED" });
-    const unavailable = new Probe({
+    const unavailable = new PiCliProbe({
       exec: vi.fn().mockRejectedValue(new Error(`bad\0${"x".repeat(1000)}`)),
     });
     const error = await unavailable.validate().catch((value: Error & { code: string }) => value);
@@ -43,12 +39,12 @@ describe("PiCliProbe", () => {
   });
 
   it("reports an empty version as unknown", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.PiCliProbe as new (options: unknown) => any;
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: " \n", stderr: "" })
       .mockResolvedValueOnce({ stdout: "--mode json --session-id --session", stderr: "" });
-    await expect(new Probe({ exec }).validate()).resolves.toMatchObject({ version: "unknown" });
+    await expect(new PiCliProbe({ exec }).validate()).resolves.toMatchObject({
+      version: "unknown",
+    });
   });
 });

package/src/__tests__/harnesses/pi/durable/PiPrintAgentService.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
+import { PiPrintError } from "../../../../durable/DurableAgent.js";
+import { PiPrintAgentService } from "../../../../harnesses/pi/durable/PiPrintAgentService.js";
 const SESSION = "22222222-2222-4222-8222-222222222222";
 const base = {
   id: "id",
@@ -10,13 +12,13 @@ const base = {
 
 describe("PiPrintAgentService", () => {
   it("probes before provider-aware create", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    expect(api).toHaveProperty("PiPrintAgentService");
     const probe = { validate: vi.fn() };
     const repository = { create: vi.fn().mockResolvedValue(base), list: vi.fn() };
     const runner = { run: vi.fn() };
-    const Service = api.PiPrintAgentService as new (options: unknown) => any;
-    await new Service({ repository, probe, runner }).create({ name: "reviewer", cwd: "/project" });
+    await new PiPrintAgentService({ repository, probe, runner }).create({
+      name: "reviewer",
+      cwd: "/project",
+    });
     expect(probe.validate).toHaveBeenCalledOnce();
     expect(repository.create).toHaveBeenCalledWith({
       name: "reviewer",
@@ -26,7 +28,6 @@ describe("PiPrintAgentService", () => {
   });
 
   it("records successful first and resumed sends", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     const repository = {
       list: vi.fn(),
       resolve: vi.fn().mockResolvedValue(base),
@@ -43,8 +44,7 @@ describe("PiPrintAgentService", () => {
         return { sessionId: SESSION, result: "answer", messages: ["answer"], exitCode: 0 };
       }),
     };
-    const Service = api.PiPrintAgentService as new (options: unknown) => any;
-    const service = new Service({ repository, probe: { validate: vi.fn() }, runner });
+    const service = new PiPrintAgentService({ repository, probe: { validate: vi.fn() }, runner });
     await service.send("reviewer", "first");
     await service.send("reviewer", "later");
     expect(repository.completeRun).toHaveBeenCalledWith(
@@ -55,8 +55,6 @@ describe("PiPrintAgentService", () => {
   });
 
   it("records mismatches and rejects missing and ambiguous records", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const ErrorType = api.PiPrintError as new (message: string, code: string) => Error;
     const completeRun = vi.fn();
     const repository = {
       list: vi.fn(),
@@ -65,12 +63,11 @@ describe("PiPrintAgentService", () => {
       recordProviderProcess: vi.fn(),
       completeRun,
     };
-    const Service = api.PiPrintAgentService as new (options: unknown) => any;
     await expect(
-      new Service({
+      new PiPrintAgentService({
         repository,
         probe: { validate: vi.fn() },
-        runner: { run: vi.fn().mockRejectedValue(new ErrorType("bad", "PI_SESSION_MISMATCH")) },
+        runner: { run: vi.fn().mockRejectedValue(new PiPrintError("bad", "PI_SESSION_MISMATCH")) },
       }).send("reviewer", "x"),
     ).rejects.toMatchObject({ code: "PI_SESSION_MISMATCH" });
     expect(completeRun).toHaveBeenCalledWith(
@@ -83,7 +80,7 @@ describe("PiPrintAgentService", () => {
       resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]),
       acquireRun: vi.fn(),
     };
-    const early = new Service({
+    const early = new PiPrintAgentService({
       repository: earlyRepository,
       probe: { validate: vi.fn() },
       runner: { run: vi.fn() },
@@ -95,8 +92,6 @@ describe("PiPrintAgentService", () => {
   });
 
   it("rejects a non-Pi target without acquiring or mutating it", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Service = api.PiPrintAgentService as new (options: unknown) => any;
     const repository = {
       resolve: vi.fn().mockResolvedValue({ ...base, provider: "claude" }),
       acquireRun: vi.fn(),
@@ -105,18 +100,17 @@ describe("PiPrintAgentService", () => {
     };
 
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner: { run: vi.fn() } }).send(
-        "reviewer",
-        "x",
-      ),
+      new PiPrintAgentService({
+        repository,
+        probe: { validate: vi.fn() },
+        runner: { run: vi.fn() },
+      }).send("reviewer", "x"),
     ).rejects.toMatchObject({ code: "PI_UNSUPPORTED" });
     expect(repository.acquireRun).not.toHaveBeenCalled();
     expect(repository.completeRun).not.toHaveBeenCalled();
   });
 
   it("does not turn a successful completion write failure into a second completion", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Service = api.PiPrintAgentService as new (options: unknown) => any;
     const completionFailure = new Error("completion failed");
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
@@ -134,7 +128,10 @@ describe("PiPrintAgentService", () => {
     };
 
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner }).send("reviewer", "x"),
+      new PiPrintAgentService({ repository, probe: { validate: vi.fn() }, runner }).send(
+        "reviewer",
+        "x",
+      ),
     ).rejects.toBe(completionFailure);
     expect(repository.completeRun).toHaveBeenCalledOnce();
   });

package/src/__tests__/harnesses/pi/durable/PiPrintRunner.test.ts

@@ -1,7 +1,8 @@
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
 import { describe, expect, it, vi } from "vitest";
-import type { PiDurableAgent } from "../../../../index.js";
+import type { PiDurableAgent } from "../../../../durable/DurableAgent.js";
+import { PiPrintRunner } from "../../../../harnesses/pi/durable/PiPrintRunner.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 function agent(sessionHealth: PiDurableAgent["sessionHealth"] = "uninitialized"): PiDurableAgent {
@@ -63,10 +64,7 @@ function events(session = SESSION): string[] {
   ];
 }
 async function runner(fixture: ReturnType<typeof fakeSpawn>, maxLineBytes?: number) {
-  const api = (await import("../../../../index.js")) as Record<string, unknown>;
-  expect(api).toHaveProperty("PiPrintRunner");
-  const Runner = api.PiPrintRunner as new (options: unknown) => any;
-  return new Runner({
+  return new PiPrintRunner({
     spawn: fixture.spawn,
     maxLineBytes,
     processInspector: { getIdentity: () => ({ pid: 4242, startedAt: "start" }) },
@@ -154,10 +152,11 @@ describe("PiPrintRunner", () => {
       (await runner(fakeSpawn(events(), 1))).run({ agent: agent(), prompt: "x", onSpawn: vi.fn() }),
     ).rejects.toMatchObject({ code: "PI_PROCESS" });
     const fixture = fakeSpawn([]);
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Runner = api.PiPrintRunner as new (options: unknown) => any;
     await expect(
-      new Runner({ spawn: fixture.spawn, processInspector: { getIdentity: () => null } }).run({
+      new PiPrintRunner({
+        spawn: fixture.spawn,
+        processInspector: { getIdentity: () => null },
+      }).run({
         agent: agent(),
         prompt: "x",
         onSpawn: vi.fn(),