@kalenkevich/agent_007 0.0.1

package/tests/unit/cli/prompt_utils_test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import { isYes, parseUserAction } from "../../../src/cli/prompt_utils.js";
+
+describe("prompt_utils", () => {
+  describe("isYes", () => {
+    it("should return true for 'yes', 'y', 'accept' case-insensitive", () => {
+      expect(isYes("yes")).toBe(true);
+      expect(isYes("YES")).toBe(true);
+      expect(isYes("y")).toBe(true);
+      expect(isYes("Y")).toBe(true);
+      expect(isYes("accept")).toBe(true);
+      expect(isYes("Accept")).toBe(true);
+    });
+
+    it("should return false for other strings", () => {
+      expect(isYes("no")).toBe(false);
+      expect(isYes("n")).toBe(false);
+      expect(isYes("random")).toBe(false);
+    });
+
+    it("should handle whitespace", () => {
+      expect(isYes("  yes  ")).toBe(true);
+      expect(isYes("y ")).toBe(true);
+    });
+
+    it("should use default value for empty input", () => {
+      expect(isYes("")).toBe(false);
+      expect(isYes("", true)).toBe(true);
+      expect(isYes("  ")).toBe(false);
+      expect(isYes("  ", true)).toBe(true);
+    });
+  });
+
+  describe("parseUserAction", () => {
+    it("should return 'accept' for yes-like inputs", () => {
+      expect(parseUserAction("yes")).toBe("accept");
+      expect(parseUserAction("y")).toBe("accept");
+      expect(parseUserAction("accept")).toBe("accept");
+    });
+
+    it("should return 'decline' for other inputs", () => {
+      expect(parseUserAction("no")).toBe("decline");
+      expect(parseUserAction("n")).toBe("decline");
+      expect(parseUserAction("")).toBe("decline");
+    });
+  });
+});

package/tests/unit/cli_agent_test.ts

