@kalenkevich/agent_007 0.0.1

package/tests/unit/tools/view_file_test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi } from "vitest";
+import { VIEW_FILE_TOOL } from "../../../src/tools/build_in/view_file.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+vi.mock("node:fs/promises");
+
+describe("ViewFileTool", () => {
+  it("should read file content", async () => {
+    const mockContent = "hello world";
+    vi.mocked(fs.readFile).mockResolvedValue(mockContent as any);
+
+    const result = await VIEW_FILE_TOOL.execute({ path: "test.txt" });
+
+    expect(result).toEqual({ content: mockContent });
+    expect(fs.readFile).toHaveBeenCalledWith(path.resolve("test.txt"), "utf-8");
+  });
+
+  it("should throw error if path is outside project", async () => {
+    await expect(
+      VIEW_FILE_TOOL.execute({ path: "../outside.txt" }),
+    ).rejects.toThrow(/Access denied/);
+  });
+
+  it("should handle readFile errors", async () => {
+    vi.mocked(fs.readFile).mockRejectedValue(new Error("Read error") as any);
+
+    await expect(VIEW_FILE_TOOL.execute({ path: "test.txt" })).rejects.toThrow(
+      /Failed to read file/,
+    );
+  });
+});

package/tests/unit/tools/write_file_test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi } from "vitest";
+import { WRITE_FILE_TOOL } from "../../../src/tools/build_in/write_file.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+vi.mock("node:fs/promises");
+
+describe("WriteFileTool", () => {
+  it("should write file content", async () => {
+    vi.mocked(fs.writeFile).mockResolvedValue(undefined as any);
+    vi.mocked(fs.mkdir).mockResolvedValue(undefined as any);
+
+    const result = await WRITE_FILE_TOOL.execute({
+      path: "test.txt",
+      content: "hello",
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(fs.mkdir).toHaveBeenCalledWith(
+      path.dirname(path.resolve("test.txt")),
+      { recursive: true },
+    );
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      path.resolve("test.txt"),
+      "hello",
+      "utf-8",
+    );
+  });
+
+  it("should throw error if path is outside project", async () => {
+    await expect(
+      WRITE_FILE_TOOL.execute({ path: "../outside.txt", content: "hello" }),
+    ).rejects.toThrow(/Access denied/);
+  });
+
+  it("should handle writeFile errors", async () => {
+    vi.mocked(fs.mkdir).mockResolvedValue(undefined as any);
+    vi.mocked(fs.writeFile).mockRejectedValue(new Error("Write error") as any);
+
+    await expect(
+      WRITE_FILE_TOOL.execute({ path: "test.txt", content: "hello" }),
+    ).rejects.toThrow(/Failed to write file/);
+  });
+});

package/tests/unit/user_input_test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "vitest";
+import {
+  isUserCommand,
+  toContentParts,
+  UserCommandType,
+  UserInput,
+} from "../../src/user_input";
+import { Content, ContentPart } from "../../src/content";
+
+describe("user_input utils", () => {
+  describe("isUserCommand", () => {
+    it("should return true for valid command", () => {
+      const input: UserInput = {
+        command: UserCommandType.SET_MODEL,
+        modelName: "gemini-1.5-pro",
+      };
+      expect(isUserCommand(input)).toBe(true);
+    });
+
+    it("should return false for non-command", () => {
+      expect(isUserCommand("string input")).toBe(false);
+      expect(
+        isUserCommand({ type: "text", text: "part" } as unknown as UserInput),
+      ).toBe(false);
+    });
+  });
+
+  describe("toContentParts", () => {
+    it("should convert string to text part", () => {
+      const result = toContentParts("hello");
+      expect(result).toEqual([{ type: "text", text: "hello" }]);
+    });
+
+    it("should return array as is", () => {
+      const parts: ContentPart[] = [{ type: "text", text: "hello" }];
+      const result = toContentParts(parts);
+      expect(result).toBe(parts);
+    });
+
+    it("should return parts from Content object", () => {
+      const content: Content = {
+        role: "user",
+        parts: [{ type: "text", text: "hello" }],
+      };
+      const result = toContentParts(content);
+      expect(result).toBe(content.parts);
+    });
+
+    it("should wrap single ContentPart in array", () => {
+      const part: ContentPart = { type: "text", text: "hello" };
+      const result = toContentParts(part as unknown as ContentPart);
+      expect(result).toEqual([part]);
+    });
+  });
+});

package/tests/unit/util_llm_test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi } from "vitest";
+import { UtilLlm } from "../../src/model/util_llm.js";
+import {
+  AgentEventType,
+  type AgentEvent,
+} from "../../src/agent/agent_event.js";
+
+describe("UtilLlm", () => {
+  it("should generate a session title", async () => {
+    const mockModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield {
+          content: {
+            role: "agent",
+            parts: [{ type: "text", text: "Generated Title" }],
+          },
+        };
+      }),
+    };
+
+    const utilLlm = new UtilLlm(mockModel as any);
+
+    const events: AgentEvent[] = [
+      {
+        id: "1",
+        streamId: "s1",
+        timestamp: "...",
+        role: "user",
+        type: AgentEventType.MESSAGE,
+        parts: [{ type: "text", text: "Hello" }],
+      },
+      {
+        id: "2",
+        streamId: "s1",
+        timestamp: "...",
+        role: "agent",
+        type: AgentEventType.MESSAGE,
+        parts: [{ type: "text", text: "Hi there" }],
+      },
+    ];
+
+    const title = await utilLlm.generateSessionTitle(events);
+
+    expect(title).toBe("Generated Title");
+    expect(mockModel.run).toHaveBeenCalled();
+
+    const callArgs = mockModel.run.mock.calls[0][0];
+    expect(callArgs.contents[0].parts[0].text).toContain("[User]: Hello");
+    expect(callArgs.contents[0].parts[0].text).toContain("[Agent]: Hi there");
+  });
+
+  it("should return default title if no conversation text", async () => {
+    const mockModel = {
+      run: vi.fn(),
+    };
+    const utilLlm = new UtilLlm(mockModel as any);
+    const title = await utilLlm.generateSessionTitle([]);
+    expect(title).toBe("New Session");
+    expect(mockModel.run).not.toHaveBeenCalled();
+  });
+});

