@tyvm/knowhow 0.0.32 → 0.0.34

package/src/clients/knowhowMcp.ts

@@ -0,0 +1,118 @@
+import {
+  GenericClient,
+  CompletionOptions,
+  CompletionResponse,
+  EmbeddingOptions,
+  EmbeddingResponse,
+} from "./types";
+import { McpService } from "../services/Mcp";
+
+/*
+ *
+ * If an MCP supports the following methods, then we can use it as a generic client.
+ * Once it's a generic client, it can be used by agents, or any other part of the system that leverages Clients
+ */
+export class KnowhowMcpClient implements GenericClient {
+  private mcpService: McpService;
+
+  constructor(mcpService: McpService, private handlesConnection = false) {
+    this.mcpService = mcpService;
+  }
+
+  setKey(key: string) {
+    return;
+  }
+
+  async connect(): Promise<void> {
+    if (this.handlesConnection) {
+      await this.mcpService.connectAll();
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.handlesConnection) {
+      await this.mcpService.closeTransports();
+    }
+  }
+
+  async callFunction<T>(
+    toolName: string,
+    args: Record<string, any>
+  ): Promise<T> {
+    try {
+      await this.connect();
+      const result = await this.mcpService.callFunction<T>(toolName, args);
+      return result as T;
+    } catch (error) {
+      console.error("Error calling MCP function:", toolName, args);
+      console.error(error);
+    } finally {
+      await this.disconnect();
+    }
+  }
+
+  async createChatCompletion(
+    options: CompletionOptions & { provider: string }
+  ): Promise<CompletionResponse> {
+    const data = await this.callFunction<CompletionResponse>(
+      "createAiCompletion",
+      {
+        provider: options.provider || "",
+        options: {
+          ...options,
+          max_tokens: options.max_tokens || 3000,
+
+          ...(options.tools && {
+            tools: options.tools,
+            tool_choice: "auto",
+          }),
+        },
+      }
+    );
+
+    console.log("Completion Response:", JSON.stringify(data, null, 2));
+
+    return data;
+  }
+
+  async createEmbedding(
+    options: EmbeddingOptions & { provider: string }
+  ): Promise<EmbeddingResponse> {
+    return this.callFunction<EmbeddingResponse>("createEmbedding", {
+      provider: options.provider || "",
+      options: {
+        ...options,
+      },
+    });
+  }
+
+  async getModels(): Promise<{ id: string }[]> {
+    try {
+      const parsedResult = await this.callFunction<any>("listAllModels", {});
+      // Convert the models object to the expected format
+      if (typeof parsedResult === "object") {
+        const models: { id: string }[] = [];
+
+        // Handle case where result is already an array of {id: string}
+        if (Array.isArray(parsedResult)) {
+          return parsedResult;
+        }
+
+        // Handle case where result is {provider: [model1, model2]}
+        for (const [provider, modelList] of Object.entries(parsedResult)) {
+          if (Array.isArray(modelList)) {
+            for (const model of modelList) {
+              models.push({ id: `${provider}/${model}` });
+            }
+          }
+        }
+
+        return models;
+      }
+
+      throw new Error("Invalid response format from MCP service");
+    } catch (error) {
+      throw new Error(`Failed to get models via MCP: ${error.message}`);
+    }
+  }
+}

package/src/clients/openai.ts

@@ -17,10 +17,18 @@ import { EmbeddingModels, Models, OpenAiReasoningModels } from "../types";
 
 const config = getConfigSync();
 
