@kalenkevich/agent_007 0.0.1

package/tests/unit/loop_test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi } from "vitest";
+import { CoreAgentLoop, AgentLoopType } from "../../src/core/loop.js";
+import { CliAgent } from "../../src/agent/cli_agent/cli_agent.js";
+import { AgentEventType } from "../../src/agent/agent_event.js";
+
+vi.mock("../../src/agent/cli_agent/cli_agent.js");
+
+vi.mock("../../src/model/adaptive_model.js");
+
+vi.mock("../../src/session/session_file_service.js", () => {
+  return {
+    SessionFileService: class {
+      getSession = vi.fn().mockResolvedValue({ events: [], title: undefined });
+      getSessionMetadata = vi.fn().mockResolvedValue({ title: undefined });
+      createSession = vi.fn().mockResolvedValue({ id: "test-session-id" });
+      appendEvent = vi.fn().mockResolvedValue(undefined);
+      updateSession = vi.fn().mockResolvedValue(undefined);
+    },
+  };
+});
+
+describe("CoreAgentLoop", () => {
+  it("should yield events on success", async () => {
+    const mockAgent = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield { type: AgentEventType.START, streamId: "123" };
+        yield { type: AgentEventType.END, streamId: "123" };
+      }),
+    };
+    vi.mocked(CliAgent).mockImplementation(function () {
+      return mockAgent as any;
+    });
+
+    const loop = new CoreAgentLoop({
+      models: {
+        main: { modelName: "gemini-3.1-pro-preview", apiKey: "dummy" },
+        util: { modelName: "gemini-3-flash-preview", apiKey: "dummy" },
+      },
+    } as any);
+
+    const events: any[] = [];
+    loop.on(AgentLoopType.AGENT_EVENT, (event) => {
+      events.push(event);
+    });
+
+    await loop.run("hello");
+
+    expect(events.length).toBe(2);
+    expect(events[0].type).toBe(AgentEventType.START);
+    expect(events[1].type).toBe(AgentEventType.END);
+  });
+
+  it("should handle errors and emit ERROR event", async () => {
+    const mockAgent = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield { type: AgentEventType.START, streamId: "123" };
+        throw new Error("Test error");
+      }),
+    };
+    vi.mocked(CliAgent).mockImplementation(function () {
+      return mockAgent as any;
+    });
+
+    const loop = new CoreAgentLoop({
+      models: {
+        main: { modelName: "gemini-3.1-pro-preview", apiKey: "dummy" },
+        util: { modelName: "gemini-3-flash-preview", apiKey: "dummy" },
+      },
+    } as any);
+
+    const events: any[] = [];
+    loop.on(AgentLoopType.AGENT_EVENT, (event) => {
+      events.push(event);
+    });
+
+    await loop.run("hello");
+
+    expect(events.length).toBe(2);
+    expect(events[0].type).toBe(AgentEventType.START);
+    expect(events[1].type).toBe(AgentEventType.ERROR);
+    expect(events[1].errorMessage).toBe("Test error");
+    expect(events[1].streamId).toBe("123"); // Should use last seen streamId
+  });
+
+  it("should fallback to unknown streamId if error occurs before any event", async () => {
+    const mockAgent = {
+      run: vi.fn().mockImplementation(async function* () {
+        throw new Error("Immediate error");
+      }),
+    };
+    vi.mocked(CliAgent).mockImplementation(function () {
+      return mockAgent as any;
+    });
+
+    const loop = new CoreAgentLoop({
+      models: {
+        main: { modelName: "gemini-3.1-pro-preview", apiKey: "dummy" },
+        util: { modelName: "gemini-3-flash-preview", apiKey: "dummy" },
+      },
+    } as any);
+
+    const events: any[] = [];
+    loop.on(AgentLoopType.AGENT_EVENT, (event) => {
+      events.push(event);
+    });
+
+    await loop.run("hello");
+
+    expect(events.length).toBe(1);
+    expect(events[0].type).toBe(AgentEventType.ERROR);
+    expect(events[0].errorMessage).toBe("Immediate error");
+    expect(events[0].streamId).toBe("unknown");
+  });
+
+  it("should append events to session service", async () => {
+    const mockAgent = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield { type: AgentEventType.START, streamId: "123" };
+        yield { type: AgentEventType.END, streamId: "123" };
+      }),
+    };
+    vi.mocked(CliAgent).mockImplementation(function () {
+      return mockAgent as any;
+    });
+
+    const loop = new CoreAgentLoop({
+      models: {
+        main: { modelName: "gemini-3.1-pro-preview", apiKey: "dummy" },
+        util: { modelName: "gemini-3-flash-preview", apiKey: "dummy" },
+      },
+    } as any);
+
+    const mockSessionService = (loop as any).sessionService;
+
+    await loop.run("hello");
+
+    expect(mockSessionService.appendEvent).toHaveBeenCalledTimes(2);
+    expect(mockSessionService.appendEvent).toHaveBeenCalledWith("test-session-id", expect.objectContaining({ type: AgentEventType.START }));
+    expect(mockSessionService.appendEvent).toHaveBeenCalledWith("test-session-id", expect.objectContaining({ type: AgentEventType.END }));
+  });
+});

