@tyvm/knowhow 0.0.90 → 0.0.92

package/src/plugins/linear.ts

@@ -1,230 +0,0 @@
-import { LinearClient } from "@linear/sdk";
-import { PluginBase, PluginMeta } from "./PluginBase";
-import { PluginContext } from "./types";
-import { MinimalEmbedding } from "../types";
-
-export class LinearPlugin extends PluginBase {
-  static readonly meta: PluginMeta = {
-    key: "linear",
-    name: "Linear Plugin",
-    requires: ["LINEAR_API_KEY"],
-  };
-
-  meta = LinearPlugin.meta;
-  linearClient: LinearClient;
-
-  constructor(context: PluginContext) {
-    super(context);
-
-    if (!this.isEnabled()) return;
-    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) {
-      this.log(`Error fetching Linear issue: ${error}`, "error");
-      return null;
-    }
-  }
-
-  async getTaskFromUrl(url: string) {
-    const issueId = this.getIdFromUrl(url);
-    if (issueId) {
-      this.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) {
-    this.log(`Project ID: ${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) {
-    this.log(`Team ID: ${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}`;
-  }
-}

package/src/plugins/notion.ts

@@ -1,179 +0,0 @@
-import { Client } from "@notionhq/client";
-import { PluginBase, PluginMeta } from "./PluginBase";
-import { PluginContext } from "./types";
-import { PageObjectResponse } from "@notionhq/client/build/src/api-endpoints";
-import { Embeddable, MinimalEmbedding } from "../types";
-
-export class NotionPlugin extends PluginBase {
-  static readonly meta: PluginMeta = {
-    key: "notion",
-    name: "Notion Plugin",
-    requires: ["NOTION_TOKEN"]
-  };
-
-  meta = NotionPlugin.meta;
-  notionClient: Client;
-
-  constructor(context: PluginContext) {
-    super(context);
-    
-    if (!this.isEnabled()) return;
-    this.notionClient = new Client({
-      auth: process.env.NOTION_TOKEN,
-    });
-  }
-
-  extractUrls(userPrompt: string): string[] {
-    const notionUrlRegex = /https:\/\/www\.notion\.so\/[^\s]+/g;
-    const matches = userPrompt.match(notionUrlRegex);
-    return matches || [];
-  }
-
-  getIdFromUrl(url: string): string {
-    return url.split("-").pop() || "";
-  }
-
-  findKeyInObject<T>(obj: T, searchKey = "plain_text") {
-    if (!obj) {
-      return null;
-    }
-    const keys = Object.keys(obj);
-    for (const key of keys) {
-      if (key === searchKey) {
-        return obj[key];
-      } else if (typeof obj[key] === "object") {
-        const result = this.findKeyInObject(obj[key], searchKey);
-        if (result) {
-          return result;
-        }
-      }
-    }
-  }
-  async getAllChildBlocks(
-    pageId: string,
-    maxDepth = 1,
-    currentDepth = 1,
-    processed = {}
-  ) {
-    if (processed[pageId] || currentDepth > maxDepth) {
-      return { results: [] };
-    }
-    this.log(`Fetching all blocks for page ${pageId} at depth ${currentDepth}`);
-    processed[pageId] = true;
-    const response = await this.notionClient.blocks.children.list({
-      block_id: pageId,
-    });
-
-    let cursor = response.next_cursor;
-    while (cursor) {
-      this.log("Fetching more blocks");
-      const childResponse = await this.notionClient.blocks.children.list({
-        block_id: pageId,
-        start_cursor: cursor,
-      });
-      response.results.push(...childResponse.results);
-      cursor = childResponse.next_cursor;
-    }
-
-    for (const block of response.results) {
-      if ("has_children" in block && block.has_children) {
-        const childBlocks = await this.getAllChildBlocks(
-          block.id,
-          maxDepth,
-          currentDepth + 1,
-          processed
-        );
-        response.results.push(...childBlocks.results);
-      }
-    }
-
-    response.has_more = false;
-    response.next_cursor = null;
-
-    return response;
-  }
-
-  async embed(user_input: string) {
-    const embeddings = new Array<MinimalEmbedding>();
-    const urls = this.extractUrls(user_input);
-    const results = await this.getPagesFromUrls(urls);
-    if (!results) {
-      return embeddings;
-    }
-
-    for (const result of results) {
-      let { page, blocks } = result;
-      const childPages = blocks.results.filter(
-        (b) => "has_children" in b && b.has_children
-      );
-
-      this.log(JSON.stringify(results, null, 2));
-
-      const childBlocks = await Promise.all(
-        childPages.map(async (childPage) => {
-          const blocks = await this.getAllChildBlocks(childPage.id);
-          return { childPage, blocks };
-        })
-      );
-
-      for (const child of childBlocks) {
-        const title =
-          "child_page" in child.childPage && child.childPage.child_page;
-        embeddings.push({
-          id: child.childPage.id,
-          text: JSON.stringify(
-            child.blocks.results.map((b) => this.findKeyInObject(b))
-          ),
-          metadata: {
-            ...title,
-          },
-        });
-      }
-    }
-
-    this.log(JSON.stringify(embeddings, null, 2));
-    return embeddings;
-  }
-
-  async getPageEmbedding(page: PageObjectResponse) {
-    let id = page.id;
-    let content = JSON.stringify(page);
-
-    return { id, content };
-  }
-
-  async getPageFromUrl(url: string) {
-    const pageId = url.split("-").pop();
-    if (pageId) {
-      this.log(`Fetching Notion page ${pageId}`);
-      const page = await this.notionClient.pages.retrieve({ page_id: pageId });
-      const blocks = await this.getAllChildBlocks(page.id);
-      return { page, blocks };
-    }
-    return null;
-  }
-
-  async getPagesFromUrls(urls: string[]) {
-    const pages = await Promise.all(
-      urls.map(async (url) => {
-        return this.getPageFromUrl(url);
-      })
-    );
-    return pages;
-  }
-
-  async call(userPrompt: string): Promise<string> {
-    const urls = this.extractUrls(userPrompt);
-    const pages = await this.getPagesFromUrls(urls);
-    const pagesDataFiltered = pages.filter((page) => page !== null);
-    if (pagesDataFiltered.length === 0) {
-      return "NOTION PLUGIN: No pages found";
-    }
-
-    const markdownPages = pagesDataFiltered
-      .map((page) => `### Page: ${JSON.stringify(page, null, 2)}\n-`)
-      .join("\n\n");
-    this.log(markdownPages);
-    return `NOTION PLUGIN: The following pages were loaded:\n\n${markdownPages}`;
-  }
-}