@@ -0,0 +1,476 @@
+import { describe, it, expect, vi } from "vitest";
+import { CliAgent } from "../../src/agent/cli_agent/cli_agent.js";
+import {
+  AgentEventType,
+  type ToolCallEvent,
+} from "../../src/agent/agent_event.js";
+import type { Tool } from "../../src/tools/tool.js";
+import type { ToolCallPolicy } from "../../src/tools/tool_call_policy.js";
+
+vi.mock("node:fs/promises", async (importOriginal) => {
+  const actual = (await importOriginal()) as any;
+  return {
+    ...actual,
+    readFile: vi.fn().mockResolvedValue("Mocked plan content"),
+  };
+});
+
+describe("CliAgent - Tool Confirmation", () => {
+  it("should request confirmation when policy requires it", async () => {
+    const mockModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield {
+          content: {
+            role: "agent",
+            parts: [
+              {
+                type: "function_call",
+                id: "call_123",
+                name: "test_tool",
+                args: { arg1: "val1" },
+              },
+            ],
+          },
+        };
+      }),
+    };
+
+    const mockTool: Tool = {
+      name: "test_tool",
+      description: "test",
+      params: {} as any,
+      output: {} as any,
+      execute: vi.fn().mockResolvedValue({ result: "ok" }),
+      toFunctionDeclaration: () => ({ name: "test_tool", description: "test" }),
+    };
+
+    const policy: ToolCallPolicy = { confirmationRequired: true };
+
+    const agent = new CliAgent({
+      model: mockModel as any,
+      toolPolicies: { test_tool: policy },
+      tools: [mockTool],
+    });
+
+    const events: any[] = [];
+    for await (const event of agent.run("hello")) {
+      console.log("Event yielded:", event.type);
+      events.push(event);
+    }
+
+    expect(events.length).toBe(4);
+    expect(events[0].type).toBe(AgentEventType.START);
+    expect(events[1].type).toBe(AgentEventType.MESSAGE);
+    expect(events[2].type).toBe(AgentEventType.TOOL_CALL);
+    expect(events[3].type).toBe(AgentEventType.USER_INPUT_REQUEST);
+    expect(events[3].requestId).toBe("call_123");
+
+    expect(mockTool.execute).not.toHaveBeenCalled();
+  });
+
+  it("should execute tool when resumed with 'yes'", async () => {
+    const mockModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield {
+          content: {
+            role: "agent",
+            parts: [{ type: "text", text: "Model response after tool" }],
+          },
+        };
+      }),
+    };
+
+    const mockTool: Tool = {
+      name: "test_tool",
+      description: "test",
+      params: {} as any,
+      output: {} as any,
+      execute: vi.fn().mockResolvedValue({ result: "ok" }),
+      toFunctionDeclaration: () => ({ name: "test_tool", description: "test" }),
+    };
+
+    const policy: ToolCallPolicy = { confirmationRequired: true };
+
+    const agent = new CliAgent({
+      model: mockModel as any,
+      toolPolicies: { test_tool: policy },
+      tools: [mockTool],
+    });
+
+    const streamId = "stream_123";
+    (agent as any).history = [
+      { type: AgentEventType.START, streamId, id: "1" } as any,
+      {
+        type: AgentEventType.MESSAGE,
+        streamId,
+        id: "2",
+        role: "user",
+        parts: [{ type: "text", text: "hello" }],
+      } as any,
+      {
+        type: AgentEventType.TOOL_CALL,
+        streamId,
+        id: "3",
+        requestId: "call_123",
+        name: "test_tool",
+        args: {},
+      } as any,
+      {
+        type: AgentEventType.USER_INPUT_REQUEST,
+        streamId,
+        id: "4",
+        requestId: "call_123",
+        message: "Confirm?",
+      } as any,
+    ];
+    (agent as any).historyContent = [
+      { role: "user", parts: [{ type: "text", text: "hello" }] },
+      {
+        role: "agent",
+        parts: [
+          {
+            type: "function_call",
+            id: "call_123",
+            name: "test_tool",
+            args: {},
+          },
+        ],
+      },
+    ];
+    (agent as any).streamId = streamId;
+
+    const events: any[] = [];
+    for await (const event of agent.run({
+      type: AgentEventType.USER_INPUT_RESPONSE,
+      id: "resp_123",
+      streamId,
+      timestamp: new Date().toISOString(),
+      role: "user",
+      requestId: "call_123",
+      action: "accept",
+    })) {
+      console.log("Event yielded (yes):", event.type);
+      events.push(event);
+    }
+
+    expect(events.length).toBe(3);
+    expect(events[0].type).toBe(AgentEventType.TOOL_RESPONSE);
+    expect(events[2].type).toBe(AgentEventType.END);
+    expect(events[0].requestId).toBe("call_123");
+    expect(events[0].result).toEqual({ result: "ok" });
+
+    expect(mockTool.execute).toHaveBeenCalled();
+  });
+
+  it("should decline tool when resumed with 'no'", async () => {
+    const mockModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield {
+          content: {
+            role: "agent",
+            parts: [{ type: "text", text: "Model response after decline" }],
+          },
+        };
+      }),
+    };
+
+    const mockTool: Tool = {
+      name: "test_tool",
+      description: "test",
+      params: {} as any,
+      output: {} as any,
+      execute: vi.fn().mockResolvedValue({ result: "ok" }),
+      toFunctionDeclaration: () => ({ name: "test_tool", description: "test" }),
+    };
+
+    const policy: ToolCallPolicy = { confirmationRequired: true };
+
+    const agent = new CliAgent({
+      model: mockModel as any,
+      toolPolicies: { test_tool: policy },
+      tools: [mockTool],
+    });
+
+    const streamId = "stream_123";
+    (agent as any).history = [
+      { type: AgentEventType.START, streamId, id: "1" } as any,
+      {
+        type: AgentEventType.MESSAGE,
+        streamId,
+        id: "2",
+        role: "user",
+        parts: [{ type: "text", text: "hello" }],
+      } as any,
+      {
+        type: AgentEventType.TOOL_CALL,
+        streamId,
+        id: "3",
+        requestId: "call_123",
+        name: "test_tool",
+        args: {},
+      } as any,
+      {
+        type: AgentEventType.USER_INPUT_REQUEST,
+        streamId,
+        id: "4",
+        requestId: "call_123",
+        message: "Confirm?",
+      } as any,
+    ];
+    (agent as any).historyContent = [
+      { role: "user", parts: [{ type: "text", text: "hello" }] },
+      {
+        role: "agent",
+        parts: [
+          {
+            type: "function_call",
+            id: "call_123",
+            name: "test_tool",
+            args: {},
+          },
+        ],
+      },
+    ];
+    (agent as any).streamId = streamId;
+
+    const events: any[] = [];
+    for await (const event of agent.run({
+      type: AgentEventType.USER_INPUT_RESPONSE,
+      id: "resp_456",
+      streamId,
+      timestamp: new Date().toISOString(),
+      role: "user",
+      requestId: "call_123",
+      action: "decline",
+    })) {
+      console.log("Event yielded (no):", event.type);
+      events.push(event);
+    }
+
+    expect(events.length).toBe(3);
+    expect(events[0].type).toBe(AgentEventType.TOOL_RESPONSE);
+    expect(events[2].type).toBe(AgentEventType.END);
+    expect(events[0].requestId).toBe("call_123");
+    expect(events[0].error).toBe("User declined tool execution");
+
+    expect(mockTool.execute).not.toHaveBeenCalled();
+  });
+
+  it("should trigger context compaction when token limit is exceeded", async () => {
+    const mockModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield {
+          content: {
+            role: "agent",
+            parts: [{ type: "text", text: "Response after compaction" }],
+          },
+        };
+      }),
+      countTokens: vi.fn().mockResolvedValue(1000),
+      modelName: "mock-model",
+    };
+
+    const agent = new CliAgent({
+      model: mockModel as any,
+      compactionConfig: {
+        enabled: true,
+        strategy: "truncate",
+        maxTokens: 800,
+        triggerThreshold: 0.8,
+      },
+    });
+
+    (agent as any).historyContent = [
+      { role: "user", parts: [{ type: "text", text: "m1" }] },
+      { role: "agent", parts: [{ type: "text", text: "r1" }] },
+      { role: "user", parts: [{ type: "text", text: "m2" }] },
+      { role: "agent", parts: [{ type: "text", text: "r2" }] },
+      { role: "user", parts: [{ type: "text", text: "m3" }] },
+      { role: "agent", parts: [{ type: "text", text: "r3" }] },
+      { role: "user", parts: [{ type: "text", text: "m4" }] },
+      { role: "agent", parts: [{ type: "text", text: "r4" }] },
+      { role: "user", parts: [{ type: "text", text: "m5" }] },
+      { role: "agent", parts: [{ type: "text", text: "r5" }] },
+    ];
+
+    const events: any[] = [];
+    for await (const event of agent.run("hello")) {
+      events.push(event);
+    }
+
+    expect(events.map((e) => e.type)).toContain(AgentEventType.MESSAGE);
+
+    const compactionMessage = events.find(
+      (e) =>
+        e.type === AgentEventType.COMPACTION &&
+        e.parts &&
+        e.parts[0].text &&
+        e.parts[0].text.includes("Context compacted"),
+    );
+    expect(compactionMessage).toBeTruthy();
+
+    // Initial 10 + 1 (user) = 11. Remove 2 = 9. Add compaction message = 10. Add response = 11.
+    expect((agent as any).historyContent.length).toBe(11);
+
+    // Check that the oldest messages were removed (m1 and r1)
+    // So the new first message should be m2
+    const firstContent = (agent as any).historyContent[0];
+    expect(firstContent.parts[0].text).toBe("m2");
+  });
+
+  it("should trigger context compaction with 'compact' strategy", async () => {
+    const mockModel = {
+      run: vi.fn().mockImplementation(async function* (request) {
+        if (
+          request.contents[0].parts[0].text.includes(
+            "Summarize the following conversation",
+          )
+        ) {
+          yield {
+            content: {
+              role: "agent",
+              parts: [{ type: "text", text: "Summarized history" }],
+            },
+          };
+          return;
+        }
+        yield {
+          content: {
+            role: "agent",
+            parts: [{ type: "text", text: "Response after compaction" }],
+          },
+        };
+      }),
+      countTokens: vi.fn().mockResolvedValue(1000),
+      modelName: "mock-model",
+    };
+
+    const agent = new CliAgent({
+      model: mockModel as any,
+      compactionConfig: {
+        enabled: true,
+        strategy: "summarize",
+        maxTokens: 800,
+        triggerThreshold: 0.8,
+      },
+    });
+
+    (agent as any).historyContent = [
+      { role: "user", parts: [{ type: "text", text: "m1" }] },
+      { role: "agent", parts: [{ type: "text", text: "r1" }] },
+    ];
+
+    const events: any[] = [];
+    for await (const event of agent.run("hello")) {
+      events.push(event);
+    }
+
+    expect(events.map((e) => e.type)).toContain(AgentEventType.MESSAGE);
+
+    const compactionMessage = events.find(
+      (e) =>
+        e.type === AgentEventType.COMPACTION &&
+        e.parts &&
+        e.parts[0].text &&
+        e.parts[0].text.includes("Context compacted using LLM summarization"),
+    );
+    expect(compactionMessage).toBeTruthy();
+
+    expect((agent as any).historyContent.length).toBe(3);
+
+    const firstContent = (agent as any).historyContent[0];
+    expect(firstContent.parts[0].text).toContain(
+      "Summary of previous conversation",
+    );
+    expect(firstContent.parts[0].text).toContain("Summarized history");
+  });
+});
+
+describe("CliAgent - Basic Flow", () => {
+  it("should yield message events when model responds with text", async () => {
+    const mockModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield {
+          content: {
+            role: "agent",
+            parts: [{ type: "text", text: "Hello from agent" }],
+          },
+        };
+      }),
+      countTokens: vi.fn().mockResolvedValue(10),
+    };
+
+    const agent = new CliAgent({
+      model: mockModel as any,
+    });
+
+    const events: any[] = [];
+    for await (const event of agent.run("hello")) {
+      events.push(event);
+    }
+
+    expect(events.length).toBe(4); // START, MESSAGE (user), MESSAGE (agent), END
+    expect(events[0].type).toBe(AgentEventType.START);
+    expect(events[1].type).toBe(AgentEventType.MESSAGE); // User message
+    expect(events[2].type).toBe(AgentEventType.MESSAGE); // Agent response
+    expect(events[2].parts[0].text).toBe("Hello from agent");
+    expect(events[3].type).toBe(AgentEventType.END);
+  });
+});
+
+describe("CliAgent - Plan Execution", () => {
+  it("should execute plan when resumed with approved plan", async () => {
+    const mockModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield {
+          content: {
+            role: "agent",
+            parts: [{ type: "text", text: "Model response executing plan" }],
+          },
+        };
+      }),
+    };
+
+    const agent = new CliAgent({
+      model: mockModel as any,
+    });
+
+    const streamId = "stream_123";
+    (agent as any).history = [
+      {
+        type: AgentEventType.USER_INPUT_REQUEST,
+        streamId,
+        id: "1",
+        requestId: "req_123",
+        message: "Do you approve this plan?",
+        requestSchema: {
+          type: "plan_approval",
+          planFilePath: "/tmp/plan_123.md",
+        },
+      } as any,
+    ];
+    (agent as any).streamId = streamId;
+
+    const events: any[] = [];
+    for await (const event of agent.run({
+      type: AgentEventType.USER_INPUT_RESPONSE,
+      id: "resp_123",
+      streamId,
+      timestamp: new Date().toISOString(),
+      role: "user",
+      requestId: "req_123",
+      action: "accept",
+    })) {
+      events.push(event);
+    }
+
+    expect(events.map((e) => e.type)).toContain(AgentEventType.MESSAGE);
+
+    const planMessage = events.find(
+      (e) => e.type === AgentEventType.MESSAGE && e.role === "user",
+    );
+    expect(planMessage).toBeTruthy();
+    expect(planMessage.parts[0].text).toContain("Plan approved");
+    expect(planMessage.parts[0].text).toContain("Mocked plan content");
+  });
+});

