@tyvm/knowhow 0.0.1

package/src/types.ts

@@ -0,0 +1,225 @@
+import { AssistantTool } from "openai/resources/beta";
+import { WebSocket } from "ws";
+
+export type Hashes = {
+  [file: string]: {
+    [promptHash: string]: string;
+
+    promptHash: string;
+    fileHash: string;
+  };
+};
+
+export type GenerationSource = {
+  model?: string;
+  agent?: string;
+  input: string;
+  output: string;
+  prompt: string;
+  kind?: string;
+  outputExt?: string;
+  outputName?: string;
+};
+
+export type EmbedSource = {
+  input: string;
+  output: string;
+  prompt?: string;
+  kind?: string;
+  uploadMode?: boolean;
+  remote?: string;
+  remoteType?: string;
+  remoteId?: string;
+  chunkSize?: number;
+  minLength?: number;
+};
+
+export type Config = {
+  openaiBaseUrl?: string;
+  promptsDir: string;
+  lintCommands?: { [fileExtension: string]: string };
+
+  micCommand?: string;
+  defaultMic?: string;
+
+  sources: GenerationSource[];
+  embedSources: EmbedSource[];
+  embeddingModel: string;
+
+  plugins: string[];
+  modules: string[];
+
+  agents: Assistant[];
+  mcps: McpConfig[];
+  modelProviders: ModelProvider[];
+
+  worker?: {
+    allowedTools?: string[];
+  };
+};
+
+export type Assistant = {
+  name?: string;
+  description?: string;
+  instructions: string;
+  model?: string;
+  provider?: keyof typeof Providers;
+};
+
+export type McpConfig = {
+  name: string;
+  command?: string;
+  url?: string;
+  args?: string[];
+  env?: { [key: string]: string };
+  params?: Partial<{ socket: WebSocket }>;
+};
+
+export type ModelProvider = {
+  url: string;
+  provider: string;
+  headers?: { [key: string]: string };
+  jwtFile?: string;
+};
+
+export type AssistantConfig = {
+  files: { [filepath: string]: string };
+};
+
+export interface Embeddable<T = any> {
+  id: string;
+  text: string;
+  vector: number[];
+  metadata: T;
+}
+
+export type MinimalEmbedding<T = any> = Pick<
+  Embeddable<T>,
+  "id" | "text" | "metadata"
+>;
+
+export interface EmbeddingBase<T = any> extends Embeddable<T> {
+  similarity?: number;
+}
+
+export type GptQuestionEmbedding = any & EmbeddingBase;
+
+export type DatasourceType = "file" | "url" | "text";
+
+export interface IDatasource {
+  kind: string;
+  data: string[];
+}
+
+export type Language = {
+  [term: string]: {
+    sources: IDatasource[];
+    context?: string;
+  };
+};
+
+export type ChatInteraction = {
+  input: string;
+  output: string;
+  summaries: string[];
+  lastThread: string[];
+};
+
+export const Models = {
+  anthropic: {
+    Opus4: "claude-opus-4-20250514",
+    Sonnet4: "claude-sonnet-4-20250514",
+    Sonnet3_7: "claude-3-7-sonnet-20250219",
+    Sonnet3_5: "claude-3-5-sonnet-20241022",
+    Haiku3_5: "claude-3-5-haiku-20241022",
+    Opus3: "claude-3-opus-20240229",
+    Haiku3: "claude-3-haiku-20240307",
+  },
+  xai: {
+    Grok3Beta: "grok-3-beta",
+    Grok3MiniBeta: "grok-3-mini-beta",
+    Grok3FastBeta: "grok-3-fast-beta",
+    Grok3MiniFastBeta: "grok-3-mini-fast-beta",
+    Grok21212: "grok-2-1212",
+    Grok2Vision1212: "grok-2-vision-1212",
+  },
+  openai: {
+    GPT_41: "gpt-4.1-2025-04-14",
+    GPT_41_Mini: "gpt-4.1-mini-2025-04-14",
+    GPT_41_Nano: "gpt-4.1-nano-2025-04-14",
+    GPT_45: "gpt-4.5-preview-2025-02-27",
+    GPT_4o: "gpt-4o-2024-08-06",
+    GPT_4o_Audio: "gpt-4o-audio-preview-2024-12-17",
+    GPT_4o_Realtime: "gpt-4o-realtime-preview-2024-12-17",
+    GPT_4o_Mini: "gpt-4o-mini-2024-07-18",
+    GPT_4o_Mini_Audio: "gpt-4o-mini-audio-preview-2024-12-17",
+    GPT_4o_Mini_Realtime: "gpt-4o-mini-realtime-preview-2024-12-17",
+    o1: "o1-2024-12-17",
+    o1_Pro: "o1-pro-2025-03-19",
+    o3: "o3-2025-04-16",
+    o4_Mini: "o4-mini-2025-04-16",
+    o3_Mini: "o3-mini-2025-01-31",
+    o1_Mini: "o1-mini-2024-09-12",
+    GPT_4o_Mini_Search: "gpt-4o-mini-search-preview-2025-03-11",
+    GPT_4o_Search: "gpt-4o-search-preview-2025-03-11",
+    Computer_Use: "computer-use-preview-2025-03-11",
+    Codex_Mini: "codex-mini-latest",
+    EmbeddingAda2: "text-embedding-ada-002",
+    EmbeddingLarge3: "text-embedding-3-large",
+    EmbeddingSmall3: "text-embedding-3-small",
+  },
+  google: {
+    Gemini_25_Flash_Preview: "gemini-2.5-flash-preview-05-20",
+    Gemini_25_Pro_Preview: "gemini-2.5-pro-preview-05-06",
+    Gemini_20_Flash: "gemini-2.0-flash",
+    Gemini_20_Flash_Preview_Image_Generation:
+      "gemini-2.0-flash-preview-image-generation",
+    Gemini_20_Flash_Lite: "gemini-2.0-flash-lite",
+    Gemini_15_Flash: "gemini-1.5-flash",
+    Gemini_15_Flash_8B: "gemini-1.5-flash-8b",
+    Gemini_15_Pro: "gemini-1.5-pro",
+    Gemini_Embedding: "gemini-embedding-exp",
+    Imagen_3: "imagen-3.0-generate-002",
+    Veo_2: "veo-2.0-generate-001",
+    Gemini_20_Flash_Live: "gemini-2.0-flash-live-001",
+  },
+};
+
+export const Providers = Object.keys(Models).reduce((obj, key) => {
+  obj[key] = key;
+  return obj;
+}, {}) as { [key in keyof typeof Models]: keyof typeof Models };
+
+export const OpenAiReasoningModels = [
+  Models.openai.o1,
+  Models.openai.o1_Mini,
+  Models.openai.o3_Mini,
+  Models.openai.o3,
+  Models.openai.o4_Mini,
+];
+
+export const OpenAiEmbeddingModels = [
+  Models.openai.EmbeddingAda2,
+  Models.openai.EmbeddingLarge3,
+  Models.openai.EmbeddingSmall3,
+];
+export const OpenAiResponseOnlyModels = [Models.openai.Codex_Mini];
+
+export const GoogleReasoningModels = [
+  Models.google.Gemini_25_Flash_Preview,
+  Models.google.Gemini_25_Pro_Preview,
+  Models.google.Gemini_20_Flash,
+  Models.google.Gemini_20_Flash_Lite,
+  Models.google.Gemini_15_Flash,
+  Models.google.Gemini_15_Flash_8B,
+  Models.google.Gemini_15_Pro,
+];
+
+export const GoogleImageModels = [
+  Models.google.Gemini_20_Flash_Preview_Image_Generation,
+  Models.google.Imagen_3,
+];
+
+export const GoogleVideoModels = [Models.google.Veo_2];
+
+export const GoogleEmbeddingModels = [Models.google.Gemini_Embedding];