package/tests/unit/model/gemini_model_test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Gemini } from "../../../src/model/google/gemini_model.js";
+
+vi.mock("@google/genai", () => {
+  const mockGenerateContent = vi.fn();
+  const mockGenerateContentStream = vi.fn();
+  const mockCountTokens = vi.fn();
+
+  return {
+    GoogleGenAI: vi.fn().mockImplementation(function () {
+      return {
+        models: {
+          generateContent: mockGenerateContent,
+          generateContentStream: mockGenerateContentStream,
+          countTokens: mockCountTokens,
+        },
+      };
+    }),
+    ThinkingLevel: {
+      LOW: "LOW",
+      MEDIUM: "MEDIUM",
+      HIGH: "HIGH",
+    },
+  };
+});
+
+describe("Gemini Model", () => {
+  let gemini: Gemini;
+  let mockClient: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    gemini = new Gemini({ modelName: "test-model", apiKey: "test-key" });
+    mockClient = (gemini as any).client;
+  });
+
+  it("should call generateContent for non-streaming request", async () => {
+    const mockResponse = {
+      candidates: [
+        {
+          content: {
+            parts: [{ text: "Hello response" }],
+          },
+        },
+      ],
+    };
+    mockClient.models.generateContent.mockResolvedValue(mockResponse);
+
+    const generator = gemini.run({
+      contents: [{ role: "user", parts: [{ type: "text", text: "hello" }] }],
+    });
+    const results = [];
+    for await (const res of generator) {
+      results.push(res);
+    }
+
+    expect(mockClient.models.generateContent).toHaveBeenCalled();
+    expect(results.length).toBe(1);
+    expect(results[0].errorCode).toBeUndefined();
+  });
+
+  it("should call generateContentStream for streaming request", async () => {
+    const mockStream = [
+      {
+        candidates: [
+          {
+            content: {
+              parts: [{ text: "Hello " }],
+            },
+          },
+        ],
+      },
+      {
+        candidates: [
+          {
+            content: {
+              parts: [{ text: "response" }],
+            },
+          },
+        ],
+      },
+    ];
+
+    mockClient.models.generateContentStream.mockResolvedValue(mockStream);
+
+    const generator = gemini.run(
+      {
+        contents: [{ role: "user", parts: [{ type: "text", text: "hello" }] }],
+      },
+      { stream: true },
+    );
+    const results = [];
+    for await (const res of generator) {
+      results.push(res);
+    }
+
+    expect(mockClient.models.generateContentStream).toHaveBeenCalled();
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("should call countTokens", async () => {
+    mockClient.models.countTokens.mockResolvedValue({ totalTokens: 42 });
+
+    const tokens = await gemini.countTokens({
+      contents: [{ role: "user", parts: [{ type: "text", text: "hello" }] }],
+    });
+
+    expect(mockClient.models.countTokens).toHaveBeenCalled();
+    expect(tokens).toBe(42);
+  });
+});

