@ai-devkit/agent-manager 0.36.0 → 0.37.0

package/src/__tests__/harnesses/grok/GrokSessionParser.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Tests for GrokSessionParser's summary path.
+ *
+ * `legacyReadSession` is a verbatim copy of the pre-incremental algorithm
+ * (full read + ConversationMessage[] build), kept here as an oracle so the
+ * reducer-based summary is checked field-for-field against it.
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import type { ConversationMessage } from "../../../adapters/AgentAdapter.js";
+import { GrokSessionParser } from "../../../harnesses/grok/GrokSessionParser.js";
+
+function legacyScan(chatPath: string) {
+  let content: string | undefined;
+  try {
+    content = fs.readFileSync(chatPath, "utf-8");
+  } catch {
+    content = undefined;
+  }
+  if (content === undefined) return {} as Record<string, string | undefined>;
+
+  const extractText = (value: unknown): string => {
+    if (typeof value === "string") return value;
+    if (Array.isArray(value)) {
+      return value
+        .map((block) =>
+          block && typeof block === "object" && typeof (block as any).text === "string"
+            ? (block as any).text
+            : "",
+        )
+        .join("");
+    }
+    return "";
+  };
+
+  const messages: ConversationMessage[] = [];
+  let lastRole: ConversationMessage["role"] | undefined;
+  for (const line of content.trim().split("\n")) {
+    if (!line.trim()) continue;
+    let record: any;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const text = extractText(record.content);
+    if (record.type === "user") {
+      const match = text.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/);
+      if (!match) continue;
+      messages.push({ role: "user", content: match[1].trim() });
+      lastRole = "user";
+    } else if (record.type === "assistant") {
+      if (!text) continue;
+      messages.push({ role: "assistant", content: text });
+      lastRole = "assistant";
+    }
+  }
+  const userTurns = messages.filter((m) => m.role === "user");
+  return {
+    firstUserMessage: userTurns[0]?.content,
+    lastUserMessage: userTurns[userTurns.length - 1]?.content,
+    lastRole,
+  };
+}
+
+function legacyReadSession(sessionDir: string, defaultCwd: string) {
+  const chatPath = path.join(sessionDir, "chat_history.jsonl");
+  const chatStat = fs.statSync(chatPath);
+  const scan = legacyScan(chatPath);
+  const dirStat = fs.statSync(sessionDir);
+  return {
+    sessionId: path.basename(sessionDir),
+    projectPath: defaultCwd,
+    sessionFilePath: chatPath,
+    sessionStart: dirStat?.birthtime || chatStat.mtime,
+    lastActive: chatStat.mtime,
+    firstUserMessage: scan.firstUserMessage,
+    lastUserMessage: scan.lastUserMessage,
+    lastRole: scan.lastRole,
+  };
+}
+
+const userRecord = (text: string) => ({
+  type: "user",
+  content: [{ type: "text", text: `<user_query>\n${text}\n</user_query>` }],
+});
+const contextRecord = (text: string) => ({ type: "user", content: [{ type: "text", text }] });
+const assistantRecord = (text: string) => ({
+  type: "assistant",
+  content: [{ type: "text", text }],
+});
+const systemRecord = (text: string) => ({ type: "system", content: text });
+const lines = (records: object[]) => records.map((r) => JSON.stringify(r)).join("\n");
+
+/** Raw chat_history.jsonl bodies covering the existing Grok fixtures plus edge cases. */
+const FIXTURES: Record<string, string> = {
+  "single prompt": lines([userRecord("fix the bug")]),
+  "user then assistant": lines([userRecord("go"), assistantRecord("done")]),
+  "summary is the last prompt": lines([
+    userRecord("refactor the parser"),
+    assistantRecord("on it"),
+  ]),
+  "context injection skipped": lines([
+    contextRecord("<user_info>OS: macos</user_info>"),
+    userRecord("do the thing"),
+  ]),
+  "context injection after assistant keeps assistant role": lines([
+    userRecord("first"),
+    assistantRecord("reply"),
+    contextRecord("<system-reminder>ping</system-reminder>"),
+  ]),
+  "system records ignored": lines([systemRecord("You are Grok"), userRecord("go")]),
+  "malformed trailing line": `${lines([userRecord("hi")])}\n{bad json`,
+  "multiple prompts, first and last differ": lines([
+    systemRecord("sys"),
+    contextRecord("<user_info>x</user_info>"),
+    userRecord("  first prompt  "),
+    assistantRecord("a1"),
+    userRecord("second prompt"),
+    assistantRecord(""),
+    { type: "user", content: "<user_query>third as string</user_query>" },
+    { type: "assistant", content: [{ type: "text", text: "part " }, { text: "two" }, 42, null] },
+  ]),
+  "empty assistant text does not change role": lines([userRecord("q"), assistantRecord("")]),
+  "trailing newline and blank lines": `\n\n${lines([userRecord("a"), assistantRecord("b")])}\n\n`,
+  "CRLF line endings": [userRecord("crlf"), assistantRecord("ok")]
+    .map((r) => JSON.stringify(r))
+    .join("\r\n"),
+  "non-object JSON values": `42\n"str"\n[1,2]\n${lines([userRecord("after scalars")])}`,
+  "unknown record types": lines([{ type: "tool", content: "x" }, userRecord("z"), { foo: 1 }]),
+  "empty file": "",
+  "only context injections": lines([contextRecord("<user_info>a</user_info>")]),
+};
+
+describe("GrokSessionParser summary", () => {
+  let tmpDir: string;
+  let parser: GrokSessionParser;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "grok-parser-test-"));
+    parser = new GrokSessionParser();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function writeChat(name: string, body: string): string {
+    const sessionDir = path.join(tmpDir, name.replace(/[^a-z0-9]+/gi, "-"));
+    fs.mkdirSync(sessionDir, { recursive: true });
+    fs.writeFileSync(path.join(sessionDir, "chat_history.jsonl"), body);
+    return sessionDir;
+  }
+
+  describe.each(Object.entries(FIXTURES))("fixture: %s", (name, body) => {
+    it("readSession matches the legacy full-parse output", () => {
+      const dir = writeChat(name, body);
+      expect(parser.readSession(dir, "/cwd")).toEqual(legacyReadSession(dir, "/cwd"));
+    });
+
+    it("readSessionIncremental matches the legacy full-parse output", () => {
+      const dir = writeChat(name, body);
+      expect(parser.readSessionIncremental(dir, "/cwd")).toEqual(legacyReadSession(dir, "/cwd"));
+      // cached second read is identical too
+      expect(parser.readSessionIncremental(dir, "/cwd")).toEqual(legacyReadSession(dir, "/cwd"));
+    });
+  });
+
+  it("incremental result tracks appends and matches a full parse", () => {
+    const dir = writeChat("append", `${lines([userRecord("one"), assistantRecord("r1")])}\n`);
+    parser.readSessionIncremental(dir, "/cwd");
+
+    const chatPath = path.join(dir, "chat_history.jsonl");
+    fs.appendFileSync(chatPath, `${lines([contextRecord("<user_info/>"), userRecord("two")])}`);
+    expect(parser.readSessionIncremental(dir, "/cwd")).toEqual(legacyReadSession(dir, "/cwd"));
+
+    // completes the previously unterminated line, then adds an assistant turn
+    fs.appendFileSync(chatPath, `\n${lines([assistantRecord("r2")])}\n`);
+    expect(parser.readSessionIncremental(dir, "/cwd")).toEqual(legacyReadSession(dir, "/cwd"));
+  });
+
+  it("returns null when chat_history.jsonl is missing", () => {
+    const dir = path.join(tmpDir, "no-chat");
+    fs.mkdirSync(dir);
+    expect(parser.readSession(dir, "/cwd")).toBeNull();
+    expect(parser.readSessionIncremental(dir, "/cwd")).toBeNull();
+  });
+
+  it("summary paths never build a conversation message array", () => {
+    const body = lines(
+      Array.from({ length: 500 }, (_, i) =>
+        i % 2 === 0 ? userRecord(`prompt ${i}`) : assistantRecord(`reply ${i}`),
+      ),
+    );
+    const dir = writeChat("many", body);
+    const buildSpy = vi.spyOn(parser as any, "parseChatHistory");
+
+    const full = parser.readSession(dir, "/cwd");
+    const incremental = parser.readSessionIncremental(dir, "/cwd");
+
+    expect(buildSpy).not.toHaveBeenCalled();
+    expect(full?.lastUserMessage).toBe("prompt 498");
+    expect(incremental).toEqual(full);
+
+    // the cached state is a fixed-shape record of scalars, not a list of turns
+    const state = (parser as any).sessionCache.read(path.join(dir, "chat_history.jsonl")).state;
+    expect(Object.keys(state).length).toBeLessThanOrEqual(3);
+    for (const value of Object.values(state)) {
+      expect(value === undefined || typeof value === "string").toBe(true);
+    }
+  });
+
+  it("getConversation still returns the full message list", () => {
+    const dir = writeChat("conv", FIXTURES["multiple prompts, first and last differ"]);
+    expect(parser.getConversation(dir)).toEqual([
+      { role: "user", content: "first prompt" },
+      { role: "assistant", content: "a1" },
+      { role: "user", content: "second prompt" },
+      { role: "user", content: "third as string" },
+      { role: "assistant", content: "part two" },
+    ]);
+    expect(parser.getConversation(dir, { verbose: true })[0]).toEqual({
+      role: "system",
+      content: "sys",
+    });
+  });
+});