package/src/utils/index.ts

@@ -0,0 +1,108 @@
+import gitignoreToGlob from "gitignore-to-glob";
+import { promisify } from "util";
+import * as util from "util";
+import { exec } from "child_process";
+import * as fs from "fs";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+
+marked.use(markedTerminal());
+
+export const fileExists = promisify(fs.exists);
+export const readFile = promisify(fs.readFile);
+export const writeFile = promisify(fs.writeFile);
+export const mkdir = promisify(fs.mkdir);
+export const execAsync = util.promisify(exec);
+export const fileStat = promisify(fs.stat);
+export const wait = promisify(setTimeout);
+
+export const askHistory = [];
+
+export const ask = async (
+  question: string,
+  options: string[] = [],
+  history = []
+) => {
+  const fullHistory = [...askHistory, ...history];
+  const readline = require("readline").createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    history: fullHistory,
+    completer: (line) => {
+      const hits = options.filter((c) => c?.startsWith(line));
+      return [hits.length ? hits : options, line];
+    },
+    terminal: true,
+  });
+
+  const _ask = util.promisify(readline.question).bind(readline);
+  const answer = await _ask(question);
+  readline.close();
+
+  return answer;
+};
+
+export const Marked = marked;
+
+export function dotp(x, y) {
+  function dotp_sum(a, b) {
+    return a + b;
+  }
+  function dotp_times(a, i) {
+    return x[i] * y[i];
+  }
+  return x.map(dotp_times).reduce(dotp_sum, 0);
+}
+
+export function cosineSimilarity(A, B) {
+  const similarity =
+    dotp(A, B) / (Math.sqrt(dotp(A, A)) * Math.sqrt(dotp(B, B)));
+  return similarity;
+}
+
+const NEWLINE_REPLACE = "<ESC_NEWLINE>";
+export function replaceEscapedNewLines(str: string): string {
+  // const replacedStr = str.replace(/\\n/g, NEWLINE_REPLACE);
+  return str;
+}
+
+export function restoreEscapedNewLines(str: string): string {
+  const escaped = [NEWLINE_REPLACE, "<ESCAPE_NEWLINE>"];
+  let replacedStr = str;
+  for (const esc of escaped) {
+    replacedStr = replacedStr.replace(new RegExp(esc, "g"), "\\n");
+  }
+  return replacedStr;
+}
+
+export function splitByNewLines(str: string): string[] {
+  const replacedStr = replaceEscapedNewLines(str);
+
+  // Step 2: Split the string by actual new lines
+  const parts = replacedStr.split("\n");
+
+  // Step 3: Restore the escaped new lines in the split parts
+  return parts.map((part) => restoreEscapedNewLines(part));
+}
+
+export function toUniqueArray<T>(arr: T[]): T[] {
+  return Array.from(new Set(arr));
+}
+
+export function mcpToolName(toolName: string): string {
+  const split = toolName.split("_");
+
+  if (split.length < 2) {
+    return null;
+  }
+
+  return split.slice(2).join("_");
+}
+
+export function takeFirstNWords(str: string, n: number): string {
+  const words = str.split(" ");
+  if (words.length <= n) {
+    return str;
+  }
+  return words.slice(n).join(" ");
+}