package/tests/unit/planner_agent_test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { PlannerAgent } from "../../src/agent/planner_agent/planner_agent.js";
+import { AgentEventType } from "../../src/agent/agent_event.js";
+import * as fs from "node:fs/promises";
+
+vi.mock("node:fs/promises", async (importOriginal) => {
+  const actual = (await importOriginal()) as any;
+  return {
+    ...actual,
+    writeFile: vi.fn().mockResolvedValue(undefined),
+  };
+});
+
+describe("PlannerAgent", () => {
+  const mockModel = {
+    run: vi.fn().mockImplementation(async function* () {
+      yield {
+        content: {
+          role: "agent",
+          parts: [{ type: "text", text: "Step 1: Do something\nStep 2: Done" }],
+        },
+      };
+    }),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should generate plan and ask for approval", async () => {
+    const agent = new PlannerAgent({
+      model: mockModel as any,
+    });
+
+    const events: any[] = [];
+    for await (const event of agent.run("Plan a trip")) {
+      events.push(event);
+    }
+
+    expect(mockModel.run).toHaveBeenCalled();
+    expect(fs.writeFile).toHaveBeenCalled();
+
+    expect(events.length).toBeGreaterThanOrEqual(4);
+    expect(events[0].type).toBe(AgentEventType.START);
+
+    const userInputRequest = events.find(
+      (e) => e.type === AgentEventType.USER_INPUT_REQUEST,
+    );
+    expect(userInputRequest).toBeTruthy();
+    expect(userInputRequest.requestSchema.type).toBe("plan_approval");
+  });
+});

