@tyvm/knowhow 0.0.1

package/src/agents/tools/asana/index.ts

@@ -0,0 +1,108 @@
+const workspace = process.env.ASANA_WORKSPACE;
+class AsanaTools {
+  private client = require("asana").ApiClient.instance;
+
+  constructor(private accessToken: string) {
+    this.client.authentications.token = process.env.ASANA_TOKEN;
+    this.client.defaultHeaders = {
+      "Asana-Enable": "new_user_task_lists,new_goal_memberships",
+    };
+  }
+
+  async createTask(projectId: string, taskName: string, taskNotes: string) {
+    if (!workspace) {
+      throw new Error("Need to set ENV Variable ASANA Workspace");
+    }
+
+    const task = await this.client.tasks.create({
+      workspace,
+      projects: [projectId],
+      name: taskName,
+      notes: taskNotes,
+    });
+    console.log(`Task created: ${task.permalink_url}`);
+    return task;
+  }
+
+  async updateTask(taskId: string, updates: object) {
+    const task = await this.client.tasks.updateTask(taskId, updates);
+    console.log(`Task updated: ${task.permalink_url}`);
+    return task;
+  }
+
+  async searchTasks(searchTerm: string) {
+    if (!workspace) {
+      throw new Error("Need to set ENV Variable ASANA Workspace");
+    }
+    searchTerm = searchTerm.toLowerCase();
+    const allTasks = await this.client.tasks.findAll({
+      opt_expand: "notes",
+      workspace,
+    });
+    const found = allTasks.data.filter(
+      (t) =>
+        t.notes.toLowerCase().includes(searchTerm) ||
+        t.name.toLowerCase().includes(searchTerm)
+    );
+
+    console.log("Found", found.length, "tasks");
+    return found;
+  }
+
+  async findTask(taskId: string) {
+    const task = await this.client.tasks.findById(taskId);
+    console.log(`Task found: ${task.permalink_url}`);
+    return task;
+  }
+
+  async getSubtasks(taskId: string) {
+    const tasks = await this.client.tasks.subtasks(taskId);
+    return tasks.data;
+  }
+
+  async createSubtask(taskId: string, taskName: string, taskNotes = "") {
+    const task = await this.client.tasks.addSubtask(taskId, {
+      name: taskName,
+      notes: taskNotes,
+    });
+    return task;
+  }
+
+  async myTasks(project?: string) {
+    const me = await this.client.users.me();
+    const tasks = await this.client.tasks.findAll({
+      assignee: Number(me.gid),
+      project,
+      workspace,
+      opt_expand: "completed",
+    });
+    return tasks.data.filter((t) => !t.completed);
+  }
+
+  async listProjects() {
+    if (!workspace) {
+      throw new Error("Need to set ENV Variable ASANA Workspace");
+    }
+    const allData = [];
+    let projects = await this.client.projects.findAll({
+      workspace,
+      archived: false,
+    });
+    do {
+      allData.push(...projects.data);
+      projects = await projects.nextPage();
+    } while (projects && projects?.data?.length);
+
+    return allData;
+  }
+}
+
+const asana = new AsanaTools(process.env.ASANA_TOKEN);
+export const createTask = asana.createTask.bind(asana);
+export const updateTask = asana.updateTask.bind(asana);
+export const searchTasks = asana.searchTasks.bind(asana);
+export const findTask = asana.findTask.bind(asana);
+export const getSubtasks = asana.getSubtasks.bind(asana);
+export const createSubtask = asana.createSubtask.bind(asana);
+export const myTasks = asana.myTasks.bind(asana);
+export const listProjects = asana.listProjects.bind(asana);

package/src/agents/tools/askHuman.ts

@@ -0,0 +1,8 @@
+import Marked from "marked";
+import { ask } from "../../utils";
+
+export async function askHuman(question: string) {
+  console.log("AI has asked: ");
+  console.log(Marked.parse(question), "\n");
+  return ask("response: ");
+}

package/src/agents/tools/callPlugin.ts

@@ -0,0 +1,4 @@
+import { Plugins } from "../../plugins/plugins";
+export async function callPlugin(pluginName: string, userInput: string) {
+  return Plugins.call(pluginName, userInput);
+}

package/src/agents/tools/embeddingSearch.ts

@@ -0,0 +1,5 @@
+// Tool to search for files related to the user's goal
+import { Plugins } from "../../plugins/plugins";
+export async function embeddingSearch(keyword: string): Promise<string> {
+  return Plugins.call("embeddings", keyword);
+}

package/src/agents/tools/execCommand.ts

