@tyvm/knowhow 0.0.1

package/src/plugins/github.ts

@@ -0,0 +1,153 @@
+import { Octokit } from "@octokit/rest";
+import { Plugin } from "./types";
+import { parseHunks, hunksToPatch } from "../agents/tools/patch";
+import { MinimalEmbedding } from "../types";
+
+export class GitHubPlugin implements Plugin {
+  octokit: Octokit;
+
+  constructor() {
+    this.octokit = new Octokit({
+      auth: process.env.GITHUB_TOKEN,
+    });
+  }
+
+  async embed(userPrompt: string): Promise<MinimalEmbedding[]> {
+    const urls = this.extractUrls(userPrompt);
+    const diffs = await this.getParsedDiffs(urls);
+    const diffsFiltered = diffs.filter((diff) => diff !== null);
+
+    return diffsFiltered.map((diff, index) => {
+      return {
+        id: urls[index],
+        text: JSON.stringify(diff),
+        metadata: {},
+      };
+    });
+  }
+
+  extractUrls(userPrompt: string): string[] {
+    const prUrlRegex =
+      /https:\/\/github\.com\/([\w-]+)\/([\w-]+)\/pull\/(\d+)/g;
+    const matches = userPrompt.match(prUrlRegex);
+    return matches;
+  }
+
+  parseUrl(url: string) {
+    const [owner, repo, _, pullNumber] = url.split("/").slice(-4);
+    return {
+      owner,
+      repo,
+      pullNumber,
+    };
+  }
+
+  async getDiff(url: string) {
+    const { owner, repo, pullNumber } = this.parseUrl(url);
+    console.log(
+      `GITHUB PLUGIN: Loading diff for ${owner}/${repo}#${pullNumber}`
+    );
+    const { data: diff } = await this.octokit.rest.pulls.get({
+      owner,
+      repo,
+      pull_number: parseInt(pullNumber, 10),
+      mediaType: {
+        format: "diff",
+      },
+    });
+
+    return diff;
+  }
+
+  getPR(url: string) {
+    const { owner, repo, pullNumber } = this.parseUrl(url);
+    return this.octokit.rest.pulls.get({
+      owner,
+      repo,
+      pull_number: parseInt(pullNumber, 10),
+    });
+  }
+
+  getLengthOfHunks(hunks: ReturnType<typeof parseHunks>) {
+    const length = hunks
+      .flatMap((hunk) => [...hunk.additions, ...hunk.subtractions])
+      .reduce((acc, line) => acc + line.length, 0);
+    console.log(`GITHUB PLUGIN: Length of hunks: ${length}`);
+    return length;
+  }
+
+  async getParsedDiffs(urls: string[]) {
+    return Promise.all(
+      urls.map(async (url) => {
+        const diff = await this.getDiff(url);
+        let parsed = parseHunks(diff.toString());
+
+        console.log(`GITHUB PLUGIN: Parsed ${parsed.length} hunks`);
+
+        const averageHunkSize =
+          parsed.reduce((acc, hunk) => acc + hunk.lines.length, 0) /
+          parsed.length;
+
+        const totalCharacters = parsed
+          .flatMap((hunk) => [...hunk.additions, ...hunk.subtractions])
+          .reduce((acc, line) => acc + line.length, 0);
+
+        console.log(
+          `GITHUB PLUGIN: Average hunk size: ${averageHunkSize}, total characters: ${totalCharacters}`
+        );
+
+        const MAX_CHARACTERS = 10000;
+        const average = MAX_CHARACTERS / averageHunkSize;
+        const PER_HUNK_LIMIT = Math.max(average, 2000);
+
+        parsed = parsed.filter((hunk) => {
+          return this.getLengthOfHunks([hunk]) <= PER_HUNK_LIMIT;
+        });
+
+        console.log(
+          `GITHUB PLUGIN: Filtered to ${
+            parsed.length
+          } hunks. ${this.getLengthOfHunks(parsed)} characters`
+        );
+        return parsed;
+      })
+    );
+  }
+
+  formatDiff(diff: any) {
+    return diff;
+  }
+
+  async call(userPrompt: string): Promise<string> {
+    const urls = this.extractUrls(userPrompt);
+
+    if (urls) {
+      const prs = [];
+      for (const url of urls) {
+        const { owner, repo, pullNumber } = this.parseUrl(url);
+        const { data: pr } = await this.getPR(url);
+        const responses = await this.getParsedDiffs(urls);
+        // Format the diffs in Markdown
+        const diffStrings = responses.map(hunksToPatch);
+
+        prs.push({
+          description: pr.title,
+          url: pr.html_url,
+          body: pr.body,
+          author: pr.user.login,
+          diff: diffStrings,
+        });
+      }
+
+      const context = `GITHUB PLUGIN: These ${urls} have automatically been expanded to include the changes:\n\n${JSON.stringify(
+        prs,
+        null,
+        2
+      )}`;
+      console.log(context);
+      return context;
+    }
+
+    return "GITHUB PLUGIN: No pull request URLs detected.";
+  }
+}