package/todo.md

@@ -0,0 +1,29 @@
+To do:
+
+- [x] Basic Agent loop
+- [x] User command execution
+- [x] Tool execution
+- [x] Tool call approval
+- [x] Sessions
+- [x] Chat history
+- [x] Dynamic model support
+- [/] Planning agent
+  - [x] Ask user for approval
+  - [ ] Plan execution
+- [x] Define project constants by scaning the codebase:
+  - language, framework, package managers, build tools
+  - project structure
+  - coding style, rules and conventions
+- [ ] Skills
+- [ ] Other models support (OpenAI, Anthropic, etc)
+- [ ] TUI with ink
+- [ ] Web/Native UI?
+- [ ] Personality (aggresive, polite, casual)
+- [ ] Web search
+- [ ] Code execution
+- [x] Context compaction
+- [ ] Memory facts
+- [ ] Index project for Llm (LllWiki)
+- [ ] Conenct to Telegram
+- [ ] Voice support
+- [ ] i18n (en, russian)

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "pretty": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "ES2020",
+    "module": "nodenext",
+    "lib": ["ES2022", "DOM"],
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "strictBindCallApply": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true,
+    "allowSyntheticDefaultImports": true,
+    "strictPropertyInitialization": true,
+    "verbatimModuleSyntax": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,33 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    projects: [
+      {
+        test: {
+          name: "unit",
+          environment: "node",
+          include: ["tests/unit/**/*_test.ts"],
+        },
+      },
+      {
+        test: {
+          name: "integration",
+          environment: "node",
+          include: ["tests/integration/**/*_test.ts"],
+        },
+      },
+      {
+        test: {
+          name: "e2e",
+          environment: "node",
+          include: ["tests/e2e/**/*_test.ts"],
+        },
+      },
+    ],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json"],
+    },
+  },
+});