-export class GenericOpenAiClient extends OpenAI implements GenericClient {
-  constructor() {
-    super({
-      apiKey: process.env.OPENAI_KEY,
+export class GenericOpenAiClient implements GenericClient {
+  client: OpenAI;
+  apiKey?: string;
+
+  constructor(apiKey = process.env.OPENAI_KEY) {
+    this.setKey(apiKey);
+  }
+
+  setKey(apiKey: string) {
+    this.apiKey = apiKey;
+    this.client = new OpenAI({
+      apiKey,
       ...(config.openaiBaseUrl && { baseURL: config.openaiBaseUrl }),
     });
   }
@@ -40,13 +48,14 @@ export class GenericOpenAiClient extends OpenAI implements GenericClient {
       return msg as ChatCompletionMessageParam;
     });
 
-    const response = await this.chat.completions.create({
+    const response = await this.client.chat.completions.create({
       model: options.model,
       messages: openaiMessages,
       max_tokens: options.max_tokens,
       ...(OpenAiReasoningModels.includes(options.model) && {
         max_tokens: undefined,
-        max_completion_tokens: options.max_tokens,
+        max_completion_tokens: Math.max(options.max_tokens, 100),
+        // Health check requires some thoughts
       }),
 
       ...(options.tools && {
@@ -166,6 +175,21 @@ export class GenericOpenAiClient extends OpenAI implements GenericClient {
         cached_input: 0,
         output: 10.0,
       },
+      [Models.openai.GPT_5]: {
+        input: 1.25,
+        cached_input: 0.125,
+        output: 10,
+      },
+      [Models.openai.GPT_5_Mini]: {
+        input: 0.25,
+        cached_input: 0.025,
+        output: 2,
+      },
+      [Models.openai.GPT_5_Nano]: {
+        input: 0.05,
+        cached_input: 0.005,
+        output: 0.4,
+      },
       /*
        *[Models.openai.Computer_Use]: {
        *  input: 3.0,
@@ -226,7 +250,7 @@ export class GenericOpenAiClient extends OpenAI implements GenericClient {
   }
 
   async getModels() {
-    const models = await this.models.list();
+    const models = await this.client.models.list();
     return models.data.map((m) => {
       return {
         id: m.id,
@@ -237,7 +261,7 @@ export class GenericOpenAiClient extends OpenAI implements GenericClient {
   }
 
   async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
-    const openAiEmbedding = await this.embeddings.create({
+    const openAiEmbedding = await this.client.embeddings.create({
       input: options.input,
       model: options.model,
     });

package/src/clients/types.ts

@@ -85,6 +85,7 @@ export interface EmbeddingResponse {
 }
 
 export interface GenericClient {
+  setKey(key: string): void;
   createChatCompletion(options: CompletionOptions): Promise<CompletionResponse>;
   createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse>;
   getModels(): Promise<{ id: string }[]>;

package/src/clients/xai.ts

@@ -16,10 +16,22 @@ import { Models } from "../types";
 
 const config = getConfigSync();
 
-export class GenericXAIClient extends OpenAI implements GenericClient {
-  constructor() {
-    super({
-      apiKey: process.env.XAI_API_KEY,
+export class GenericXAIClient implements GenericClient {
+  private client: OpenAI;
+  private apiKey: string;
+
+  constructor(apiKey = process.env.XAI_API_KEY) {
+    this.apiKey = apiKey || "";
+    this.client = new OpenAI({
+      apiKey: apiKey || process.env.XAI_API_KEY,
+      baseURL: "https://api.x.ai/v1",
+    });
+  }
+
+  setKey(apiKey: string) {
+    this.apiKey = apiKey;
+    this.client = new OpenAI({
+      apiKey,
       baseURL: "https://api.x.ai/v1",
     });
   }
@@ -39,7 +51,7 @@ export class GenericXAIClient extends OpenAI implements GenericClient {
       return msg as ChatCompletionMessageParam;
     });
 
-    const response = await this.chat.completions.create({
+    const response = await this.client.chat.completions.create({
       model: options.model,
       messages: xaiMessages,
       max_tokens: options.max_tokens,

package/src/config.ts

@@ -73,6 +73,14 @@ const defaultConfig = {
   ],
 
   modelProviders: [{ url: "http://localhost:1234", provider: "lms" }],
+
+  ycmd: {
+    enabled: false,
+    installPath: undefined, // Will default to ~/.knowhow/ycmd
+    port: 0, // 0 for auto-assign
+    logLevel: "info",
+    completionTimeout: 5000,
+  },
 } as Config;
 
 const defaultLanguage = {
@@ -148,6 +156,14 @@ export async function updateLanguageConfig(language: Language) {
 }
 
 export async function updateConfig(config: Config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Invalid config object");
+  }
+
+  await fs.promises.copyFile(
+    ".knowhow/knowhow.json",
+    ".knowhow/knowhow.json.bak"
+  );
   await writeFile(".knowhow/knowhow.json", JSON.stringify(config, null, 2));
 }
 
@@ -185,15 +201,24 @@ export function getConfigSync() {
   }
 }
 
+let loggedWarning = false;
 export async function getConfig() {
   if (!fs.existsSync(".knowhow/knowhow.json")) {
-    console.warn(
-      "KnowHow config file not found. Please run `knowhow init` to create it."
-    );
+    if (!loggedWarning) {
+      loggedWarning = true;
+      console.warn(
+        "KnowHow config file not found. Please run `knowhow init` to create it."
+      );
+    }
     return {} as Config;
   }
-  const config = JSON.parse(await readFile(".knowhow/knowhow.json", "utf8"));
-  return config as Config;
+  try {
+    const config = await readFile(".knowhow/knowhow.json", "utf8");
+    return JSON.parse(config) as Config;
+  } catch (error) {
+    console.error("Error reading .knowhow/knowhow.json:", error);
+    throw new Error("Failed to load KnowHow configuration.");
+  }
 }
 
 export async function loadPrompt(promptName: string) {

package/src/conversion.ts

@@ -2,7 +2,7 @@ import pdf from "pdf-parse";
 import * as fs from "fs";
 import * as path from "path";
 import { readFile, fileExists } from "./utils";
-import { Downloader } from "./plugins/downloader/downloader";
+import { services } from "./services";
 
 export async function processAudio(
   filePath: string,
@@ -21,6 +21,7 @@ export async function processAudio(
       : JSON.parse(fileContent);
   }
 
+  const { Downloader } = services();
   const chunks = await Downloader.chunk(
     filePath,
     parsed.dir,
@@ -73,9 +74,11 @@ export async function processVideo(
   );
 
   console.log("Extracting keyframes...");
+  const { Downloader } = services();
   const videoAnalysis = await Downloader.extractKeyframes(
     filePath,
     outputPath,
+    reusePreviousTranscript,
     chunkTime
   );
 

package/src/embeddings.ts

@@ -71,6 +71,46 @@ function getChunkId(id: string, index: number, chunkSize: number) {
   return chunkSize ? `${id}-${index}` : id;
 }
 
+function parseIdFromChunk(chunkName: string) {
+  const split = chunkName.split("-");
+  if (
+    split.length > 1 &&
+    Number.isInteger(parseInt(split[split.length - 1], 10))
+  ) {
+    // already has chunkId
+    return split.slice(0, -1).join("-");
+  }
+  return chunkName;
+}
+
+export async function detectDeletedEmbeddingFiles(
+  source: Config["embedSources"][0],
+  ignorePattern: string[],
+  embeddings: Embeddable[]
+) {
+  if (source.kind !== "file") {
+    return;
+  }
+  const inputs = (await glob.sync(source.input, {
+    ignore: ignorePattern,
+  })) as string[];
+
+  for (const embedding of embeddings) {
+    const id = parseIdFromChunk(embedding.id);
+    const dirName = path.dirname(id);
+    const exists = await fileExists(path.resolve(id));
+
+    const hasSomeFilesInDir = inputs.some((input) => input.startsWith(dirName));
+    if (hasSomeFilesInDir && !exists) {
+      console.log("Detected deleted embedding file", embedding.id);
+      const index = embeddings.findIndex((e) => e.id === embedding.id);
+      if (index !== -1) {
+        embeddings.splice(index, 1);
+      }
+    }
+  }
+}
+
 export async function embedSource(
   model: Config["embeddingModel"],
   source: Config["embedSources"][0],
@@ -97,10 +137,8 @@ export async function embedSource(
   }
 
   console.log(`Found ${inputs.length} files`);
-  if (inputs.length > 100) {
-    console.error(
-      "woah there, that's a lot of files. I'm not going to embed that many"
-    );
+  if (inputs.length > 1000) {
+    console.error("Large number of files detected. This may take a while");
   }
   console.log(inputs);
   const embeddings: Embeddable[] = await loadEmbedding(source.output);
@@ -108,18 +146,20 @@ export async function embedSource(
   let index = 0;
   for (const file of inputs) {
     index++;
-    const shouldSave = batch.length > 20 || index === inputs.length;
+    const shouldSave = batch.length > 20;
     if (shouldSave) {
       await Promise.all(batch);
+      await saveEmbedding(source.output, embeddings);
       batch = [];
     }
-    batch.push(embedKind(model, file, source, embeddings, shouldSave));
+    batch.push(embedKind(model, file, source, embeddings));
   }
   if (batch.length > 0) {
     await Promise.all(batch);
   }
 
   // Save one last time just in case
+  await detectDeletedEmbeddingFiles(source, ignorePattern, embeddings);
   await saveEmbedding(source.output, embeddings);
 }
 
@@ -165,9 +205,31 @@ export async function embed(
     }
 
     dontPrune.push(chunkId);
-    const alreadyEmbedded = embeddings.find(
-      (e) => e.id === chunkId && e.text === textOfChunk
-    );
+    const foundMany = embeddings.filter((e) => e.id === chunkId);
+    const found = foundMany.length > 0 ? foundMany[0] : null;
+    const alreadyEmbedded = found && found.text === textOfChunk;
+
+    if (foundMany.length > 1) {
+      // We have duplicates, so we need to remove them
+      console.log(`Removing ${foundMany.length} duplicates for`, chunkId);
+
+      let toDelete = embeddings.findIndex((e) => e.id === chunkId);
+      while (toDelete !== -1) {
+        // Keep removing until we find no more duplicates
+        embeddings.splice(toDelete, 1);
+        toDelete = embeddings.findIndex((e) => e.id === chunkId);
+      }
+
+      if (alreadyEmbedded) {
+        // Put back the exact match of the current chunk
+        // if this doesn't happen, we need to generate a new embedding
+        embeddings.push({
+          ...found,
+        });
+        updates.push(chunkId);
+      }
+    }
+
     if (alreadyEmbedded) {
       console.log("Skipping", chunkId);
       continue;
@@ -235,7 +297,7 @@ export async function embedJson(
   ) as Embeddable[];
 
   const embeddings: Embeddable[] = await loadEmbedding(output);
-  let updates = [];
+  const updates = [];
   let batch = [];
 
   for (const row of sourceJson) {
@@ -264,24 +326,17 @@ export async function embedJson(
       batch = [];
     }
     updates.push(...embedded);
-
-    if (updates.length > 20) {
-      await saveEmbedding(output, embeddings);
-      updates = [];
-    }
   }
 
   // save in case we missed some
   await Promise.all(batch);
-  await saveEmbedding(output, embeddings);
 }
 
 export async function embedKind(
   model: Config["embeddingModel"],
   id: string,
   source: Config["embedSources"][0],
-  embeddings = [] as Embeddable[],
-  save = true
+  embeddings = [] as Embeddable[]
 ) {
   const { prompt, output, uploadMode, chunkSize } = source;
 
@@ -312,10 +367,6 @@ export async function embedKind(
     );
     updates.push(...embedded);
   }
-
-  if (save && updates.length > 0) {
-    await saveEmbedding(output, embeddings);
-  }
 }
 
 async function handleFileKind(filePath: string) {
@@ -367,7 +418,12 @@ export async function handleAllKinds(
 
 export async function saveEmbedding(output: string, embeddings: Embeddable[]) {
   const fileString =
-    "[" + embeddings.map((e) => JSON.stringify(e)).join(",") + "]";
+    "[" +
+    embeddings
+      .sort((a, b) => (a.id < b.id ? -1 : 1))
+      .map((e) => JSON.stringify(e))
+      .join(",") +
+    "]";
   await writeFile(output, fileString);
 }
 

package/src/login.ts

@@ -3,22 +3,20 @@ import fs from "fs";
 import path from "path";
 import { chmod } from "fs/promises";
 import { ask } from "./utils";
+import { getConfig, updateConfig } from "./config";
+import { KNOWHOW_API_URL } from "./services/KnowhowClient";
 
-const API_URL = process.env.KNOWHOW_API_URL;
-
-export async function login(): Promise<void> {
-  if (!API_URL) {
+export async function login(jwtFlag?: string): Promise<void> {
+  if (!KNOWHOW_API_URL) {
     throw new Error("Error: KNOWHOW_API_URL environment variable not set.");
   }
 
-  const [flag] = process.argv.slice(3);
-
-  if (flag === "--jwt") {
+  if (jwtFlag) {
     const jwt = await ask("Enter your JWT: ");
 
     // Update the JWT file
     const configDir = path.join(process.cwd(), ".knowhow");
-    const jwtFile = path.join(configDir, ".jwt");
+    const jwtFile = path.join(process.cwd(), ".knowhow", ".jwt");
 
     if (!fs.existsSync(configDir)) {
       fs.mkdirSync(configDir, { recursive: true });
@@ -31,7 +29,7 @@ export async function login(): Promise<void> {
   // Get current user/org information
   try {
     const storedJwt = await loadJwt();
-    const response = await axios.get(`${API_URL}/api/users/me`, {
+    const response = await axios.get(`${KNOWHOW_API_URL}/api/users/me`, {
       headers: {
         Authorization: `Bearer ${storedJwt}`,
       },
@@ -47,6 +45,25 @@ export async function login(): Promise<void> {
     console.log(
       `Current user: ${user.email}, \nOrganization: ${currentOrg?.organization?.name} - ${orgId}`
     );
+
+    const config = await getConfig();
+    const proxyUrl = KNOWHOW_API_URL + "/api/proxy";
+    const hasProvider = config.modelProviders.find(
+      (provider) => provider.provider === "knowhow" && provider.url === proxyUrl
+    );
+    if (!hasProvider) {
+      if (!config.modelProviders) {
+        config.modelProviders = [];
+      }
+
+      config.modelProviders.push({
+        provider: "knowhow",
+        url: proxyUrl,
+        jwtFile: ".knowhow/.jwt",
+      });
+
+      await updateConfig(config);
+    }
   } catch (error) {
     if (axios.isAxiosError(error) && error.response) {
       throw new Error(

package/src/microphone.ts

@@ -3,7 +3,6 @@ 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 {