package/src/worker.ts

@@ -0,0 +1,80 @@
+import os from "os";
+import { WebSocket } from "ws";
+import { Developer, Patcher, Researcher } from "./agents";
+import { includedTools } from "./agents/tools/list";
+import { loadJwt } from "./login";
+import { Agents, Tools } from "./services";
+import { Mcp, McpServerService } from "./services/Mcp";
+import * as allTools from "./agents/tools";
+import { wait } from "./utils";
+import { getConfig, updateConfig } from "./config";
+
+const API_URL = process.env.KNOWHOW_API_URL;
+
+export async function worker() {
+  const mcpServer = new McpServerService(Tools);
+  const clientName = "knowhow-worker";
+  const clientVersion = "1.1.1";
+  const config = await getConfig();
+
+  if (!config.worker || !config.worker.allowedTools) {
+    console.log(
+      "Worker tools configured! Update knowhow.json to adjust which tools are allowed by the worker."
+    );
+    config.worker = {
+      ...config.worker,
+      allowedTools: Tools.getToolNames(),
+    };
+
+    await updateConfig(config);
+    return;
+  }
+
+  const toolsToUse = Tools.getToolsByNames(config.worker.allowedTools);
+  mcpServer.createServer(clientName, clientVersion).withTools(toolsToUse);
+
+  let connected = false;
+
+  async function connectWebSocket() {
+    const jwt = await loadJwt();
+    console.log(`Connecting to ${API_URL}`);
+
+    const dir = process.cwd();
+    const homedir = os.homedir();
+    const root = dir === homedir ? "~" : dir.replace(homedir, "~");
+    const ws = new WebSocket(`${API_URL}/worker`, {
+      headers: {
+        Authorization: `Bearer ${jwt}`,
+        "User-Agent": `${clientName}/${clientVersion}/${os.hostname()}`,
+        Root: `${root}`,
+      },
+    });
+
+    ws.on("open", () => {
+      console.log("Connected to the server");
+      connected = true;
+    });
+
+    ws.on("close", async (code, reason) => {
+      console.log(
+        `WebSocket closed. Code: ${code}, Reason: ${reason.toString()}`
+      );
+      console.log("Attempting to reconnect...");
+      connected = false;
+    });
+
+    ws.on("error", (error) => {
+      console.error("WebSocket error:", error);
+    });
+
+    mcpServer.runWsServer(ws);
+  }
+
+  while (true) {
+    if (!connected) {
+      console.log("Attempting to connect...");
+      connectWebSocket();
+    }
+    await wait(5000);
+  }
+}

