@tyvm/knowhow 0.0.33 → 0.0.35

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/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 {