@tyvm/knowhow 0.0.1

package/src/index.ts

@@ -0,0 +1,376 @@
+import { summarizeFiles, summarizeFile } from "./ai";
+import {
+  saveAllFileHashes,
+  saveHashes,
+  getHashes,
+  checkNoFilesChanged,
+} from "./hashes";
+import axios from "axios";
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import { promisify } from "util";
+import glob from "glob";
+
+import { Prompts } from "./prompts";
+import { Config, Hashes, Embeddable, GenerationSource } from "./types";
+import { readFile, writeFile, fileExists } from "./utils";
+import {
+  getConfig,
+  loadPrompt,
+  updateConfig,
+  getIgnorePattern,
+} from "./config";
+import {
+  embedJson,
+  embedKind,
+  getConfiguredEmbeddings,
+  pruneEmbedding,
+  loadEmbedding,
+  saveEmbedding,
+  embedSource,
+  getConfiguredEmbeddingMap,
+} from "./embeddings";
+
+import { abort } from "process";
+import { chatLoop } from "./chat";
+import { convertToText } from "./conversion";
+import { Plugins } from "./plugins/plugins";
+import { AwsS3 } from "./services/S3";
+import { GitHub } from "./services/GitHub";
+import { knowhowMcpClient } from "./services/Mcp";
+import { knowhowApiClient } from "./services/KnowhowClient";
+import { Models } from "./types";
+
+export * as clients from "./clients";
+export * as agents from "./agents";
+export * as ai from "./ai";
+export * as services from "./services";
+export * as embeddings from "./embeddings";
+export * as types from "./types";
+
+const OPENAI_KEY = process.env.OPENAI_KEY;
+
+export async function embed() {
+  // load config
+  const config = await getConfig();
+  const ignorePattern = await getIgnorePattern();
+
+  const defaultModel = config.embeddingModel || Models.openai.EmbeddingAda2;
+  for (const source of config.embedSources) {
+    await embedSource(defaultModel, source, ignorePattern);
+  }
+}
+
+export async function purge(globPath: string) {
+  const files = glob.sync(globPath);
+  const embeddings = await getConfiguredEmbeddingMap();
+  const config = await getConfig();
+  const chunkSizes = config.embedSources.reduce((acc, source) => {
+    acc[source.output] = source.chunkSize;
+    return acc;
+  }, {});
+
+  for (const file of Object.keys(embeddings)) {
+    let pruned = embeddings[file];
+    for (const filePath of files) {
+      const before = pruned.length;
+      pruned = pruned
+        .filter((e) => !filePath || !e.id.startsWith("./" + filePath))
+        .filter((e) => e.text.length <= chunkSizes[file]);
+      const after = pruned.length;
+
+      if (after < before) {
+        console.log("Purging", filePath);
+      }
+    }
+    await saveEmbedding(file, pruned);
+  }
+}
+
+export async function upload() {
+  const config = await getConfig();
+
+  for (const source of config.embedSources) {
+    const bucketName = source.remote;
+
+    if (!source.remoteType) {
+      console.log(
+        "Skipping",
+        source.output,
+        "because no remoteType is configured"
+      );
+      continue;
+    }
+    const items = JSON.parse(await readFile(source.output, "utf8"));
+    const { name: embeddingName } = path.parse(source.output);
+    const data = {
+      embeddingName,
+      items,
+    };
+
+    if (source.remoteType === "s3") {
+      console.log(
+        "Uploading",
+        source.output,
+        "to",
+        `${bucketName}/${embeddingName}.json`
+      );
+
+      const s3Key = `${embeddingName}.json`;
+      await AwsS3.uploadFile(source.output, bucketName, s3Key);
+    } else if (source.remoteType === "knowhow") {
+      if (!source.remoteId) {
+        throw new Error("remoteId is required for knowhow uploads");
+      }
+      const url = await knowhowApiClient.getPresignedUploadUrl(source);
+      console.log("Uploading to", url);
+      await AwsS3.uploadToPresignedUrl(url, source.output);
+    } else {
+      console.log(
+        "Skipping upload to",
+        source.remoteType,
+        "for",
+        source.remote
+      );
+    }
+  }
+}
+
+export async function generate(): Promise<void> {
+  const config = await getConfig();
+  for (const source of config.sources) {
+    console.log("Generating", source.input, "to", source.output);
+    if (source.kind === "file" || !source.kind) {
+      const files = glob.sync(source.input);
+      const prompt = await loadPrompt(source.prompt);
+
+      if (source.output.endsWith("/")) {
+        await handleMultiOutputGeneration(
+          source.model,
+          source.input,
+          files,
+          prompt,
+          source.output,
+          source.outputExt,
+          source.outputName,
+          source.kind,
+          source.agent
+        );
+      } else {
+        await handleSingleOutputGeneration(
+          source.model,
+          files,
+          prompt,
+          source.output,
+          source.kind,
+          source.agent
+        );
+      }
+    } else {
+      await handleAllKindsGeneration(source);
+    }
+  }
+}
+
+async function handleAllKindsGeneration(source: GenerationSource) {
+  const { kind, input } = source;
+  if (Plugins.isPlugin(kind)) {
+    const data = await Plugins.call(kind, input);
+    if (source.output.endsWith("/")) {
+      throw new Error(`Plugin ${kind} can only output to a single file`);
+    }
+    await writeFile(source.output, data);
+  }
+  return handleFileKindGeneration(source);
+}
+
+async function handleFileKindGeneration(source: GenerationSource) {
+  const prompt = await loadPrompt(source.prompt);
+  const files = glob.sync(source.input);
+  console.log("Analyzing files: ", files);
+
+  if (source.output.endsWith("/")) {
+    await handleMultiOutputGeneration(
+      source.model,
+      source.input,
+      files,
+      prompt,
+      source.output,
+      source.outputExt,
+      source.outputName,
+      source.kind,
+      source.agent
+    );
+  } else {
+    await handleSingleOutputGeneration(
+      source.model,
+      files,
+      prompt,
+      source.output,
+      source.kind,
+      source.agent
+    );
+  }
+}
+export async function handleMultiOutputGeneration(
+  model: string,
+  inputPattern: string,
+  files: string[],
+  prompt: string,
+  output: string,
+  outputExt = "mdx",
+  outputName?: string,
+  kind?: string,
+  agent?: string
+) {
+  // get the hash of the prompt
+  const promptHash = crypto.createHash("md5").update(prompt).digest("hex");
+
+  // get the files matching the input pattern
+  const hashes = await getHashes();
+
+  const inputPath = inputPattern.includes("**")
+    ? inputPattern.split("**")[0]
+    : "";
+
+  for (const file of files) {
+    // get the hash of the file
+    const fileContent = await convertToText(file);
+    const fileHash = crypto.createHash("md5").update(fileContent).digest("hex");
+
+    if (!hashes[file]) {
+      hashes[file] = { promptHash: "", fileHash: "" };
+    }
+
+    // summarize the file
+    console.log("Summarizing", file);
+    const summary = prompt
+      ? await summarizeFile(file, prompt, model, agent)
+      : fileContent;
+
+    // write the summary to the output file
+    const { name, ext, dir } = path.parse(file);
+    const nestedFolder = inputPath ? (dir + "/").replace(inputPath, "") : "";
+    const outputFolder = path.join(output, nestedFolder);
+
+    if (!fs.existsSync(outputFolder)) {
+      fs.mkdirSync(outputFolder, { recursive: true });
+    }
+
+    const outputFileName = outputName || name;
+    const outputFile = path.join(outputFolder, outputFileName + "." + outputExt);
+    console.log({ dir, inputPath, nestedFolder, outputFile });
+
+    const toCheck = [file, outputFile];
+    const noChanges = await checkNoFilesChanged(toCheck, promptHash, hashes);
+    if (noChanges) {
+      console.log("Skipping file", file, "because it hasn't changed");
+      continue;
+    }
+
+    console.log("Writing summary to", outputFile);
+    await writeFile(outputFile, summary);
+
+    await saveAllFileHashes(toCheck, promptHash);
+  }
+}
+
+export async function handleSingleOutputGeneration(
+  model: string,
+  files: string[],
+  prompt: string,
+  outputFile: string,
+  kind?: string,
+  agent?: string
+) {
+  const hashes = await getHashes();
+  const promptHash = crypto.createHash("md5").update(prompt).digest("hex");
+
+  const filesToCheck = [outputFile, ...files];
+  const noChanges = await checkNoFilesChanged(filesToCheck, promptHash, hashes);
+  if (noChanges) {
+    console.log(`Skipping ${files.length} files because they haven't changed`);
+    return;
+  }
+
+  console.log("Summarizing", files.length, "files");
+  const summary = prompt
+    ? await summarizeFiles(files, prompt, model, agent)
+    : (await Promise.all(files.map(convertToText))).join("\n\n");
+
+  const fileHash = crypto.createHash("md5").update(summary).digest("hex");
+
+  console.log("Writing summary to", outputFile);
+  await writeFile(outputFile, summary);
+
+  await saveAllFileHashes(filesToCheck, promptHash);
+}
+
+export async function chat() {
+  const config = await getConfig();
+  const embeddings = await getConfiguredEmbeddings();
+  await chatLoop("knowhow", embeddings, config.plugins);
+}
+
+export async function download() {
+  const config = await getConfig();
+
+  for (const source of config.embedSources) {
+    const { remote, remoteType } = source;
+
+    if (!remoteType) {
+      console.log(
+        "Skipping",
+        source.output,
+        "because no remoteType is configured"
+      );
+      continue;
+    }
+
+    const { name } = path.parse(source.output);
+    const fileName = `${name}.json`;
+    const destinationPath = source.output;
+
+    if (remoteType === "s3") {
+      const bucketName = remote;
+      console.log(
+        "Downloading",
+        fileName,
+        `from ${remoteType}`,
+        bucketName,
+        "to",
+        destinationPath
+      );
+      await AwsS3.downloadFile(bucketName, fileName, destinationPath);
+    } else if (remoteType === "github") {
+      console.log(
+        "Downloading",
+        fileName,
+        "from GitHub repo",
+        remote,
+        "to",
+        destinationPath
+      );
+      const embeddingPath = ".knowhow/embeddings/" + fileName;
+      await GitHub.downloadFile(remote, embeddingPath, destinationPath);
+    } else if (remoteType === "knowhow") {
+      if (!source.remoteId) {
+        throw new Error("remoteId is required for knowhow downloads");
+      }
+      console.log(
+        "Downloading",
+        fileName,
+        "from Knowhow",
+        "to",
+        destinationPath
+      );
+      const preSignedUrl = await knowhowApiClient.getPresignedDownloadUrl(
+        source
+      );
+      await AwsS3.downloadFromPresignedUrl(preSignedUrl, destinationPath);
+    } else {
+      console.log("Unsupported remote type for", source.output);
+    }
+  }
+}