package/src/__tests__/{adapters → harnesses/kiro}/KiroAdapter.test.ts

@@ -1,42 +1,27 @@
-/**
- * Tests for KiroAdapter
- */
-
 import type { MockedFunction } from "vitest";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 
-import { KiroAdapter } from "../../adapters/KiroAdapter.js";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
-import {
-  listAgentProcesses,
-  enrichProcesses,
-  captureProcessSnapshot,
-} from "../../utils/process.js";
-import { generateAgentName } from "../../utils/matching.js";
-
-vi.mock("../../utils/process.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/process.js");
-  return {
-    ...actual,
-    listAgentProcesses: vi.fn(),
-    enrichProcesses: vi.fn(),
-    captureProcessSnapshot: vi.fn(),
-  };
+import { KiroAdapter } from "../../../harnesses/kiro/KiroAdapter.js";
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import { captureProcessSnapshot } from "../../../utils/process.js";
+import { generateAgentName } from "../../../utils/matching.js";
+
+vi.mock("../../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/process.js");
+  return { ...actual, captureProcessSnapshot: vi.fn() };
 });
 
-vi.mock("../../utils/matching.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/matching.js");
+vi.mock("../../../utils/matching.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/matching.js");
   return {
     ...actual,
     generateAgentName: vi.fn(),
   };
 });
 