package/src/plugins/jira.ts

@@ -0,0 +1,104 @@
+import JiraClient from "jira-client";
+import { Plugin } from "./types";
+import { MinimalEmbedding } from "../types";
+
+export class JiraPlugin implements Plugin {
+  jiraClient: JiraClient;
+
+  constructor() {
+    this.jiraClient = new JiraClient({
+      protocol: "https",
+      host: process.env.JIRA_HOST,
+      username: process.env.JIRA_USER,
+      password: process.env.JIRA_PASSWORD,
+      apiVersion: "2",
+      strictSSL: true,
+    });
+  }
+
+  async embed(userPrompt: string): Promise<MinimalEmbedding[]> {
+    const urls = this.extractUrls(userPrompt);
+    const tasks = await this.getTasksFromUrls(urls);
+    const tasksFiltered = tasks.filter((task) => task !== null);
+
+    return tasksFiltered.map((task, index) => {
+      return {
+        id: urls[index],
+        text: JSON.stringify(task),
+        metadata: {},
+      };
+    });
+  }
+
+  async getTasksFromUrls(urls: string[]) {
+    const tasks = await Promise.all(
+      urls.map(async (url) => {
+        return this.getTaskFromUrl(url);
+      })
+    );
+    return tasks;
+  }
+
+  async getTaskFromUrl(url: string) {
+    const issueId = this.extractIdFromUrl(url);
+    if (issueId) {
+      console.log(`Fetching Jira issue ${issueId}`);
+      return await this.getIssueData(issueId);
+    }
+    return null;
+  }
+
+  async getIssueData(issueId: string) {
+    try {
+      const issue = await this.jiraClient.findIssue(issueId);
+      return issue;
+    } catch (error) {
+      console.error("Error fetching Jira issue:", error);
+      return null;
+    }
+  }
+
+  // https://${process.env.JIRA_HOST}/browse/${issue.key}
+  extractUrls(userPrompt: string): string[] {
+    const host = process.env.JIRA_HOST;
+    const regex = new RegExp(`https://${host}/browse/[A-Z]+-\\d+`, "g");
+    const matches = userPrompt.match(regex);
+    if (!matches) {
+      return [];
+    }
+    return matches;
+  }
+
+  extractIdFromUrl(url: string): string {
+    const host = process.env.JIRA_HOST;
+    const regex = new RegExp(`https://${host}/browse/([A-Z]+-\\d+)`, "g");
+    const matches = regex.exec(url);
+    if (matches && matches[1]) {
+      return matches[1];
+    }
+    return null;
+  }
+
+  getTaskString(task: any) {
+    return `### Issue: ${task.key}\n- Summary: ${task.fields.summary}\n- URL: ${process.env.JIRA_HOST}/browse/${task.key} \n- Description: ${task.fields.description}`;
+  }
+
+  async call(userPrompt: string): Promise<string> {
+    const urls = this.extractUrls(userPrompt);
+    if (!urls) {
+      return "JIRA PLUGIN: No issues found";
+    }
+
+    const issuesData = await this.getTasksFromUrls(urls);
+    const issuesDataFiltered = issuesData.filter((issue) => issue !== null);
+
+    if (issuesDataFiltered.length === 0) {
+      return "JIRA PLUGIN: No issues found";
+    }
+
+    const markdownIssues = issuesDataFiltered
+      .map((issue) => this.getTaskString(issue))
+      .join("\n\n");
+    return `JIRA PLUGIN: The following issues were loaded:\n\n${markdownIssues}`;
+  }
+}

package/src/plugins/language.ts