@@ -0,0 +1,26 @@
+import { execAsync } from "../../utils";
+
+// Tool to execute a command in the system's command line interface
+export const execCommand = async (command: string): Promise<string> => {
+  let output = "";
+  console.log("execCommand:", command);
+  const { stdout, stderr } = await execAsync(command).catch((e) => e);
+  if (stderr) {
+    output += stderr + "\n";
+  }
+  output += stdout;
+  console.log(`$ ${command}:\n${output}`);
+
+  const fullOutput = output.split("\n");
+
+  const maxLines = 1000;
+  const maxCharacters = 40000;
+  const shouldTrim = fullOutput.length > maxLines;
+  const trimmedOutput = shouldTrim ? fullOutput.slice(0, maxLines) : fullOutput;
+
+  const trimmedMessage = shouldTrim
+    ? ` (${fullOutput.length - maxLines} results trimmed)`
+    : "";
+
+  return trimmedOutput.join("\n").slice(0, maxCharacters) + trimmedMessage;
+};

package/src/agents/tools/fileSearch.ts

@@ -0,0 +1,33 @@
+import glob from "glob";
+import { getConfiguredEmbeddings } from "../../embeddings";
+import { execCommand } from "./execCommand";
+import { getIgnorePattern } from "../../config";
+import { toUniqueArray } from "../../utils";
+
+export async function fileSearch(searchTerm) {
+  const searchTermLower = searchTerm.toLowerCase();
+  const pattern = `./**/*${searchTermLower}*`;
+  const ignore = await getIgnorePattern();
+  console.log({ pattern, ignore });
+  const files = await glob.sync(pattern, {
+    ignore,
+  });
+
+  if (files.length === 0) {
+    const embeddings = await getConfiguredEmbeddings();
+    const results = embeddings.filter((embedding) =>
+      embedding.id.toLowerCase().includes(searchTermLower)
+    );
+
+    // ids are filepath.txt-part
+    const ids = toUniqueArray(
+      results.map((r) => {
+        const parts = r.id.split("-");
+        return parts.slice(0, -1).join("-");
+      })
+    );
+    files.push(...ids);
+  }
+
+  return JSON.stringify(files);
+}

package/src/agents/tools/finalAnswer.ts

@@ -0,0 +1,4 @@
+// Finalize the AI's task and return the answer to the user
+export function finalAnswer(answer: string): string {
+  return answer;
+}

package/src/agents/tools/github/definitions.ts

@@ -0,0 +1,89 @@
+export const definitions = [
+  {
+    type: "function",
+    function: {
+      name: "getPullRequest",
+      description:
+        "Fetches a pull request from GitHub using the provided URL. Requires a valid GITHUB_TOKEN.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          url: {
+            type: "string",
+            description: "The URL of the pull request to fetch.",
+          },
+        },
+        required: ["url"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "getPullRequestBuildStatuses",
+      description:
+        "Fetches the build statuses for a pull request using the provided URL. Requires a valid GITHUB_TOKEN.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          url: {
+            type: "string",
+            description:
+              "The URL of the pull request to fetch build statuses for.",
+          },
+        },
+        required: ["url"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "getRunLogs",
+      description:
+        "Retrieves the run logs for a specified GitHub Actions run ID in the specified repository.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          runId: {
+            type: "number",
+            description:
+              "The ID of the GitHub Actions run to retrieve logs for.",
+          },
+          owner: {
+            type: "string",
+            description: "The owner of the repository containing the run.",
+          },
+          repo: {
+            type: "string",
+            description: "The name of the repository containing the run.",
+          },
+        },
+        required: ["runId", "owner", "repo"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "getPullRequestBuildFailureLogs",
+      description:
+        "Fetches the build failure logs for a pull request using the provided URL. Specifically focuses on failures.",
+      parameters: {
+        type: "object",
+        positional: true,
+        properties: {
+          url: {
+            type: "string",
+            description:
+              "The URL of the pull request to fetch failure logs for.",
+          },
+        },
+        required: ["url"],
+      },
+    },
+  },
+];

package/src/agents/tools/github/index.ts