package/tests/unit/project_service_test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ProjectService } from "../../src/core/project_service.js";
+import { configStore } from "../../src/config/config_store.js";
+import { createHash } from "node:crypto";
+
+vi.mock("../../src/config/config_store.js");
+
+describe("ProjectService", () => {
+  const mockCwd = "/mock/project";
+  let service: ProjectService;
+  let expectedProjectId: string;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    service = new ProjectService(mockCwd);
+    expectedProjectId = createHash("sha256").update(mockCwd).digest("hex");
+  });
+
+  describe("constructor", () => {
+    it("should use default process.cwd() if not provided", () => {
+      const mockProcessCwd = "/default/cwd";
+      const spy = vi.spyOn(process, "cwd").mockReturnValue(mockProcessCwd);
+
+      const defaultService = new ProjectService();
+      const expectedHash = createHash("sha256")
+        .update(mockProcessCwd)
+        .digest("hex");
+
+      expect(defaultService.getProjectId()).toBe(expectedHash);
+
+      spy.mockRestore();
+    });
+  });
+
+  describe("getProjectId", () => {
+    it("should return the sha256 hash of the cwd", () => {
+      expect(service.getProjectId()).toBe(expectedProjectId);
+    });
+  });
+
+  describe("getConstantsPath", () => {
+    it("should return the correct path including project ID", () => {
+      expect(service.getConstantsPath()).toBe(
+        `projects/${expectedProjectId}/constants.json`,
+      );
+    });
+  });
+
+  describe("getConstants", () => {
+    it("should call configStore.get with the correct path", async () => {
+      const mockData = JSON.stringify({ foo: "bar" });
+      vi.mocked(configStore.get).mockResolvedValue(mockData);
+
+      const result = await service.getConstants();
+
+      expect(configStore.get).toHaveBeenCalledWith(
+        `projects/${expectedProjectId}/constants.json`,
+      );
+      expect(result).toBe(mockData);
+    });
+
+    it("should return null if configStore.get returns null", async () => {
+      vi.mocked(configStore.get).mockResolvedValue(null);
+
+      const result = await service.getConstants();
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("saveConstants", () => {
+    it("should call configStore.set with correct path and stringified data", async () => {
+      const mockConstants = { foo: "bar" };
+      vi.mocked(configStore.set).mockResolvedValue(undefined);
+
+      await service.saveConstants(mockConstants);
+
+      expect(configStore.set).toHaveBeenCalledWith(
+        `projects/${expectedProjectId}/constants.json`,
+        JSON.stringify(mockConstants, null, 2),
+      );
+    });
+  });
+
+  describe("isInitialized", () => {
+    it("should return true if constants exist", async () => {
+      vi.mocked(configStore.get).mockResolvedValue(JSON.stringify({}));
+
+      const result = await service.isInitialized();
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false if constants do not exist", async () => {
+      vi.mocked(configStore.get).mockResolvedValue(null);
+
+      const result = await service.isInitialized();
+
+      expect(result).toBe(false);
+    });
+  });
+});

package/tests/unit/session_file_service_test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  SessionFileService,
+  loadFileData,
+} from "../../src/session/session_file_service.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+vi.mock("node:fs/promises");
+vi.mock("../../src/config/app_dir.js", () => ({
+  APP_FILE_DIR: "/mock/app/dir",
+}));
+
+describe("SessionFileService", () => {
+  let service: SessionFileService;
+  const rootDir = "/mock/app/dir/sessions";
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    service = new SessionFileService();
+  });
+
+  describe("createSession", () => {
+    it("should create session directory and files", async () => {
+      const mockAgentName = "test-agent";
+      const mockEvents = [{ type: "test-event" } as any];
+
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      const session = await service.createSession(mockAgentName, mockEvents);
+
+      expect(session).toBeTruthy();
+      expect(session.id).toBeTruthy();
+      expect(session.agentName).toBe(mockAgentName);
+
+      const sessionDir = path.join(rootDir, session.id);
+      expect(fs.mkdir).toHaveBeenCalledWith(rootDir, { recursive: true });
+      expect(fs.mkdir).toHaveBeenCalledWith(sessionDir, { recursive: true });
+      expect(fs.writeFile).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("getSession", () => {
+    it("should return combined session data", async () => {
+      const sessionId = "123";
+      const mockSession = { id: sessionId, events: [] };
+      const mockMeta = { id: sessionId, title: "Test" };
+
+      vi.mocked(fs.readFile).mockImplementation(async (filePath: any) => {
+        if (filePath.includes("session.json"))
+          return JSON.stringify(mockSession);
+        if (filePath.includes("metadata.json")) return JSON.stringify(mockMeta);
+        throw new Error("File not found");
+      });
+
+      const session = await service.getSession(sessionId);
+      expect(session).toEqual({ id: sessionId, events: [], title: "Test" });
+    });
+
+    it("should throw error if session or meta is missing", async () => {
+      const sessionId = "123";
+      const error = new Error("File not found");
+      (error as any).code = "ENOENT";
+      vi.mocked(fs.readFile).mockRejectedValue(error);
+
+      await expect(service.getSession(sessionId)).rejects.toThrow(
+        `Session ${sessionId} not found`,
+      );
+    });
+  });
+
+  describe("listSessions", () => {
+    it("should return list of session metadata", async () => {
+      vi.mocked(fs.readdir).mockResolvedValue(["session1", "session2"] as any);
+
+      vi.mocked(fs.readFile).mockImplementation(async (filePath: any) => {
+        if (filePath.includes("session1"))
+          return JSON.stringify({ id: "session1", title: "Title 1" });
+        if (filePath.includes("session2"))
+          return JSON.stringify({ id: "session2", title: "Title 2" });
+        throw new Error("File not found");
+      });
+
+      const list = await service.listSessions();
+      expect(list.length).toBe(2);
+      expect(list[0].id).toBe("session1");
+      expect(list[1].id).toBe("session2");
+    });
+
+    it("should handle corrupt metadata gracefully", async () => {
+      vi.mocked(fs.readdir).mockResolvedValue(["session1", "session2"] as any);
+
+      vi.mocked(fs.readFile).mockImplementation(async (filePath: any) => {
+        if (filePath.includes("session1"))
+          return JSON.stringify({ id: "session1", title: "Title 1" });
+        if (filePath.includes("session2")) throw new Error("JSON parse error");
+        throw new Error("File not found");
+      });
+
+      const list = await service.listSessions();
+      expect(list.length).toBe(1);
+      expect(list[0].id).toBe("session1");
+    });
+  });
+
+  describe("updateSession", () => {
+    it("should update session title", async () => {
+      const sessionId = "123";
+      const mockMeta = { id: sessionId, title: "Old Title" };
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockMeta));
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await service.updateSession(sessionId, { title: "New Title" });
+
+      expect(fs.writeFile).toHaveBeenCalledTimes(1);
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string);
+      expect(writtenData.title).toBe("New Title");
+    });
+  });
+
+  describe("appendEvent", () => {
+    it("should append event to session", async () => {
+      const sessionId = "123";
+      const mockSession = { id: sessionId, events: [] };
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockSession));
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      const event = { type: "test" } as any;
+      await service.appendEvent(sessionId, event);
+
+      expect(fs.writeFile).toHaveBeenCalledTimes(1);
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string);
+      expect(writtenData.events.length).toBe(1);
+      expect(writtenData.events[0]).toEqual(event);
+    });
+  });
+
+  describe("loadFileData", () => {
+    it("should return undefined on ENOENT", async () => {
+      const error = new Error("File not found");
+      (error as any).code = "ENOENT";
+      vi.mocked(fs.readFile).mockRejectedValue(error);
+
+      const result = await loadFileData("/some/file");
+      expect(result).toBeUndefined();
+    });
+
+    it("should throw on other errors", async () => {
+      const error = new Error("Some other error");
+      vi.mocked(fs.readFile).mockRejectedValue(error);
+
+      await expect(loadFileData("/some/file")).rejects.toThrow(
+        "Some other error",
+      );
+    });
+  });
+});