@@ -0,0 +1,100 @@
+import { readFile, fileExists, fileStat } from "../utils";
+import { Language } from "../types";
+import { getConfig, getLanguageConfig } from "../config";
+import { Plugin } from "./types";
+import { GitHubPlugin } from "./github";
+import { AsanaPlugin } from "./asana";
+import { JiraPlugin } from "./jira";
+import { LinearPlugin } from "./linear";
+import { PluginService } from "./plugins";
+
+export class LanguagePlugin implements Plugin {
+  constructor(private pluginService: PluginService) {}
+
+  async embed(userPrompt: string) {
+    return [];
+  }
+
+  async call(userPrompt: string): Promise<string> {
+    const config = await getConfig();
+    const languageConfig = await getLanguageConfig();
+    // Extract terms from the language configuration
+    const terms = Object.keys(languageConfig);
+
+    // Find all matching terms in the userPrompt
+    const matchingTerms = terms.filter((term) =>
+      term
+        .split(",")
+        .some((w) => userPrompt.toLowerCase().includes(w.toLowerCase()))
+    );
+    if (matchingTerms.length > 0) {
+      console.log("LANGUAGE PLUGIN: Found matching terms", matchingTerms);
+    }
+
+    const sources = matchingTerms.flatMap(
+      (term) => languageConfig[term].sources
+    );
+
+    const contexts = [];
+
+    // Load the files for the matching terms
+    const filesToLoad = sources
+      .filter((f) => f.kind === "file")
+      .map((f) => f.data)
+      .flat();
+
+    // Read the contents of the files
+    const fileContents = await Promise.all(
+      filesToLoad.map(async (filePath) => {
+        const exists = await fileExists(filePath);
+        if (!exists) {
+          return { filePath, content: `File ${filePath} does not exist` };
+        }
+        const content = (await readFile(filePath, "utf8")).toString();
+        console.log("LANGUAGE PLUGIN: Read file", filePath);
+        return { filePath, content };
+      })
+    );
+    contexts.push(...fileContents);
+
+    const textContexts = matchingTerms
+      .flatMap((term) =>
+        languageConfig[term].sources.filter((s) => s.kind === "text")
+      )
+      .map((s) => s.data);
+    contexts.push(...textContexts);
+
+    const plugins = this.pluginService.listPlugins();
+    for (const plugin of plugins) {
+      if (config.plugins.includes(plugin)) {
+        const matchingSources = sources.filter((s) => s.kind === plugin);
+        if (matchingSources.length === 0) {
+          continue;
+        }
+
+        const data = matchingSources
+          .map((s) => s.data)
+          .flat()
+          .join("\n");
+        console.log("LANGUAGE PLUGIN: Calling plugin", plugin, data);
+        const pluginContext = await this.pluginService.call(plugin, data);
+
+        contexts.push(...pluginContext);
+      }
+    }
+
+    if (!matchingTerms || !matchingTerms.length) {
+      return "LANGUAGE PLUGIN: No matching terms found";
+    }
+
+    // Return the file contents in a format that can be added to the prompt context
+    return `LANGUAGE PLUGIN: The user mentioned these terms triggering contextual expansions ${matchingTerms} expanded to: ${JSON.stringify(
+      contexts
+    )}
+    These terms are directly related to what the user is asking about so be sure to contextualize your response to this information.
+    `;
+  }
+}
+
+// Since this uses other plugins, it needs to be registered
+// Plugins.registerPlugin("language", new LanguagePlugin());

package/src/plugins/linear.ts