package/tests/unit/content_test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import {
+  isTextContentPart,
+  isThoughtContentPart,
+  isMediaContentPart,
+  isFunctionCallContentPart,
+  isFunctionResponseContentPart,
+  ContentPart,
+} from "../../src/content";
+
+describe("content type guards", () => {
+  it("should identify text content part", () => {
+    const part: ContentPart = { type: "text", text: "hello" };
+    expect(isTextContentPart(part)).toBe(true);
+    expect(isThoughtContentPart(part)).toBe(false);
+    expect(isMediaContentPart(part)).toBe(false);
+    expect(isFunctionCallContentPart(part)).toBe(false);
+    expect(isFunctionResponseContentPart(part)).toBe(false);
+  });
+
+  it("should identify thought content part", () => {
+    const part: ContentPart = { type: "thought", thought: "thinking" };
+    expect(isThoughtContentPart(part)).toBe(true);
+    expect(isTextContentPart(part)).toBe(false);
+    expect(isMediaContentPart(part)).toBe(false);
+    expect(isFunctionCallContentPart(part)).toBe(false);
+    expect(isFunctionResponseContentPart(part)).toBe(false);
+  });
+
+  it("should identify media content part", () => {
+    const part: ContentPart = { type: "media", uri: "http://example.com" };
+    expect(isMediaContentPart(part)).toBe(true);
+    expect(isTextContentPart(part)).toBe(false);
+    expect(isThoughtContentPart(part)).toBe(false);
+    expect(isFunctionCallContentPart(part)).toBe(false);
+    expect(isFunctionResponseContentPart(part)).toBe(false);
+  });
+
+  it("should identify function call content part", () => {
+    const part: ContentPart = { type: "function_call", name: "greet" };
+    expect(isFunctionCallContentPart(part)).toBe(true);
+    expect(isTextContentPart(part)).toBe(false);
+    expect(isThoughtContentPart(part)).toBe(false);
+    expect(isMediaContentPart(part)).toBe(false);
+    expect(isFunctionResponseContentPart(part)).toBe(false);
+  });
+
+  it("should identify function response content part", () => {
+    const part: ContentPart = { type: "function_response", name: "greet" };
+    expect(isFunctionResponseContentPart(part)).toBe(true);
+    expect(isTextContentPart(part)).toBe(false);
+    expect(isThoughtContentPart(part)).toBe(false);
+    expect(isMediaContentPart(part)).toBe(false);
+    expect(isFunctionCallContentPart(part)).toBe(false);
+  });
+});