package/src/login.ts

@@ -0,0 +1,78 @@
+import axios from "axios";
+import fs from "fs";
+import path from "path";
+import { chmod } from "fs/promises";
+import { ask } from "./utils";
+
+const API_URL = process.env.KNOWHOW_API_URL;
+
+export async function login(): Promise<void> {
+  if (!API_URL) {
+    throw new Error("Error: KNOWHOW_API_URL environment variable not set.");
+  }
+
+  const [flag] = process.argv.slice(3);
+
+  if (flag === "--jwt") {
+    const jwt = await ask("Enter your JWT: ");
+
+    // Update the JWT file
+    const configDir = path.join(process.cwd(), ".knowhow");
+    const jwtFile = path.join(configDir, ".jwt");
+
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(jwtFile, jwt);
+    fs.chmodSync(jwtFile, 0o600);
+    console.log("JWT updated successfully.");
+  }
+
+  // Get current user/org information
+  try {
+    const storedJwt = await loadJwt();
+    const response = await axios.get(`${API_URL}/api/users/me`, {
+      headers: {
+        Authorization: `Bearer ${storedJwt}`,
+      },
+    });
+    const user = response.data.user;
+    const orgs = user.orgs;
+    const orgId = response.data.orgId;
+
+    const currentOrg = orgs.find((org) => {
+      return org.organizationId === orgId;
+    });
+
+    console.log(
+      `Current user: ${user.email}, \nOrganization: ${currentOrg?.organization?.name} - ${orgId}`
+    );
+  } catch (error) {
+    if (axios.isAxiosError(error) && error.response) {
+      throw new Error(
+        `Error: ${error.response.status} - ${
+          error.response.data.message || "Unknown error"
+        }`
+      );
+    }
+    console.log(
+      "Error: Unable to fetch user information. Please check your JWT and try again.",
+      error
+    );
+  }
+}
+
+export async function loadJwt(): Promise<string> {
+  const jwtFile = path.join(process.cwd(), ".knowhow", ".jwt");
+  if (!fs.existsSync(jwtFile)) {
+    throw new Error("Error: JWT file not found.");
+  }
+
+  const jwt = fs.readFileSync(jwtFile, "utf-8").trim();
+
+  if (!jwt) {
+    throw new Error("Error: JWT is empty. Re-login with knowhow login --jwt.");
+  }
+
+  return jwt;
+}