@@ -0,0 +1,219 @@
+import { LinearClient } from "@linear/sdk";
+import { Plugin } from "./types";
+import { MinimalEmbedding } from "../types";
+
+export class LinearPlugin implements Plugin {
+  linearClient: LinearClient;
+
+  constructor() {
+    this.linearClient = new LinearClient({
+      apiKey: process.env.LINEAR_API_KEY,
+    });
+  }
+
+  async embed(userPrompt: string): Promise<MinimalEmbedding[]> {
+    const urls = this.extractTaskUrls(userPrompt);
+    const tasksData = await this.getTasksFromUrls(urls);
+    const tasksDataFiltered = tasksData.filter((task) => task !== null);
+
+    const tasksEmbeddings = tasksDataFiltered.map((task) => {
+      return {
+        id: task.url,
+        text: this.getTaskString(task),
+        metadata: {
+          task: JSON.stringify(task),
+        },
+      };
+    });
+
+    const projectUrls = this.extractProjectUrls(userPrompt);
+    const projectTasks = await this.getTasksFromProjectUrls(projectUrls);
+    const projectTasksFiltered = projectTasks.filter((t) => t !== null);
+
+    const projectTaskEmbeddings = projectTasksFiltered
+      .map((t) => {
+        return {
+          id: t.url,
+          text: this.getTaskString(t),
+          metadata: {
+            task: JSON.stringify(t),
+          },
+        };
+      })
+      .flat();
+
+    const teamUrls = this.extractTeamUrls(userPrompt);
+    const teamTasks = await this.getTasksFromTeamUrls(teamUrls);
+    const teamTasksFiltered = teamTasks.filter((t) => t !== null);
+
+    const teamTaskEmbeddings = teamTasksFiltered
+      .map((t) => {
+        return {
+          id: t.url,
+          text: this.getTaskString(t),
+          metadata: {
+            task: JSON.stringify(t),
+          },
+        };
+      })
+      .flat();
+
+    return tasksEmbeddings
+      .concat(projectTaskEmbeddings)
+      .concat(teamTaskEmbeddings);
+  }
+
+  async getIssueData(issueId: string) {
+    try {
+      const issue = await this.linearClient.issue(issueId);
+      return issue;
+    } catch (error) {
+      console.error("Error fetching Linear issue:", error);
+      return null;
+    }
+  }
+
+  async getTaskFromUrl(url: string) {
+    const issueId = this.getIdFromUrl(url);
+    if (issueId) {
+      console.log(`Fetching Linear issue ${issueId}`);
+      return await this.getIssueData(issueId);
+    }
+    return null;
+  }
+
+  async getTasksFromUrls(urls: string[]) {
+    const tasks = await Promise.all(
+      urls.map(async (url) => {
+        return this.getTaskFromUrl(url);
+      })
+    );
+    return tasks;
+  }
+
+  extractTeamUrls(userPrompt: string): string[] {
+    const urlRegex = /https:\/\/linear\.app\/[^\/]+\/team\/[^\/]+\/[^\/]+/g;
+    const matches = userPrompt.match(urlRegex);
+    return matches || [];
+  }
+
+  getTeamIdFromUrl(url: string): string {
+    const urlRegex = /https:\/\/linear\.app\/[^\/]+\/team\/([^\/]+)\/[^\/]+/g;
+    const match = urlRegex.exec(url);
+    if (match && match[1]) {
+      return match[1];
+    }
+    return null;
+  }
+
+  extractProjectUrls(userPrompt: string): string[] {
+    const urlRegex = /https:\/\/linear\.app\/[^\/]+\/project\/[^\/]+\/[^\/]+/g;
+    const matches = userPrompt.match(urlRegex);
+    return matches || [];
+  }
+
+  getProjectIdFromUrl(url: string): string {
+    const urlRegex =
+      /https:\/\/linear\.app\/[^\/]+\/project\/([^\/]+)\/[^\/]+/g;
+    const match = urlRegex.exec(url);
+    if (match && match[1]) {
+      const parts = match[1].split("-");
+      return parts[parts.length - 1];
+    }
+    return null;
+  }
+
+  async getTasksForProject(projectId: string) {
+    console.log({ projectId });
+    let tasks = await this.linearClient.issues({
+      filter: {
+        project: { slugId: { eq: projectId } },
+      },
+    });
+    let allTasks = tasks.nodes;
+
+    while (tasks.pageInfo.hasNextPage) {
+      tasks = await tasks.fetchNext();
+      allTasks = allTasks.concat(tasks.nodes);
+    }
+
+    return allTasks;
+  }
+
+  async getTasksFromProjectUrls(urls: string[]) {
+    const tasks = await Promise.all(
+      urls.map(async (url) => {
+        return this.getTasksForProject(this.getProjectIdFromUrl(url));
+      })
+    );
+    return tasks.flat();
+  }
+
+  async getTasksForTeam(teamId: string) {
+    console.log({ teamId });
+    let tasks = await this.linearClient.issues({
+      filter: {
+        team: { key: { eq: teamId } },
+      },
+    });
+
+    let allTasks = tasks.nodes;
+
+    while (tasks.pageInfo.hasNextPage) {
+      tasks = await tasks.fetchNext();
+      allTasks = allTasks.concat(tasks.nodes);
+    }
+
+    return allTasks;
+  }
+
+  async getTasksFromTeamUrls(urls: string[]) {
+    const tasks = await Promise.all(
+      urls.map(async (url) => {
+        return this.getTasksForTeam(this.getTeamIdFromUrl(url));
+      })
+    );
+    return tasks.flat();
+  }
+
+  extractTaskUrls(userPrompt: string): string[] {
+    const urlRegex = /https:\/\/linear\.app\/[^\/]+\/issue\/[^\/]+\/[^\/]+/g;
+    const matches = userPrompt.match(urlRegex);
+    if (!matches) {
+      return [];
+    }
+    return matches;
+  }
+
+  getIdFromUrl(url: string): string {
+    const urlRegex = /https:\/\/linear\.app\/[^\/]+\/issue\/([^\/]+)\/[^\/]+/g;
+    const match = urlRegex.exec(url);
+    if (match && match[1]) {
+      return match[1];
+    }
+    return null;
+  }
+
+  getTaskString(task: any): string {
+    return `Issue: ${task.identifier}\nTitle: ${task.title}\nURL: ${task.url} \nDescription: ${task.description}`;
+  }
+
+  async call(userPrompt: string): Promise<string> {
+    const urls = this.extractTaskUrls(userPrompt);
+    if (!urls) {
+      return "LINEAR PLUGIN: No issues found";
+    }
+
+    const issuesData = await this.getTasksFromUrls(urls);
+    const issuesDataFiltered = issuesData.filter((issue) => issue !== null);
+
+    if (issuesDataFiltered.length === 0) {
+      return "LINEAR PLUGIN: No issues found";
+    }
+
+    const markdownIssues = issuesDataFiltered
+      .map((issue) => this.getTaskString(issue))
+      .join("\n\n");
+    return `LINEAR PLUGIN: The following issues were loaded:\n\n${markdownIssues}`;
+  }
+}