package/tests/unit/tools/find_test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { FIND_TOOL } from "../../../src/tools/build_in/find.js";
+import * as fs from "node:fs/promises";
+
+vi.mock("node:fs/promises");
+
+describe("FindTool", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("should find files matching pattern", async () => {
+    const mockStats = { isDirectory: () => true };
+    vi.mocked(fs.stat).mockResolvedValue(mockStats as any);
+    vi.mocked(fs.readdir).mockResolvedValue([
+      { name: "file1.txt", isDirectory: () => false, isFile: () => true },
+      { name: "file2.js", isDirectory: () => false, isFile: () => true },
+    ] as any);
+
+    const result = await FIND_TOOL.execute({ pattern: "\\.txt$", path: "." });
+
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0]).toBe("file1.txt");
+  });
+
+  it("should throw error if path is outside project", async () => {
+    await expect(
+      FIND_TOOL.execute({ pattern: "test", path: "../outside" }),
+    ).rejects.toThrow(/Access denied/);
+  });
+
+  it("should throw error if path is not a directory", async () => {
+    const mockStats = { isDirectory: () => false };
+    vi.mocked(fs.stat).mockResolvedValue(mockStats as any);
+
+    await expect(
+      FIND_TOOL.execute({ pattern: "test", path: "file.txt" }),
+    ).rejects.toThrow(/is not a directory/);
+  });
+});

package/tests/unit/tools/grep_test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { GREP_TOOL } from "../../../src/tools/build_in/grep.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+vi.mock("node:fs/promises");
+
+describe("GrepTool", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("should find matches in a file", async () => {
+    const mockStats = { isFile: () => true, isDirectory: () => false };
+    vi.mocked(fs.stat).mockResolvedValue(mockStats as any);
+    vi.mocked(fs.readFile).mockResolvedValue("line1\nmatch this\nline3" as any);
+
+    const result = await GREP_TOOL.execute({ pattern: "match", path: "test.txt" });
+
+    expect(result.matches).toHaveLength(1);
+    expect(result.matches[0]).toEqual({
+      file: "test.txt",
+      line: 2,
+      content: "match this",
+    });
+  });
+
+  it("should throw error if path is outside project", async () => {
+    await expect(
+      GREP_TOOL.execute({ pattern: "test", path: "../outside.txt" }),
+    ).rejects.toThrow(/Access denied/);
+  });
+
+  it("should handle file read errors gracefully (ignore file)", async () => {
+    const mockStats = { isFile: () => true, isDirectory: () => false };
+    vi.mocked(fs.stat).mockResolvedValue(mockStats as any);
+    vi.mocked(fs.readFile).mockRejectedValue(new Error("Read error") as any);
+
+    const result = await GREP_TOOL.execute({ pattern: "test", path: "test.txt" });
+
+    expect(result.matches).toHaveLength(0);
+  });
+});

package/tests/unit/tools/list_dir_test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi } from "vitest";
+import { LIST_DIR_TOOL } from "../../../src/tools/build_in/list_dir.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+vi.mock("node:fs/promises");
+
+describe("ListDirTool", () => {
+  it("should list directory contents", async () => {
+    const mockFiles = ["file1.txt", "dir1"];
+    vi.mocked(fs.readdir).mockResolvedValue(mockFiles as any);
+
+    const result = await LIST_DIR_TOOL.execute({ path: "." });
+
+    expect(result).toEqual({ files: mockFiles });
+    expect(fs.readdir).toHaveBeenCalledWith(path.resolve("."));
+  });
+
+  it("should throw error if path is outside project", async () => {
+    await expect(LIST_DIR_TOOL.execute({ path: "../outside" })).rejects.toThrow(
+      /Access denied/,
+    );
+  });
+
+  it("should handle readdir errors", async () => {
+    vi.mocked(fs.readdir).mockRejectedValue(new Error("Read error") as any);
+
+    await expect(LIST_DIR_TOOL.execute({ path: "." })).rejects.toThrow(
+      /Failed to list directory/,
+    );
+  });
+});