@@ -0,0 +1,67 @@
+import { Octokit } from "@octokit/rest";
+import * as fs from "fs";
+import { execCommand } from "../execCommand";
+
+const octokit = new Octokit({
+  auth: process.env.GITHUB_TOKEN,
+});
+
+export async function getPullRequest(url: string) {
+  const [owner, repo, _, pullNumber] = url.split("/").slice(-4);
+  const pullRequest = await octokit.rest.pulls.get({
+    owner,
+    repo,
+    pull_number: parseInt(pullNumber, 10),
+  });
+
+  return pullRequest;
+}
+
+export async function getPullRequestBuildStatuses(url: string) {
+  const [owner, repo, _, pullNumber] = url.split("/").slice(-4);
+
+  const pullRequest = await octokit.rest.pulls.get({
+    owner,
+    repo,
+    pull_number: parseInt(pullNumber, 10),
+  });
+
+  const { data: statuses } = await octokit.rest.checks.listForRef({
+    owner,
+    repo,
+    ref: pullRequest.data.head.sha,
+  });
+
+  return statuses;
+}
+
+export async function getRunLogs(runId: number, owner: string, repo: string) {
+  const logs = await execCommand(
+    `gh run view ${runId} -R ${owner}/${repo} --log`
+  );
+  return logs;
+}
+
+export async function getPullRequestBuildFailureLogs(url: string) {
+  const [owner, repo, _, pullNumber] = url.split("/").slice(-4);
+  const statuses = await getPullRequestBuildStatuses(url);
+  const failures = statuses.check_runs.filter(
+    (status) => status.conclusion === "failure"
+  );
+
+  if (failures.length === 0) {
+    return "No failures found";
+  }
+
+  const allLogs = [];
+  for (const fail of failures) {
+    const [runId, __, jobId] = fail.details_url.split("/").slice(-3);
+    const logs = await execCommand(
+      `gh run view ${runId} -R ${owner}/${repo} --log | grep -E 'FAIL|ERROR' -A 25 -B 25`
+    );
+    return logs;
+    allLogs.push(logs);
+  }
+
+  return allLogs;
+}

package/src/agents/tools/googleSearch.ts

