@tyvm/knowhow 0.0.46 → 0.0.48

package/tests/test.spec.ts

@@ -1,9 +1,37 @@
+// Global mocks that need to be hoisted before any imports
+jest.mock("tree-sitter", () => {
+  return jest.fn().mockImplementation(() => ({
+    setLanguage: jest.fn(),
+    parse: jest.fn(() => ({ rootNode: { toString: () => "mock tree" } })),
+  }));
+});
+jest.mock("tree-sitter-typescript", () => ({ typescript: jest.fn() }));
+jest.mock("tree-sitter-javascript", () => ({ javascript: jest.fn() }));
+jest.mock("../src/plugins/tree-sitter/parser", () => ({
+  LanguageAgnosticParser: jest.fn(),
+}));
+jest.mock("../src/plugins/tree-sitter/editor", () => ({
+  TreeEditor: jest.fn(),
+}));
+jest.mock("../src/services/S3", () => ({
+  S3Service: jest.fn().mockImplementation(() => ({
+    uploadFile: jest.fn(),
+    downloadFile: jest.fn(),
+    uploadToPresignedUrl: jest.fn(),
+    downloadFromPresignedUrl: jest.fn(),
+  })),
+}));
+jest.mock("@aws-sdk/client-s3", () => ({
+  S3Client: jest.fn(),
+}));
 jest.mock("fs");
 jest.mock("../src/plugins/plugins");
+jest.mock("../src/utils");
+jest.mock("../src/agents/tools/lintFile");
+jest.mock("../src/index");
 
+// Import modules after mocking
 import * as fs from "fs";