package/tests/integration/figma.test.ts

@@ -0,0 +1,70 @@
+import { FigmaPlugin } from "../../src/plugins/figma";
+
+const figmaToken = "test_token"; // This should be the actual testing token
+const figmaPlugin = new FigmaPlugin();
+
+const exampleFigmaFileUrl =
+  "https://www.figma.com/file/iK2ggDLxl94Q4q0FKUdlmM/Guilds";
+const exampleNodeId = "52-717";
+const exampleNodeIds = [exampleNodeId];
+
+const expectedApiResponse = {
+  name: "Guilds",
+  nodes: { "52-717": { document: {} } },
+};
+
+describe("FigmaPlugin", () => {
+  describe("extractUrls", () => {
+    it("should extract Figma file URLs from a given text", () => {
+      const text = `Design can be found here: ${exampleFigmaFileUrl}`;
+      expect(figmaPlugin.extractUrls(text)).toEqual([exampleFigmaFileUrl]);
+    });
+  });
+
+  describe("extractFileIdFromUrl", () => {
+    it("should extract file ID from Figma URL", () => {
+      expect(figmaPlugin.extractFileIdFromUrl(exampleFigmaFileUrl)).toBe(
+        "iK2ggDLxl94Q4q0FKUdlmM"
+      );
+    });
+  });
+
+  describe("parseNodeIdsFromUrl", () => {
+    it("should extract node IDs from Figma URL", () => {
+      const urlWithNode = exampleFigmaFileUrl + "?node-id=" + exampleNodeId;
+      expect(figmaPlugin.parseNodeIdsFromUrl(urlWithNode)).toEqual(
+        exampleNodeIds
+      );
+    });
+  });
+
+  describe("loadFigmaData", () => {
+    it("should make an API call and return Figma data", async () => {
+      const data = await figmaPlugin.loadFigmaData(
+        exampleFigmaFileUrl + "?node-id=" + exampleNodeId
+      );
+      expect(data).toBeDefined;
+    });
+  });
+
+  describe("embed", () => {
+    it("should return a minimal embedding array", async () => {
+      const embeddings = await figmaPlugin.embed(
+        `Here's the design file: ${exampleFigmaFileUrl}?node-id=${exampleNodeId}`
+      );
+      expect(embeddings).toBeInstanceOf(Array);
+      expect(embeddings).toHaveLength(1);
+      const nodeId = exampleNodeId.replace("-", ":");
+      console.log(JSON.parse(embeddings[0].text));
+      /*
+       *expect(embeddings[0].text).toEqual(
+       *  JSON.stringify({
+       *    id: expectedApiResponse.name,
+       *    metadata: {},
+       *    text: JSON.stringify(expectedApiResponse),
+       *  })
+       *);
+       */
+    });
+  });
+});