@@ -0,0 +1,242 @@
+import axios from "axios";
+import { Tool } from "../../clients/types";
+
+interface GoogleSearchParams {
+  q: string;
+  cx?: string;
+  dateRestrict?: string;
+  siteSearch?: string;
+  siteSearchFilter?: "e" | "i";
+  sort?: string;
+  start?: number;
+  lr?: string;
+  num?: number;
+  [key: string]: any;
+}
+
+// Google Search API Response Types
+interface GoogleSearchUrlTemplate {
+  type: string;
+  template: string;
+}
+
+interface GoogleSearchQuery {
+  title: string;
+  totalResults: string;
+  searchTerms: string;
+  count: number;
+  startIndex: number;
+  startPage: number;
+  language: string;
+  inputEncoding: string;
+  outputEncoding: string;
+  safe: string;
+  cx: string;
+  sort: string;
+  filter: string;
+  gl: string;
+  cr: string;
+  googleHost: string;
+  disableCnTwTranslation: string;
+  hq: string;
+  hl: string;
+  siteSearch: string;
+  siteSearchFilter: string;
+  exactTerms: string;
+  excludeTerms: string;
+  linkSite: string;
+  orTerms: string;
+  relatedSite: string;
+  dateRestrict: string;
+  lowRange: string;
+  highRange: string;
+  fileType: string;
+  rights: string;
+  searchType: string;
+  imgSize: string;
+  imgType: string;
+  imgColorType: string;
+  imgDominantColor: string;
+}
+
+interface GoogleSearchQueries {
+  previousPage: GoogleSearchQuery[];
+  request: GoogleSearchQuery[];
+  nextPage: GoogleSearchQuery[];
+}
+
+interface GoogleSearchInformation {
+  searchTime: number;
+  formattedSearchTime: string;
+  totalResults: string;
+  formattedTotalResults: string;
+}
+
+interface GoogleSearchSpelling {
+  correctedQuery: string;
+  htmlCorrectedQuery: string;
+}
+
+export interface GoogleSearchResponse {
+  kind: string;
+  url: GoogleSearchUrlTemplate;
+  queries: GoogleSearchQueries;
+  promotions?: any[];
+  context?: any;
+  searchInformation: GoogleSearchInformation;
+  spelling?: GoogleSearchSpelling;
+  items?: any[];
+}
+
+interface LlmRelevantSearchResult {
+  title: string;
+  link: string;
+  snippet: string;
+  source?: string;
+}
+
+interface TransformedLlmResponse {
+  searchQuery: string;
+  totalResults?: string;
+  results: LlmRelevantSearchResult[];
+}
+
+/**
+ * Transforms the Google Custom Search API response to a more LLM-relevant format.
+ * It prioritizes plain text fields and extracts essential information.
+ *
+ * @param apiResponse The original API response from Google Custom Search.
+ * @returns An object containing the search query and a list of processed search results.
+ */
+function transformGoogleSearchResponseForLLM(
+  apiResponse: GoogleSearchResponse
+) {
+  const searchQuery =
+    apiResponse.queries?.request?.[0]?.searchTerms || "Unknown query";
+  const totalResults = apiResponse.searchInformation?.totalResults;
+
+  const relevantItems: LlmRelevantSearchResult[] = (
+    apiResponse.items || []
+  ).map((item) => {
+    let bestSnippet = item.snippet || ""; // Default to the item's snippet
+
+    const metaTags = item.pagemap?.metatags?.[0];
+    if (metaTags) {
+      const ogDescription = metaTags["og:description"];
+      const twitterDescription = metaTags["twitter:description"];
+      const genericDescription = metaTags?.description;
+
+      // Prefer meta descriptions if they are longer or provide more context
+      if (ogDescription && ogDescription.length > bestSnippet.length) {
+        bestSnippet = ogDescription;
+      } else if (
+        twitterDescription &&
+        twitterDescription.length > bestSnippet.length
+      ) {
+        bestSnippet = twitterDescription;
+      } else if (
+        genericDescription &&
+        genericDescription.length > bestSnippet.length
+      ) {
+        bestSnippet = genericDescription;
+      }
+    }
+
+    return {
+      title: item.title,
+      link: item.link,
+      snippet: bestSnippet,
+      source: item.displayLink,
+    };
+  });
+
+  return {
+    searchQuery,
+    totalResults,
+    results: relevantItems,
+  };
+}
+
+export async function googleSearch(params: GoogleSearchParams) {
+  const apiKey = process.env.GOOGLE_SEARCH_API_KEY;
+  const cx = process.env.GOOGLE_SEARCH_CX;
+  if (!apiKey) {
+    throw new Error("GOOGLE_SEARCH_API_KEY environment variable is not set");
+  }
+  if (!cx) {
+    throw new Error("GOOGLE_SEARCH_CX environment variable is not set");
+  }
+
+  const baseUrl = "https://www.googleapis.com/customsearch/v1";
+  const url = new URL(baseUrl);
+  url.searchParams.append("key", apiKey);
+  url.searchParams.append("cx", cx);
+
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined) {
+      url.searchParams.append(key, value.toString());
+    }
+  }
+
+  try {
+    const response = await axios.get<GoogleSearchResponse>(url.toString());
+    return transformGoogleSearchResponseForLLM(response.data);
+  } catch (error) {
+    console.error("Error performing Google search:", error);
+    throw error;
+  }
+}
+
+export const googleSearchDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "googleSearch",
+    description: "Perform a Google search using the Custom Search API",
+    parameters: {
+      type: "object",
+      properties: {
+        q: {
+          type: "string",
+          description: "The search query",
+        },
+        num: {
+          type: "number",
+          description:
+            "The number of search results to return (optional, default is 10, max is 10)",
+        },
+        start: {
+          type: "number",
+          description:
+            "The index of the first result to return (optional, default is 1)",
+        },
+        dateRestrict: {
+          type: "string",
+          description:
+            "Restricts results to URLs based on date. Format: [d|w|m|y]NUMBER. Example: 'd10' for past 10 days",
+        },
+        siteSearch: {
+          type: "string",
+          description: "Specifies a site to search within",
+        },
+        siteSearchFilter: {
+          type: "string",
+          description:
+            "Controls whether to include or exclude results from the site specified in siteSearch. 'e' to exclude, 'i' to include",
+        },
+        sort: {
+          type: "string",
+          description:
+            "The sort expression to apply to the results, e.g., 'date'",
+        },
+        lr: {
+          type: "string",
+          description:
+            "Restricts the search to documents written in a particular language (e.g., lr=lang_ja)",
+        },
+      },
+      required: ["q"],
+    },
+  },
+};
+
+export default googleSearch;

package/src/agents/tools/index.ts

@@ -0,0 +1,24 @@
+export * from "./addInternalTools";
+export * from "./agentCall";
+export * from "./callPlugin";
+export * from "./embeddingSearch";
+export * from "./execCommand";
+export * from "./finalAnswer";
+export * from "./index";
+export * from "./lintFile";
+export * from "./modifyFile";
+export * from "./patch";
+export * from "./readBlocks";
+export * from "./readFile";
+export * from "./scanFile";
+export * from "./textSearch";
+export * from "./visionTool";
+export * from "./writeFile";
+export * from "./asana";
+export * from "./github";
+export * from "./fileSearch";
+export * from "./language";
+export * from "./askHuman";
+export * from "./aiClient";
+export * from "./googleSearch";
+export * from "./loadWebpage";