@tyvm/knowhow 0.0.1

package/tests/patching/imports.test.ts

@@ -0,0 +1,43 @@
+import * as fs from "fs";
+import { parseHunks, fixPatch } from "../../src/agents/tools/patch";
+import { applyPatch } from "diff";
+
+describe("fixPatch", () => {
+  it("should fix patch", async () => {
+    const patch = fs.readFileSync(__dirname + "/imports.patch.txt").toString();
+    const originalContent = fs
+      .readFileSync(__dirname + "/imports.txt")
+      .toString();
+    const hunks = parseHunks(patch);
+
+    console.log(hunks);
+    expect(hunks.length).toBe(1);
+
+    expect(hunks[0].newStartLine).toBe(6);
+    expect(hunks[0].originalStartLine).toBe(5);
+
+    const fixedPatch = await fixPatch(originalContent, patch);
+    console.log(fixedPatch);
+
+    const patched = applyPatch(originalContent, fixedPatch);
+    console.log("PATCH OUTPUT");
+    console.log(patched);
+  });
+
+  it("should patch interface.text", async () => {
+    const patch = fs
+      .readFileSync(__dirname + "/interface.patch.txt")
+      .toString();
+    const originalContent = fs
+      .readFileSync(__dirname + "/interface.txt")
+      .toString();
+
+    const hunks = parseHunks(patch);
+    const fixedPatch = await fixPatch(originalContent, patch);
+    console.log(fixedPatch);
+
+    const patched = applyPatch(originalContent, fixedPatch);
+    console.log("PATCH OUTPUT");
+    console.log(patched);
+  });
+});

package/tests/patching/imports.txt

@@ -0,0 +1,11 @@
+import { gql, useMutation } from '@apollo/client';
+import React from 'react';
+import { Col, Row } from 'react-bootstrap';
+
+import InformationTooltip from '~/components/InformationTooltip';
+import Link from '~/components/Link';
+import { NameValueRow, NameValueRowWithBottomBorder } from '~/components/NameValueRow';
+import { BOTTOM_BORDER_CONTAINER_STYLE } from '~/components/NameValueRow/NameValueRowWithBottomBorder';
+import { NotesPopoverWrapper } from '~/components/Notes';
+import { TokenAgreementRowAssetUnion, UpdateTokenAgreement, UpdateTokenAgreementVariables } from '~/generated/schema';
+

package/tests/patching/interface.patch.txt

@@ -0,0 +1,15 @@
+--- ./tests/patching/interface.txt
++++ ./tests/patching/interface.txt
+@@ -3,8 +3,14 @@
+ import { Message } from "../clients/types";
+
+ export interface IAgent {
++  getModel(): string;
++  setModel(value: string): void;
++  getProvider(): string;
++  setProvider(value: string): void;
+   name: string;
+   description: string;
+-  call: (userInput: string, messages?: Message[]) => Promise<string>;
++  call: (userInput: string, messages?: Message[]) => Promise<string>;
+ }

package/tests/patching/interface.txt

@@ -0,0 +1,7 @@
+import { Message } from "../clients/types";
+
+export interface IAgent {
+  name: string;
+  description: string;
+  call: (userInput: string, messages?: Message[]) => Promise<string>;
+}

package/tests/test.spec.ts

@@ -0,0 +1,132 @@
+jest.mock("fs");
+jest.mock("../src/plugins/plugins");
+
+import * as fs from "fs";
+import { exec } from "child_process";
+
+import {
+  embeddingSearch,
+  readFile,
+  scanFile,
+  modifyFile,
+  execCommand,
+  writeFile,
+} from "../src/agents/tools";
+import { Plugins } from "../src/plugins/plugins";
+import { patchFile } from "../src/agents/tools/patch";
+
+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);
+});

package/ts_build/src/agents/base/base.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { GenericClient, Message, Tool, ToolCall } from "../../clients/types";
+import { IAgent } from "../interface";
+import { ToolsService } from "../../services/Tools";
+import { EventService } from "../../services/EventService";
+import { Clients } from "../../clients";
+export { Message, Tool, ToolCall };
+export interface ModelPreference {
+    model: string;
+    provider: keyof typeof Clients.clients;
+}
+export declare abstract class BaseAgent implements IAgent {
+    tools: ToolsService;
+    events: EventService;
+    abstract name: string;
+    abstract description: string;
+    private status;
+    private lastHealthCheckTime;
+    protected provider: string;
+    protected modelName: string;
+    protected client: null | GenericClient;
+    protected modelPreferences: ModelPreference[];
+    protected currentModelPreferenceIndex: number;
+    protected easyFinalAnswer: boolean;
+    protected requiredToolNames: string[];
+    protected totalCostUsd: number;
+    protected currentThread: number;
+    protected threads: Message[][];
+    protected pendingUserMessages: Message[];
+    protected taskBreakdown: string;
+    protected summaries: string[];
+    agentEvents: EventEmitter<[never]>;
+    eventTypes: {
+        newThread: string;
+        threadUpdate: string;
+        costUpdate: string;
+        toolUsed: string;
+        done: string;
+        pause: string;
+        kill: string;
+        unpause: string;
+    };
+    disabledTools: any[];
+    constructor(tools?: ToolsService, events?: EventService);
+    newTask(): void;
+    register(): void;
+    setModelPreferences(value: ModelPreference[]): void;
+    updatePreferences(value: ModelPreference): void;
+    nextModel(): void;
+    getModel(): string;
+    setModel(value: string): void;
+    getProvider(): string;
+    setProvider(value: keyof typeof Clients.clients): void;
+    getClient(): GenericClient;
+    setClient(client: GenericClient): void;
+    setEasyFinalAnswer(value: boolean): void;
+    getEnabledTools(): Tool[];
+    getEnabledToolNames(): string[];
+    disableTool(toolName: string): void;
+    isToolEnabled(toolName: string): boolean;
+    enableTool(toolName: string): void;
+    adjustTotalCostUsd(cost: number): void;
+    getTotalCostUsd(): number;
+    startNewThread(messages: Message[]): void;
+    updateCurrentThread(messages: Message[]): void;
+    getThreads(): Message[][];
+    getSummaries(): string[];
+    abstract getInitialMessages(userInput: string): Promise<Message[]>;
+    processToolMessages(toolCall: ToolCall): Promise<any[]>;
+    logMessages(messages: Message[]): void;
+    formatInputContent(userInput: string): string;
+    formatAiResponse(response: string): string;
+    formatInputMessages(messages: Message[]): Message[];
+    formatOutputMessages(messages: Message[]): Message[];
+    healthCheck(): Promise<boolean>;
+    selectHealthyModel(): Promise<void>;
+    setNotHealthy(): void;
+    pause(): void;
+    unpause(): void;
+    unpaused(): Promise<unknown>;
+    kill(): Promise<void>;
+    call(userInput: string, _messages?: Message[]): any;
+    addPendingUserMessage(message: Message): void;
+    getMessagesLength(messages: Message[]): number;
+    getTaskBreakdown(messages: Message[]): Promise<string>;
+    compressMessages(messages: Message[], startIndex: number, endIndex: number): Promise<Message[]>;
+}