package/tests/unit/logger_test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import { Logger, ConsoleTransport } from "../../src/logger";
+
+vi.mock("fs", async () => {
+  const actual = await vi.importActual<typeof import("fs")>("fs");
+  return {
+    ...actual,
+    appendFileSync: vi.fn(),
+  };
+});
+
+describe("Logger", () => {
+  let consoleLogSpy: any;
+  let consoleInfoSpy: any;
+  let consoleWarnSpy: any;
+  let consoleErrorSpy: any;
+
+  beforeEach(() => {
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    consoleInfoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.mocked(fs.appendFileSync).mockClear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should log to console.log", () => {
+    const logger = new Logger([new ConsoleTransport(true)]);
+    logger.log("test log");
+    expect(consoleLogSpy).toHaveBeenCalledWith("test log");
+  });
+
+  it("should log to console.info", () => {
+    const logger = new Logger([new ConsoleTransport(true)]);
+    logger.info("test info");
+    expect(consoleInfoSpy).toHaveBeenCalledWith("test info");
+  });
+
+  it("should log to console.warn", () => {
+    const logger = new Logger([new ConsoleTransport(true)]);
+    logger.warn("test warn");
+    expect(consoleWarnSpy).toHaveBeenCalledWith("test warn");
+  });
+
+  it("should log to console.error", () => {
+    const logger = new Logger([new ConsoleTransport(true)]);
+    logger.error("test error");
+    expect(consoleErrorSpy).toHaveBeenCalledWith("test error");
+  });
+
+  it("should write to file if DEBUG_LOGGER is set", () => {
+    process.env.DEBUG_LOGGER = "true";
+    const logger = new Logger();
+    logger.log("test file log");
+    expect(fs.appendFileSync).toHaveBeenCalled();
+    const call = vi.mocked(fs.appendFileSync).mock.calls[0];
+    expect(call[0]).toContain("debug.log");
+    expect(call[1]).toContain("test file log");
+    delete process.env.DEBUG_LOGGER;
+  });
+
+  it("should NOT write to file if DEBUG_LOGGER is not set", () => {
+    delete process.env.DEBUG_LOGGER;
+    const logger = new Logger();
+    logger.log("test no file log");
+    expect(fs.appendFileSync).not.toHaveBeenCalled();
+  });
+
+  it("should format message with timestamp and level", () => {
+    process.env.DEBUG_LOGGER = "true";
+    const logger = new Logger();
+    logger.log("test format");
+    expect(fs.appendFileSync).toHaveBeenCalled();
+    const call = vi.mocked(fs.appendFileSync).mock.calls[0];
+    expect(call[1]).toMatch(
+      /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[LOG\] test format/,
+    );
+    delete process.env.DEBUG_LOGGER;
+  });
+
+  it("should use custom transport", () => {
+    const mockTransport = {
+      enabled: true,
+      log: vi.fn(),
+    };
+    const logger = new Logger([mockTransport]);
+    logger.log("test custom log");
+    expect(mockTransport.log).toHaveBeenCalledWith(
+      "LOG",
+      expect.stringMatching(
+        /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[LOG\] test custom log/,
+      ),
+      ["test custom log"],
+    );
+  });
+
+  it("should use multiple custom transports", () => {
+    const mockTransport1 = { enabled: true, log: vi.fn() };
+    const mockTransport2 = { enabled: true, log: vi.fn() };
+    const logger = new Logger([mockTransport1, mockTransport2]);
+    logger.log("test multiple");
+    expect(mockTransport1.log).toHaveBeenCalled();
+    expect(mockTransport2.log).toHaveBeenCalled();
+  });
+});