-import { exec } from "child_process";
-
 import {
   embeddingSearch,
   readFile,
@@ -12,121 +40,138 @@ import {
   execCommand,
   writeFile,
 } from "../src/agents/tools";
-import { Plugins } from "../src/plugins/plugins";
+import { services } from "../src/services";
 import { patchFile } from "../src/agents/tools/patch";
+import { fileExists } from "../src/utils";
+import * as utils from "../src/utils";
+import { lintFile } from "../src/agents/tools/lintFile";
+import { embed } from "../src/index";
 
 const mockFs = jest.mocked(fs);
-
-test("searchFiles should call the embeddings plugin with the correct keyword", async () => {
-  const mocked = Plugins as jest.Mocked<typeof Plugins>;
-  const keyword = "test";
-  const expectedResult = JSON.stringify({ files: ["test1.js", "test2.js"] });
-
-  // Setting up the plugin to return the expected result
-  mocked.call.mockResolvedValue(expectedResult);
-
-  const result = await embeddingSearch(keyword);
-
-  // Verifying that the plugin was called with the correct keyword
-  expect(Plugins.call).toHaveBeenCalledWith("embeddings", keyword);
-  // Verifying that the function returns the expected result
-  expect(result).toBe(expectedResult);
-});
-
-test("readFile should return the content of a file", () => {
-  const filePath = "test.txt";
-  const fileContent = "Hello World";
-
-  // Mock readFile to return the fileContent
-  mockFs.readFileSync.mockReturnValue(fileContent);
-
-  const result = readFile(filePath);
-
-  // Verify readFile was called with the correct file path
-  expect(fs.readFileSync).toHaveBeenCalledWith(filePath, "utf8");
-  // Verify the result matches the fileContent
-  expect(result).toBe(JSON.stringify([[1, fileContent]]));
-});
-
-test("scanFile should return the contents of a specified range of lines from a file", () => {
-  const filePath = "test.txt";
-  const fileContentLines = ["Line1", "Line2", "Line3", "Line4", "Line5"];
-  const startLine = 3;
-  const endLine = 3;
-
-  // Mock fs.readFileSync to return joined fileContentLines
-  mockFs.readFileSync.mockReturnValue(fileContentLines.join("\n"));
-
-  const result = scanFile(filePath, startLine, endLine);
-
-  // Verify fs.readFileSync was called with the correct file path
-  expect(fs.readFileSync).toHaveBeenCalledWith(filePath, "utf8");
-  // Verify that the correct range of lines is returned
-  expect(result).toBe(
-    JSON.stringify([
-      [1, "Line1"],
-      [2, "Line2"],
-      [3, "Line3"],
-      [4, "Line4"],
-      [5, "Line5"],
-    ])
-  );
-});
-
-test("writeFile should write the full contents to a file", () => {
-  const filePath = "testWrite.txt";
-  const contentToWrite = "Writing to file";
-
-  // Mock fs.writeFileSync to not actually write to disk
-  mockFs.writeFileSync.mockImplementation(() => {});
-
-  const result = writeFile(filePath, contentToWrite);
-
-  // Verify fs.writeFileSync was called with the correct arguments
-  expect(fs.writeFileSync).toHaveBeenCalledWith(filePath, contentToWrite);
-  // Verify the function returns a success message
-  expect(result).toBe(`File ${filePath} written`);
-});
-
-test("applyPatchFile should apply a patch to a file", async () => {
-  const filePath = "testPatch.txt";
-  const originalContent = "Original content\n";
-  const patchedContent = "Patched content\n";
-  const patch = "@@ -1,1 +1,1 @@\n-Original content\n+Patched content\n";
-
-  // Mock fs.readFileSync to return the originalContent
-  mockFs.readFileSync.mockReturnValue(originalContent);
-  // Mock fs.writeFileSync to not actually write to disk
-  mockFs.writeFileSync.mockImplementation(() => {});
-
-  const result = await patchFile(filePath, patch);
-
-  // Verify fs.readFileSync was called with the correct file path
-  expect(fs.readFileSync).toHaveBeenCalledWith(filePath, "utf8");
-  // Verify fs.writeFileSync was called with the corrected content
-  expect(fs.writeFileSync).toHaveBeenCalledWith(filePath, patchedContent);
-  // Verify the function returns a success message
-  expect(result.startsWith("Patch Applied")).toBe(true);
-});
-
-test("execCommand should execute a system command and return its output", async () => {
-  const command = 'echo "Hello World"';
-  const expectedOutput = "Hello World\n";
-
-  // Use the execCommand and expect it to return the correct result
-  const result = await execCommand(command);
-  expect(result).toEqual(expectedOutput);
-});
-
-test("execCommand should return an error message if the command fails", async () => {
-  const command = "exit 1";
-  const expectedOutput = "Command failed: exit 1\n";
-
-  // Use the execCommand and expect it to return the correct result
-  const result = await execCommand(command);
-  expect(result).toEqual(expectedOutput);
-});
-
-test("it should run a test", () => {
-  expect(true).toEqual(true);
-});
+const mockServices = jest.mocked(services);
+const mockUtils = jest.mocked(utils);
+const mockLintFile = jest.mocked(lintFile);
+const mockEmbed = jest.mocked(embed);
+
+describe("Agent Tools Tests", () => {
+  test("searchFiles should call the embeddings plugin with the correct keyword", async () => {
+    const { Plugins } = mockServices();
+    const expectedResult = JSON.stringify({ files: ["test1.js", "test2.js"] });
+    const mocked = Plugins as jest.Mocked<typeof Plugins>;
+    const keyword = "test";
+
+    // Setting up the plugin to return the expected result
+    mocked.call.mockResolvedValue(expectedResult);
+
+    const result = await embeddingSearch(keyword);
+
+    // Verifying that the plugin was called with the correct keyword
+    expect(Plugins.call).toHaveBeenCalledWith("embeddings", keyword);
+    // Verifying that the function returns the expected result
+    expect(result).toBe(expectedResult);
+  });
+
+  test("readFile should return the content of a file", async () => {
+    const filePath = "test.txt";
+    const fileContent = "Hello World";
+
+    mockUtils.fileExists.mockResolvedValue(true);
+
+    // Mock readFile to return the fileContent
+    mockFs.readFileSync.mockReturnValue(fileContent);
+
+    const result = await readFile(filePath);
+
+    // Verify readFile was called with the correct file path
+    expect(mockFs.readFileSync).toHaveBeenCalledWith(filePath, "utf8");
+    // Verify the result is a patch (since readFile now returns patch format)
+    expect(result).toContain(fileContent);
+  });
+
+  test("scanFile should return the contents of a specified range of lines from a file", () => {
+    const filePath = "test.txt";
+    const fileContentLines = ["Line1", "Line2", "Line3", "Line4", "Line5"];
+    const startLine = 3;
+    const endLine = 3;
+
+    // Mock fs.readFileSync to return joined fileContentLines
+    mockFs.readFileSync.mockReturnValue(fileContentLines.join("\n"));
+
+    const result = scanFile(filePath, startLine, endLine);
+
+    // Verify fs.readFileSync was called with the correct file path
+    expect(mockFs.readFileSync).toHaveBeenCalledWith(filePath, "utf8");
+    // Verify that the correct range of lines is returned
+    expect(result).toBe(
+      JSON.stringify([
+        [1, "Line1"],
+        [2, "Line2"],
+        [3, "Line3"],
+        [4, "Line4"],
+        [5, "Line5"],
+      ])
+    );
+  });
+
+  test("writeFile should write the full contents to a file", () => {
+    const filePath = "testWrite.txt";
+    const contentToWrite = "Writing to file";
+
+    // Mock fs.writeFileSync to not actually write to disk
+    mockFs.writeFileSync.mockImplementation(() => {});
+
+    const result = writeFile(filePath, contentToWrite);
+
+    // Verify fs.writeFileSync was called with the correct arguments
+    expect(mockFs.writeFileSync).toHaveBeenCalledWith(filePath, contentToWrite);
+    // Verify the function returns a success message
+    expect(result).toBe(`File ${filePath} written`);
+  });
+
+  test("applyPatchFile should apply a patch to a file", async () => {
+    const filePath = "testPatch.txt";
+    const originalContent = "Original content\n";
+    const patch = "@@ -1,1 +1,1 @@\n-Original content\n+Patched content\n";
+
+    // Mock fs.existsSync to return true (file exists)
+    mockFs.existsSync.mockReturnValue(true);
+
+    // Mock the utilities that patchFile uses
+    mockUtils.readFile.mockResolvedValue(originalContent);
+    mockUtils.writeFile.mockResolvedValue(undefined);
+    mockUtils.fileExists.mockResolvedValue(true);
+    mockUtils.mkdir.mockResolvedValue(undefined);
+    mockUtils.splitByNewLines.mockImplementation((text: string) =>
+      text.split(/\r?\n/)
+    );
+    mockLintFile.mockResolvedValue("");
+    mockEmbed.mockResolvedValue(undefined);
+
+    const result = await patchFile(filePath, patch);
+
+    // Verify the function returns a success message
+    expect(result).toContain("Patch applied successfully");
+  }, 60000); // Increase timeout to 60 seconds
+
+  test("execCommand should execute a system command and return its output", async () => {
+    const command = 'echo "Hello World"';
+    const expectedOutput = '$ echo "Hello World"\nHello World\n';
+
+    // Use the execCommand and expect it to return the correct result
+    const result = await execCommand(command);
+    expect(result).toEqual(expectedOutput);
+  });
+
+  test("execCommand should return an error message if the command fails", async () => {
+    const command = "exit 1";
+    const expectedOutput = "$ exit 1\nCommand failed: exit 1";
+
+    // Use the execCommand and expect it to return the correct result
+    const result = await execCommand(command);
+    expect(result.trim()).toEqual(expectedOutput);
+  });
+
+  test("it should run a test", () => {
+    expect(true).toEqual(true);
+  });
+});

package/tests/tree-sitter/editor.test.ts

@@ -0,0 +1,113 @@
+import { join } from "path";
+import { TreeEditor } from "../../src/plugins/tree-sitter/editor";
+import { LanguageAgnosticParser } from "../../src/plugins/tree-sitter/parser";
+
+describe("TreeEditor", () => {
+  let parser: LanguageAgnosticParser;
+  const sampleCode = `class Calculator {
+  add(a, b) {
+    return a + b;
+  }
+
+  multiply(a, b) {
+    return a * b;
+  }
+}`;
+
+  beforeEach(() => {
+    parser = LanguageAgnosticParser.createJavaScriptParser();
+  });
+
+  test("should create TreeEditor from string", () => {
+    const editor = new TreeEditor(parser, sampleCode);
+    expect(editor).toBeDefined();
+    expect(editor.getCurrentText()).toBe(sampleCode);
+  });
+
+  test("should create TreeEditor from file", () => {
+    const beforeFilePath = join(__dirname, "sample-before.ts");
+    const editor = TreeEditor.fromFile(parser, beforeFilePath);
+    expect(editor).toBeDefined();
+    expect(editor.getCurrentText().length).toBeGreaterThan(0);
+  });
+
+  test("should add lines to code", () => {
+    const editor = new TreeEditor(parser, sampleCode);
+    const newEditor = editor.addLines(
+      "",
+      "  subtract(a, b) {\n    return a - b;\n  }",
+      5
+    );
+
+    const newText = newEditor.getCurrentText();
+    expect(newText).toContain("subtract");
+    expect(newText.split("\n").length).toBeGreaterThan(
+      sampleCode.split("\n").length
+    );
+
+    console.log("After adding lines:\n", newText);
+  });
+
+  test("should remove lines from code", () => {
+    const editor = new TreeEditor(parser, sampleCode);
+    const newEditor = editor.removeLines(1, 3); // Remove add method
+
+    const newText = newEditor.getCurrentText();
+    expect(newText).not.toContain("add(a, b)");
+    expect(newText.split("\n").length).toBeLessThan(
+      sampleCode.split("\n").length
+    );
+
+    console.log("After removing lines:\n", newText);
+  });
+
+  test("should update a specific line", () => {
+    const editor = new TreeEditor(parser, sampleCode);
+    const newEditor = editor.updateLine(0, "class AdvancedCalculator {");
+
+    const newText = newEditor.getCurrentText();
+    expect(newText).toContain("AdvancedCalculator");
+    expect(newText).not.toContain("class Calculator {");
+
+    console.log("After updating line:\n", newText);
+  });
+
+  test("should generate diff between original and modified", () => {
+    const editor = new TreeEditor(parser, sampleCode);
+    const newEditor = editor
+      .updateLine(0, "class AdvancedCalculator {")
+      .addLines("", "  subtract(a, b) {\n    return a - b;\n  }", 5);
+
+    const diff = newEditor.generateDiff();
+
+    expect(diff).toContain("---");
+    expect(diff).toContain("+++");
+    expect(diff).toContain("-class Calculator {");
+    expect(diff).toContain("+class AdvancedCalculator {");
+    expect(diff).toContain("+  subtract(a, b) {");
+    expect(diff).toContain("+    return a - b;");
+
+    console.log("Generated diff:\n", diff);
+  });
+
+  test("should handle complex editing workflow", () => {
+    const beforeFilePath = join(__dirname, "sample-before.ts");
+    const editor = TreeEditor.fromFile(parser, beforeFilePath);
+
+    // Make multiple edits
+    const modifiedEditor = editor
+      .addLines("", "  private operationCount: number = 0;", 2)
+      .updateLine(5, "  // Enhanced add method")
+      .addLines("", "    this.operationCount++;", 9);
+
+    const diff = modifiedEditor.generateDiff();
+    const newText = modifiedEditor.getCurrentText();
+
+    expect(newText).toContain("operationCount");
+    expect(newText).toContain("Enhanced add method");
+    expect(diff).toContain("operationCount");
+
+    console.log("Complex edit result:\n", newText);
+    console.log("Complex edit diff:\n", diff);
+  });
+});