@tyvm/knowhow 0.0.48 → 0.0.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {

package/src/agents/base/base.ts

@@ -31,6 +31,11 @@ export interface AgentContext {
   Clients?: AIClient;
 }
 
+export interface ToolCallEvent {
+  toolCall: ToolCall;
+  functionResp: any;
+}
+
 export abstract class BaseAgent implements IAgent {
   abstract name: string;
   abstract description: string;
@@ -62,7 +67,8 @@ export abstract class BaseAgent implements IAgent {
     newThread: "new_thread",
     threadUpdate: "thread_update",
     costUpdate: "cost_update",
-    toolUsed: "tool_used",
+    toolCall: "tool:pre_call",
+    toolUsed: "tool:post_call",
     done: "done",
     pause: "pause",
     kill: "kill",
@@ -294,6 +300,8 @@ export abstract class BaseAgent implements IAgent {
   abstract getInitialMessages(userInput: string): Promise<Message[]>;
 
   async processToolMessages(toolCall: ToolCall) {
+    this.agentEvents.emit(this.eventTypes.toolCall, { toolCall });
+
     const { functionResp, toolMessages } = await this.tools.callTool(
       toolCall,
       this.getEnabledToolNames()

package/src/auth/browserLogin.ts

@@ -253,17 +253,17 @@ export function validateJwt(jwt: string): boolean {
 
   // If this looks like a real JWT (contains base64-like characters), validate it strictly
   const looksLikeRealJwt = parts.every(part => /^[A-Za-z0-9+/\-_]+={0,2}$/.test(part));
-  
+
   if (looksLikeRealJwt) {
     // Strict validation for real JWTs
     try {
       // Try to decode header and payload as valid JSON
       JSON.parse(Buffer.from(parts[0], "base64").toString());
       JSON.parse(Buffer.from(parts[1], "base64").toString());
-      
+
       // Try to decode signature - should be valid base64 with reasonable length
       const signature = Buffer.from(parts[2], "base64");
-      
+
       // JWT signatures are typically at least 32 bytes (256 bits)
       if (signature.length < 32) {
         return false;
@@ -273,7 +273,7 @@ export function validateJwt(jwt: string): boolean {
       return false;
     }
   }
-  
+
   // For simple test cases like 'part1.part2.part3', just check basic structure
   try {
     return true;

package/src/chat/modules/AgentModule.ts

@@ -20,6 +20,7 @@ import {
 } from "../../processors/index";
 import { TaskInfo, ChatSession } from "../types";
 import { agents } from "../../agents";
+import { ToolCallEvent } from "src/agents/base/base";
 
 export class AgentModule extends BaseChatModule {
   name = "agent";
@@ -719,10 +720,28 @@ ${reason}
       ]);
 
       // Set up event listeners
+      if (!agent.agentEvents.listenerCount(agent.eventTypes.toolCall)) {
+        agent.agentEvents.on(
+          agent.eventTypes.toolCall,
+          (responseMsg: ToolCallEvent) => {
+            console.time(JSON.stringify(responseMsg.toolCall.function.name));
+            console.log(
+              ` 🔨 Tool: ${responseMsg.toolCall.function.name}\n Args: ${responseMsg.toolCall.function.arguments}\n`
+            );
+          }
+        );
+      }
       if (!agent.agentEvents.listenerCount(agent.eventTypes.toolUsed)) {
-        agent.agentEvents.on(agent.eventTypes.toolUsed, (responseMsg) => {
-          console.log(` 🔨 Tool used: ${JSON.stringify(responseMsg, null, 2)}`);
-        });
+        agent.agentEvents.on(
+          agent.eventTypes.toolUsed,
+          (responseMsg: ToolCallEvent) => {
+            console.timeEnd(JSON.stringify(responseMsg.toolCall.function.name));
+            console.log(
+              ` 🔨 Tool Response:
+              ${JSON.stringify(responseMsg.functionResp, null, 2)}`
+            );
+          }
+        );
       }
 
       const taskCompleted = new Promise<string>((resolve) => {

package/src/embeddings.ts

@@ -136,11 +136,10 @@ export async function embedSource(
     inputs = [source.input];
   }
 
-  console.log(`Found ${inputs.length} files`);
+  console.log(`Checking ${inputs.length} files`);
   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);
   let batch = [];
   let index = 0;
@@ -231,7 +230,6 @@ export async function embed(
     }
 
     if (alreadyEmbedded) {
-      console.log("Skipping", chunkId);
       continue;
     }
 
@@ -468,7 +466,7 @@ export async function queryEmbedding<E>(
   model = EmbeddingModels.openai.EmbeddingAda2
 ) {
   const providerEmbeddings = await Clients.createEmbedding("", {
-    input: takeFirstNWords(query, 5000),
+    input: takeFirstNWords(query, 5000).slice(0, 16000),
     model,
   });
   const queryVector = providerEmbeddings.data[0].embedding;

package/src/login.ts

@@ -42,33 +42,19 @@ export async function login(jwtFlag?: boolean): Promise<void> {
   // Get current user/org information
   try {
     const storedJwt = await loadJwt();
-    const response = await axios.get(`${KNOWHOW_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}`
-    );
+    await checkJwt(storedJwt);
 
     const config = await getConfig();
     const proxyUrl = KNOWHOW_API_URL + "/api/proxy";
+
+    if (!config.modelProviders) {
+      config.modelProviders = [];
+    }
+
     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,
@@ -106,3 +92,24 @@ export async function loadJwt(): Promise<string> {
 
   return jwt;
 }
+
+export async function checkJwt(storedJwt: string) {
+  const response = await axios.get(`${KNOWHOW_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}`
+  );
+
+  return { user, currentOrg };
+}

package/src/plugins/GitPlugin.ts

@@ -92,12 +92,17 @@ Your modifications are automatically tracked separately and won't affect the use
           "# Knowhow agent tracking repository\n"
         );
 
-        const hasChanges = await this.hasChanges();
-        if (hasChanges) {
-          this.commit("Initial commit for agent tracking, with changes");
-        } else {
+        // For initial commit, we need to add files and commit directly
+        // since HEAD doesn't exist yet
+        try {
+          this.gitCommand("add -A");
+          this.gitCommand(
+            'commit -m "Initial commit for agent tracking"'
+          );
+        } catch (error) {
+          // If there's nothing to commit, create an empty commit
           this.gitCommand(
-            'commit --allow-empty -m "Initial commit for agent tracking, no changes"'
+            'commit --allow-empty -m "Initial commit for agent tracking"'
           );
         }
       }

package/src/processors/CustomVariables.ts

@@ -101,18 +101,24 @@ export class CustomVariables {
    */
   private listVariables(): string {
     const variableNames = Object.keys(this.variables);
-    
+
     if (variableNames.length === 0) {
       return "No variables are currently stored.";
     }
 
-    const variableList = variableNames.map(name => {
-      const value = this.variables[name];
-      const preview = typeof value === "string" 
-        ? (value.length > 50 ? value.substring(0, 50) + "..." : value)
-        : JSON.stringify(value).substring(0, 50) + (JSON.stringify(value).length > 50 ? "..." : "");
-      return `- ${name}: ${preview}`;
-    }).join("\n");
+    const variableList = variableNames
+      .map((name) => {
+        const value = this.variables[name];
+        const preview =
+          typeof value === "string"
+            ? value.length > 50
+              ? value.substring(0, 50) + "..."
+              : value
+            : JSON.stringify(value).substring(0, 50) +
+              (JSON.stringify(value).length > 50 ? "..." : "");
+        return `- ${name}: ${preview}`;
+      })
+      .join("\n");
 
     return `Currently stored variables (${variableNames.length}):\n${variableList}`;
   }
@@ -146,17 +152,17 @@ export class CustomVariables {
       // Check if ALL variables are undefined - if so, return just the error message for the first one
       const variableMatches = value.match(/\{\{([a-zA-Z0-9_]+)\}\}/g);
       if (variableMatches) {
-        const allUndefined = variableMatches.every(match => {
-          const varName = match.replace(/[{}]/g, '');
+        const allUndefined = variableMatches.every((match) => {
+          const varName = match.replace(/[{}]/g, "");
           return !(varName in this.variables);
         });
-        
+
         if (allUndefined && variableMatches.length > 0) {
-          const firstUndefinedVar = variableMatches[0].replace(/[{}]/g, '');
+          const firstUndefinedVar = variableMatches[0].replace(/[{}]/g, "");
           return `{{ERROR: Variable "${firstUndefinedVar}" is not defined}}`;
         }
       }
-      
+
       // Otherwise, proceed with partial substitution
       return value.replace(/\{\{([a-zA-Z0-9_]+)\}\}/g, (match, varName) => {
         // Prevent infinite recursion
@@ -251,62 +257,34 @@ export class CustomVariables {
    */
   private registerTools(toolsService: ToolsService): void {
     // Register setVariable tool
-    if (!toolsService.getTool(this.setVariableToolName)) {
-      toolsService.addTool(setVariableToolDefinition);
-      toolsService.addFunctions({
-        [this.setVariableToolName]: (name: string, contents: any) => {
-          return this.setVariable(name, contents);
-        },
-      });
-    }
-
-    // Register getVariable tool
-    if (!toolsService.getTool(this.getVariableToolName)) {
-      toolsService.addTool(getVariableToolDefinition);
-      toolsService.addFunctions({
-        [this.getVariableToolName]: (varName: string) => {
-          return this.getVariable(varName);
-        },
-      });
-    }
-
-    // Register storeToolCallToVariable tool
-    if (!toolsService.getTool(this.storeToolCallToolName)) {
-      toolsService.addTool(storeToolCallToVariableDefinition);
-      toolsService.addFunctions({
-        [this.storeToolCallToolName]: async (
-          varName: string,
-          toolName: string,
-          toolArgs: string
-        ) => {
-          return await this.storeToolCallToVariable(
-            varName,
-            toolName,
-            toolArgs
-          );
-        },
-      });
-    }
-
-    // Register listVariables tool
-    if (!toolsService.getTool(this.listVariablesToolName)) {
-      toolsService.addTool(listVariablesToolDefinition);
-      toolsService.addFunctions({
-        [this.listVariablesToolName]: () => {
-          return this.listVariables();
-        },
-      });
-    }
-
-    // Register deleteVariable tool
-    if (!toolsService.getTool(this.deleteVariableToolName)) {
-      toolsService.addTool(deleteVariableToolDefinition);
-      toolsService.addFunctions({
-        [this.deleteVariableToolName]: (varName: string) => {
-          return this.deleteVariable(varName);
-        },
-      });
-    }
+    toolsService.addTools([
+      setVariableToolDefinition,
+      getVariableToolDefinition,
+      storeToolCallToVariableDefinition,
+      listVariablesToolDefinition,
+      deleteVariableToolDefinition,
+    ]);
+    toolsService.addFunctions({
+      [this.setVariableToolName]: (name: string, contents: any) => {
+        return this.setVariable(name, contents);
+      },
+      [this.getVariableToolName]: (varName: string) => {
+        return this.getVariable(varName);
+      },
+      [this.storeToolCallToolName]: async (
+        varName: string,
+        toolName: string,
+        toolArgs: string
+      ) => {
+        return await this.storeToolCallToVariable(varName, toolName, toolArgs);
+      },
+      [this.listVariablesToolName]: () => {
+        return this.listVariables();
+      },
+      [this.deleteVariableToolName]: (varName: string) => {
+        return this.deleteVariable(varName);
+      },
+    });
   }
 
   /**
@@ -434,4 +412,4 @@ export const deleteVariableToolDefinition: Tool = {
       required: ["varName"],
     },
   },
-};
+};

package/src/processors/TokenCompressor.ts

@@ -116,8 +116,9 @@ export class TokenCompressor {
 
     // For nested properties (path !== ""), use maxTokens to avoid recompressing stored data
     // For top-level content (path === ""), use compressionThreshold to determine compression
-    const thresholdToUse = path === "" ? this.compressionThreshold : this.maxTokens;
-    
+    const thresholdToUse =
+      path === "" ? this.compressionThreshold : this.maxTokens;
+
     if (tokens <= thresholdToUse) {
       return content;
     }
@@ -320,8 +321,8 @@ export class TokenCompressor {
   }
 
   registerTool(toolsService?: ToolsService): void {
-    if (toolsService && !toolsService.getTool(this.toolName)) {
-      toolsService.addTool(expandTokensDefinition);
+    if (toolsService) {
+      toolsService.addTools([expandTokensDefinition]);
       toolsService.addFunctions({
         [this.toolName]: (key: string) => {
           const data = this.retrieveString(key);

package/src/processors/ToolResponseCache.ts

@@ -130,7 +130,6 @@ export class ToolResponseCache {
     }
 
     try {
-      
       // First parse the stored string as JSON, then handle nested JSON strings
       const jsonData = this.tryParseJson(data);
       if (!jsonData) {
@@ -207,14 +206,12 @@ export class ToolResponseCache {
    * Registers the jqToolResponse tool with the ToolsService
    */
   registerTool(toolsService: ToolsService): void {
-    if (!toolsService.getTool(this.toolName)) {
-      toolsService.addTool(jqToolResponseDefinition);
-      toolsService.addFunctions({
-        [this.toolName]: async (toolCallId: string, jqQuery: string) => {
-          return await this.queryToolResponse(toolCallId, jqQuery);
-        },
-      });
-    }
+    toolsService.addTools([jqToolResponseDefinition]);
+    toolsService.addFunctions({
+      [this.toolName]: async (toolCallId: string, jqQuery: string) => {
+        return await this.queryToolResponse(toolCallId, jqQuery);
+      },
+    });
   }
 }
 

package/src/services/KnowhowClient.ts

@@ -38,7 +38,9 @@ export function loadKnowhowJwt(): string {
   if (!fs.existsSync(jwtFile)) {
     return "";
   }
-  return fs.readFileSync(jwtFile, "utf-8").trim();
+  const jwt = fs.readFileSync(jwtFile, "utf-8").trim();
+
+  return jwt;
 }
 
 export const KNOWHOW_API_URL =
@@ -46,6 +48,7 @@ export const KNOWHOW_API_URL =
 
 export class KnowhowSimpleClient {
   headers = {};
+  jwtValidated = false;
 
   constructor(private baseUrl, private jwt = loadKnowhowJwt()) {
     this.setJwt(jwt);
@@ -58,21 +61,45 @@ export class KnowhowSimpleClient {
     };
   }
 
-  checkJwt() {
+  async checkJwt() {
     if (!this.jwt) {
       throw new Error("No JWT found. Please login first.");
     }
+
+    if (!this.jwtValidated) {
+      try {
+        this.jwtValidated = true;
+        const response = await this.me();
+
+        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) {
+        throw new Error("Invalid JWT. Please login again.");
+      }
+    }
   }
 
-  me() {
-    this.checkJwt();
+  async me() {
+    if (!this.jwt) {
+      throw new Error("No JWT found. Please login first.");
+    }
+
     return axios.get(`${this.baseUrl}/api/users/me`, {
       headers: this.headers,
     });
   }
 
   async getPresignedUploadUrl(source: Config["embedSources"][0]) {
-    this.checkJwt();
+    await this.checkJwt();
     const id = source.remoteId;
     const presignedUrlResp = await axios.post(
       `${this.baseUrl}/api/org-embeddings/${id}/upload`,
@@ -89,7 +116,7 @@ export class KnowhowSimpleClient {
   }
 
   async getPresignedDownloadUrl(source: Config["embedSources"][0]) {
-    this.checkJwt();
+    await this.checkJwt();
     const id = source.remoteId;
     const presignedUrlResp = await axios.post(
       `${this.baseUrl}/api/org-embeddings/${id}/download`,
@@ -103,8 +130,8 @@ export class KnowhowSimpleClient {
     return presignedUrl;
   }
 
-  createChatCompletion(options: CompletionOptions) {
-    this.checkJwt();
+  async createChatCompletion(options: CompletionOptions) {
+    await this.checkJwt();
     return axios.post<CompletionResponse>(
       `${this.baseUrl}/api/proxy/v1/chat/completions`,
       options,
@@ -114,8 +141,8 @@ export class KnowhowSimpleClient {
     );
   }
 
-  createEmbedding(options: EmbeddingOptions) {
-    this.checkJwt();
+  async createEmbedding(options: EmbeddingOptions) {
+    await this.checkJwt();
     return axios.post<EmbeddingResponse>(
       `${this.baseUrl}/api/proxy/v1/embeddings`,
       options,
@@ -125,15 +152,15 @@ export class KnowhowSimpleClient {
     );
   }
 
-  getModels() {
-    this.checkJwt();
+  async getModels() {
+    await this.checkJwt();
     return axios.get(`${this.baseUrl}/api/proxy/v1/models?type=all`, {
       headers: this.headers,
     });
   }
 
-  createChatTask(request: CreateMessageTaskRequest) {
-    this.checkJwt();
+  async createChatTask(request: CreateMessageTaskRequest) {
+    await this.checkJwt();
     return axios.post<CreateMessageTaskResponse>(
       `${this.baseUrl}/api/chat/tasks`,
       request,
@@ -143,8 +170,8 @@ export class KnowhowSimpleClient {
     );
   }
 
-  updateChatTask(taskId: string, updates: UpdateOrgTaskRequest) {
-    this.checkJwt();
+  async updateChatTask(taskId: string, updates: UpdateOrgTaskRequest) {
+    await this.checkJwt();
     return axios.put<UpdateOrgTaskResponse>(
       `${this.baseUrl}/api/chat/tasks/${taskId}`,
       updates,