-const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
-const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
 const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<
   typeof captureProcessSnapshot
 >;
@@ -55,16 +40,8 @@ describe("KiroAdapter", () => {
 
     adapter = new KiroAdapter();
 
-    mockedListAgentProcesses.mockReset();
-    mockedEnrichProcesses.mockReset();
     mockedCaptureProcessSnapshot.mockReset();
     mockedGenerateAgentName.mockReset();
-
-    mockedEnrichProcesses.mockImplementation((procs) => procs);
-    // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
-    mockedCaptureProcessSnapshot.mockImplementation(async (names) =>
-      enrichProcesses(names.flatMap((name) => listAgentProcesses(name))),
-    );
     mockedGenerateAgentName.mockImplementation((cwd: string, pid: number) => {
       const folder = path.basename(cwd) || "unknown";
       return `${folder} (${pid})`;
@@ -75,88 +52,60 @@ describe("KiroAdapter", () => {
     fs.rmSync(tmpHome, { recursive: true, force: true });
   });
 
-  describe("initialization", () => {
-    it("exposes the kiro type and process names", () => {
-      expect(adapter.type).toBe("kiro");
-      expect(adapter.processNames).toEqual(["kiro-cli", "kiro", "kiro-cli-chat", "node"]);
-    });
+  it("exposes the kiro type and process names", () => {
+    expect(adapter.type).toBe("kiro");
+    expect(adapter.processNames).toEqual(["kiro-cli", "kiro", "kiro-cli-chat", "node", "bun"]);
   });
 
   describe("canHandle", () => {
-    it("identifies Kiro commands without matching unrelated paths", () => {
-      expect(adapter.canHandle({ pid: 1, command: "kiro-cli", cwd: "/repo", tty: "ttys001" })).toBe(
-        true,
-      );
-      expect(
-        adapter.canHandle({
-          pid: 2,
-          command: "/usr/local/bin/kiro --model x",
-          cwd: "/repo",
-          tty: "ttys002",
-        }),
-      ).toBe(true);
-      expect(
-        adapter.canHandle({
-          pid: 3,
-          command: "node /opt/kiro/bin/kiro-cli.js",
-          cwd: "/repo",
-          tty: "ttys003",
-        }),
-      ).toBe(true);
-      expect(
-        adapter.canHandle({
-          pid: 4,
-          command: "node /repo/feature-kiro-adapter/script.js",
-          cwd: "/repo",
-          tty: "ttys004",
-        }),
-      ).toBe(false);
-      expect(
-        adapter.canHandle({
-          pid: 5,
-          command: "kiro-cli chat",
-          cwd: "/repo",
-          tty: "ttys005",
-        }),
-      ).toBe(true);
-      expect(
-        adapter.canHandle({
-          pid: 6,
-          command: "bun /opt/kiro/bin/kiro-cli.js",
-          cwd: "/repo",
-          tty: "ttys006",
-        }),
-      ).toBe(true);
-      expect(
-        adapter.canHandle({
-          pid: 7,
-          command: "node /usr/local/bin/ai-devkit agent start --type kiro",
-          cwd: "/repo",
-          tty: "ttys007",
-        }),
-      ).toBe(false);
-      expect(
-        adapter.canHandle({
-          pid: 8,
-          command: "node server.js --name kiro",
-          cwd: "/repo",
-          tty: "ttys008",
-        }),
-      ).toBe(false);
-      expect(
-        adapter.canHandle({
-          pid: 9,
-          command: "kiro-cli-chat acp",
-          cwd: "/repo",
-          tty: "ttys009",
-        }),
-      ).toBe(false);
+    const handles = (command: string) =>
+      adapter.canHandle({ pid: 1, command, cwd: "/repo", tty: "ttys001" });
+
+    it.each([
+      "kiro-cli",
+      "kiro-cli chat",
+      "/usr/local/bin/kiro --model x",
+      "node /opt/kiro/bin/kiro-cli.js",
+      "bun /opt/kiro/bin/kiro-cli.js",
+    ])("handles %s", (command) => {
+      expect(handles(command)).toBe(true);
+    });
+
+    it.each([
+      "node /repo/feature-kiro-adapter/script.js",
+      "node /usr/local/bin/ai-devkit agent start --type kiro",
+      "node server.js --name kiro",
+      "kiro-cli-chat acp",
+    ])("ignores %s", (command) => {
+      expect(handles(command)).toBe(false);
+    });
+
+    it("identifies Kiro when the runtime or script path contains spaces", () => {
+      const root = fs.mkdtempSync(path.join(os.tmpdir(), "kiro-spaces-"));
+      try {
+        const install = (relativePath: string) => {
+          const fullPath = path.join(root, relativePath);
+          fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+          fs.writeFileSync(fullPath, "");
+          return fullPath;
+        };
+        const node = install("Applications/Dev Tools/bin/node");
+        const kiro = install("Applications/Kiro App.app/Contents/Resources/kiro-cli");
+        const script = install("My Tools/kiro/bin/kiro-cli.js");
+
+        expect(handles(`${kiro} chat --trust-all-tools`)).toBe(true);
+        expect(handles(`${node} /opt/kiro/bin/kiro-cli.js`)).toBe(true);
+        expect(handles(`${node} --no-warnings ${script} chat`)).toBe(true);
+        expect(handles(`${node} /repo/server.js --name My Dir/kiro-cli`)).toBe(false);
+      } finally {
+        fs.rmSync(root, { recursive: true, force: true });
+      }
     });
   });
 
   describe("detectAgents", () => {
     it("returns [] when there are no Kiro processes", async () => {
-      mockedListAgentProcesses.mockReturnValue([]);
+      mockedCaptureProcessSnapshot.mockResolvedValue([]);
       expect(await adapter.detectAgents()).toEqual([]);
     });
 
@@ -188,7 +137,50 @@ describe("KiroAdapter", () => {
       });
     });
 
-    it("matches a lock held by a kiro-cli-chat acp descendant when bun is not collected", async () => {
+    it("walks through the bundled bun TUI to the kiro-cli that owns an acp lock", async () => {
+      // Real kiro-cli tree: the acp helper has no tty, so only the parent chain links it.
+      const bun = path.join(tmpHome, "Library", "Application Support", "kiro-cli", "bun");
+      fs.mkdirSync(path.dirname(bun), { recursive: true });
+      fs.writeFileSync(bun, "");
+      const sessionFile = writeKiroSession(
+        "sess-bun",
+        "/repo/bun",
+        [prompt("hello", 1781098057)],
+        35355,
+      );
+      const kiro = makeProcess({ pid: 35261, command: "kiro-cli", ppid: 28496, tty: "ttys007" });
+      const chat = makeProcess({
+        pid: 35320,
+        command: "/home/.local/bin/kiro-cli-chat chat",
+        ppid: 35261,
+        tty: "ttys007",
+      });
+      const tui = makeProcess({
+        pid: 35349,
+        command: `${bun} --no-env-file ${path.dirname(bun)}/tui.js chat`,
+        ppid: 35320,
+        tty: "ttys007",
+      });
+      const acp = makeProcess({
+        pid: 35355,
+        command: "/home/.local/bin/kiro-cli-chat acp",
+        ppid: 35349,
+        tty: "??",
+      });
+      mockedCaptureProcessSnapshot.mockResolvedValue([kiro, chat, tui, acp]);
+
+      const agents = await adapter.detectAgents();
+
+      expect(agents).toEqual([
+        expect.objectContaining({
+          pid: 35261,
+          sessionId: "sess-bun",
+          sessionFilePath: sessionFile,
+        }),
+      ]);
+    });
+
+    it("falls back to the sole kiro-cli on the lock holder tty when its parent chain is broken", async () => {
       const cwd = "/repo/project-a";
       const sessionFile = writeKiroSession(
         "sess-acp",
@@ -436,6 +428,32 @@ describe("KiroAdapter", () => {
     });
   });
 
+  describe("findSessionsById", () => {
+    it("reads only the session stored under that id", async () => {
+      const sessionFile = writeKiroSession("sess-find", "/repo/find", [
+        prompt("find me", 1781098057),
+      ]);
+      writeKiroSession("sess-other", "/repo/other", [prompt("not me", 1781098057)]);
+
+      expect(await adapter.findSessionsById("sess-find")).toEqual([
+        expect.objectContaining({
+          type: "kiro",
+          sessionId: "sess-find",
+          cwd: "/repo/find",
+          firstUserMessage: "find me",
+          sessionFilePath: sessionFile,
+        }),
+      ]);
+    });
+
+    it("returns [] for a missing or unsafe id", async () => {
+      writeKiroSession("sess-find", "/repo/find", [prompt("find me", 1781098057)]);
+
+      expect(await adapter.findSessionsById("missing")).toEqual([]);
+      expect(await adapter.findSessionsById("../cli/sess-find")).toEqual([]);
+    });
+  });
+
   function makeProcess(overrides: Partial<ProcessInfo>): ProcessInfo {
     return {
       pid: 1,

package/src/__tests__/{providers → harnesses}/opencode/OpenCodeAdapter.test.ts

@@ -4,7 +4,7 @@ import * as os from "os";
 import * as path from "path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
-import { OpenCodeAdapter } from "../../../providers/opencode/OpenCodeAdapter.js";
+import { OpenCodeAdapter } from "../../../harnesses/opencode/OpenCodeAdapter.js";
 
 describe("OpenCodeAdapter", () => {
   let adapter: OpenCodeAdapter;

package/src/__tests__/{providers → harnesses}/opencode/OpenCodeAgentMapper.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { AgentStatus } from "../../../adapters/AgentAdapter.js";
-import { OpenCodeAgentMapper } from "../../../providers/opencode/OpenCodeAgentMapper.js";
+import { OpenCodeAgentMapper } from "../../../harnesses/opencode/OpenCodeAgentMapper.js";
 
 describe("OpenCodeAgentMapper", () => {
   const mapper = new OpenCodeAgentMapper("/tmp/opencode.db");

package/src/__tests__/{providers → harnesses}/opencode/OpenCodeSessionLocator.test.ts

@@ -3,8 +3,8 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { OpenCodeSessionLocator } from "../../../providers/opencode/OpenCodeSessionLocator.js";
-import { OpenCodeSessionParser } from "../../../providers/opencode/OpenCodeSessionParser.js";
+import { OpenCodeSessionLocator } from "../../../harnesses/opencode/OpenCodeSessionLocator.js";
+import { OpenCodeSessionParser } from "../../../harnesses/opencode/OpenCodeSessionParser.js";
 
 describe("OpenCodeSessionLocator", () => {
   let tmpDir: string;

package/src/__tests__/{providers → harnesses}/opencode/OpenCodeSessionParser.test.ts

@@ -1,6 +1,6 @@
 import Database from "better-sqlite3";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { OpenCodeSessionParser } from "../../../providers/opencode/OpenCodeSessionParser.js";
+import { OpenCodeSessionParser } from "../../../harnesses/opencode/OpenCodeSessionParser.js";
 
 describe("OpenCodeSessionParser", () => {
   let db: Database.Database;

package/src/__tests__/{providers → harnesses}/pi/PiAdapter.test.ts

@@ -8,7 +8,7 @@ import * as os from "os";
 import * as path from "path";
 
 import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
-import { PiAdapter } from "../../../providers/pi/PiAdapter.js";
+import { PiAdapter } from "../../../harnesses/pi/PiAdapter.js";
 import { AgentRegistry } from "../../../utils/AgentRegistry.js";
 import { captureProcessSnapshot } from "../../../utils/process.js";
 import { generateAgentName, matchProcessesToSessions } from "../../../utils/matching.js";