package/tests/integration/fileblocks/readwrite.test.ts

@@ -0,0 +1,95 @@
+import * as fs from "fs";
+import { readFile, writeFile } from "../../../src/utils";
+import { Patcher } from "../../../src/agents/patcher/patcher";
+import { FlagsService } from "../../../src/services/flags";
+
+describe("Developer", () => {
+  beforeAll(() => {
+    Patcher.disableTool("searchFiles");
+    Patcher.disableTool("execCommand");
+    Patcher.enableTool("modifyFile");
+    Patcher.enableTool("readFile");
+  });
+
+  test("should be able to patch a codebase", async () => {
+    const inputPath = "tests/integration/patching/input.txt";
+    const originalText = (await readFile(inputPath)).toString();
+    await Patcher.call(
+      `Update the file in ${inputPath} change the string "finalAnswer" to "FinalAnswer" on line 120. Do not modify anything else. Treat this file as a typescript file.`
+    );
+
+    const updatedText = (await readFile(inputPath)).toString();
+    await writeFile(inputPath, originalText);
+
+    expect(updatedText).toBe(
+      originalText.replace(`"finalAnswer"`, `"FinalAnswer"`)
+    );
+  });
+
+  test("should be able to update the unseen file", async () => {
+    const unseenPath = "tests/integration/patching/unseen.txt";
+    const originalText = (await readFile(unseenPath)).toString();
+    await Patcher.call(
+      `Update the file in ${unseenPath} change the file additions and deletions count from 200 to 300. Do not modify anything else. Treat this file as a typescript file.`
+    );
+
+    const updatedText = (await readFile(unseenPath)).toString();
+    await writeFile(unseenPath, originalText);
+
+    expect(updatedText).toBe(originalText.replaceAll("200", "300"));
+  });
+
+  test.only("should be able to create a simple flag service", async () => {
+    const outputPath = "tests/integration/fileblocks/outputs/flags.js";
+
+    const promptText = `
+  Create the following class
+
+    - **Class Name**: FlagsService
+    - **Internal Variables**:
+      - flags: Object
+      - log: Boolean
+    - **Constructor**:
+      - Parameters: flags (Array<string>), log (Boolean)
+    - **Methods**:
+      - register(flags: Array<string>): Initializes flags with false.
+      - flip(flag: string): Toggles and logs the state of a flag.
+      - enableLogging(): Enables logging.
+      - disableLogging(): Disables logging.
+      - enabled(flag: string): Checks if a flag is enabled.
+    - **Singleton Variable**: Flags
+
+      Make sure to module.exports the class and Singleton, as we will be importing it in the test via require("./outputs/flags.js").Flags
+`;
+    await Patcher.call(
+      `Modify the file in ${outputPath} for these instructions.: ${promptText}`
+    );
+
+    const fileContent = (await readFile(outputPath)).toString();
+    console.log(fileContent);
+    jest.resetModules();
+    const service: FlagsService = require("./outputs/flags.js").Flags;
+    try {
+      service.register(["test"]);
+      expect(service.enabled("test")).toEqual(false);
+      service.flip("test");
+      expect(service.enabled("test")).toEqual(true);
+
+      await Patcher.call(
+        `Modify the file in ${outputPath} and add a method called hasFlag that takes a string and returns a boolean. It should return true if the flag is defined at all, even if it is false. This is a unit test, only modify the file I've specified.`
+      );
+
+      jest.resetModules();
+
+      const newService: FlagsService & {
+        hasFlag: (flag: string) => boolean;
+      } = require("./outputs/flags.js").Flags;
+
+      newService.register(["test"]);
+      expect(newService.hasFlag("test")).toEqual(true);
+      fs.unlinkSync(outputPath);
+    } catch (e) {
+      console.log(e);
+    }
+  });
+});