package/src/microphone.ts

@@ -0,0 +1,136 @@
+import { exec } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { openai } from "./ai";
+import { execAsync, ask } from "./utils";
+import { Downloader } from "./plugins/downloader/downloader";
+import { convertToText, convertAudioToText } from "./conversion";
+
+interface MicrophoneConfig {
+  defaultMic: string | null;
+  micCommand?: string;
+}
+
+const CONFIG_DIR = ".knowhow/tools/microphone";
+const CONFIG_FILE = "config.json";
+const CONFIG_PATH = path.join(CONFIG_DIR, CONFIG_FILE);
+
+function ensureConfigDirectoryExists() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function readMicrophoneConfig(): MicrophoneConfig {
+  ensureConfigDirectoryExists();
+  if (!fs.existsSync(CONFIG_PATH)) {
+    const defaultConfig: MicrophoneConfig = { defaultMic: null };
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(defaultConfig, null, 2));
+    return defaultConfig;
+  }
+  const configContent = fs.readFileSync(CONFIG_PATH, "utf-8");
+  return JSON.parse(configContent);
+}
+
+function writeMicrophoneConfig(config: MicrophoneConfig) {
+  ensureConfigDirectoryExists();
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+export function getDefaultMic(): string | null {
+  const config = readMicrophoneConfig();
+  return config.defaultMic;
+}
+
+export function setDefaultMic(micName: string) {
+  const config = readMicrophoneConfig();
+  config.defaultMic = micName;
+  writeMicrophoneConfig(config);
+}
+
+export function getMicCommand(): string | undefined {
+  const config = readMicrophoneConfig();
+  return config.micCommand;
+}
+
+export function setMicCommand(command: string) {
+  const config = readMicrophoneConfig();
+  config.micCommand = command;
+  writeMicrophoneConfig(config);
+}
+
+export async function listMicrophones() {
+  const regex = /\n\s{8}(\w.*):\n\n/gm;
+
+  const output = await execAsync(
+    `system_profiler SPAudioDataType | grep "Input Source: " -B 7 -A 1`
+  );
+
+  const matches = output.stdout.match(regex) || [];
+
+  const options = matches.map((m) => m.trim().slice(0, -1));
+  console.log({ options });
+
+  return options;
+}
+
+// This isn't likely to work for everyone
+export async function recordAudio() {
+  const filePath = "/tmp/knowhow.wav";
+  const audioFile = fs.createWriteStream(filePath, { encoding: "binary" });
+  const defaultMic = getDefaultMic();
+  const hasSox = await execAsync("which sox");
+
+  if (!hasSox && !defaultMic) {
+    console.error("Sox is required to record audio");
+    console.log(`
+For Mac OS
+brew install sox
+
+For most linux disto's
+sudo apt-get install sox libsox-fmt-all
+`);
+    process.exit(1);
+  }
+
+  if (!defaultMic) {
+    const options = await listMicrophones();
+    const mic = await ask(
+      `Select a microphone (${options.join()})  : `,
+      options
+    );
+    setDefaultMic(mic);
+  }
+
+  const currentDefaultMic = getDefaultMic();
+
+  const defaultCommand = `sox -t coreaudio "$1" -r 16000 -c 1 /tmp/knowhow.wav`;
+  const micCommand = getMicCommand();
+  const defaulted = micCommand || defaultCommand;
+  const recordCommand = defaulted.replace("$1", currentDefaultMic);
+
+  if (!micCommand) {
+    setMicCommand(defaultCommand);
+  }
+
+  const task = exec(recordCommand);
+
+  return { stop: () => task.kill() };
+}
+
+export async function voiceToText() {
+  const input = await ask(
+    "Press Enter to Start Recording, or exit to quit...: "
+  );
+
+  if (input === "exit") {
+    return "voice";
+  }
+
+  const recording = await recordAudio();
+  console.log("Recording audio...");
+  await ask("Press Enter to Stop...");
+  recording.stop();
+  console.log("Stopped recording");
+  return convertAudioToText("/tmp/knowhow.wav", false);
+}

package/src/modules/index.ts

@@ -0,0 +1,37 @@
+import { Clients } from "src/clients";
+import { Plugins } from "src/plugins/plugins";
+import { Agents } from "src/services/AgentService";
+import { Tools } from "src/services/Tools";
+import { getConfig } from "../config";
+import { KnowhowModule } from "./types";
+
+export class ModulesService {
+  async loadModulesFromConfig() {
+    const config = await getConfig();
+
+    const modules = config.modules || [];
+
+    for (const modulePath of modules) {
+      const importedModule = require(modulePath) as KnowhowModule;
+      await importedModule.init({ config, cwd: process.cwd() });
+
+      for (const agent of importedModule.agents) {
+        Agents.registerAgent(agent);
+      }
+
+      for (const tool of importedModule.tools) {
+        Tools.addTool(tool.definition);
+        Tools.setFunction(tool.definition.function.name, tool.handler);
+      }
+
+      for (const plugin of importedModule.plugins) {
+        Plugins.registerPlugin(plugin.name, plugin.plugin);
+      }
+
+      for (const client of importedModule.clients) {
+        Clients.registerClient(client.provider, client.client);
+        Clients.registerModels(client.provider, client.models);
+      }
+    }
+  }
+}

package/src/modules/types.ts

@@ -0,0 +1,48 @@
+import { Plugin } from "../plugins/types";
+import { IAgent } from "../agents/interface";
+import { Tool } from "../clients/types";
+import { Config } from "../types";
+import { GenericClient } from "../clients/types";
+
+/*
+ *
+ * A a module should allow the dynamic composition of npm modules that are installed globally by referencing an array of config
+ *
+ * A module can add new commands to the chat loop, new tools, new agents, new plugins, new clients, new server features etc.
+ *
+ */
+export interface ModuleChatCommand {
+  name: string;
+  description: string;
+  handler: (ctx: any) => void;
+}
+
+export interface ModuleTool {
+  name: string;
+  handler: (...args: any[]) => any;
+  definition: Tool;
+}
+
+export type ModuleAgent = IAgent;
+
+export type ModulePlugin = { name: string; plugin: Plugin };
+
+export type ModuleClient = {
+  client: GenericClient;
+  provider: string;
+  models: string[];
+};
+
+export type InitParams = {
+  config: Config;
+  cwd: string;
+};
+
+export interface KnowhowModule {
+  init: (params: InitParams) => Promise<void>;
+  commands: ModuleChatCommand[];
+  tools: ModuleTool[];
+  agents: ModuleAgent[];
+  plugins: ModulePlugin[];
+  clients: ModuleClient[];
+}