@tyvm/knowhow 0.0.47 → 0.0.48

package/src/plugins/tree-sitter/simple-paths.ts

@@ -0,0 +1,467 @@
+import { LanguageAgnosticParser, SyntaxNode, Tree } from "./parser";
+import { getLanguagePack, LanguagePackConfig } from "./lang-packs";
+import { Query } from "tree-sitter";
+
+export interface SimplePathMatch {
+  node: SyntaxNode;
+  path: string;
+  simplePath: string;
+  description: string;
+}
+
+export class SimplePathResolver {
+  private parser: LanguageAgnosticParser;
+  private languagePack: LanguagePackConfig;
+
+  constructor(parser: LanguageAgnosticParser) {
+    this.parser = parser;
+    this.languagePack = parser.getLanguagePack();
+  }
+
+  /**
+   * Execute a tree-sitter query and return matches with capture names
+   */
+  private executeQuery(
+    tree: Tree,
+    queryString: string
+  ): { node: SyntaxNode; captures: Record<string, SyntaxNode> }[] {
+    try {
+      const language = this.parser.parser.getLanguage(); // Access internal parser
+      if (!language) return [];
+
+      const query = new Query(language, queryString);
+      const matches = query.matches(tree.rootNode);
+
+      return matches.map((match) => {
+        const captures: Record<string, SyntaxNode> = {};
+        for (const capture of match.captures) {
+          captures[capture.name] = capture.node;
+        }
+        return {
+          node: match.captures[0]?.node, // Main node
+          captures,
+        };
+      });
+    } catch (error) {
+      console.warn("Failed to execute tree-sitter query:", error);
+      console.warn("Query that failed:", JSON.stringify(queryString));
+      return [];
+    }
+  }
+  /**
+   * Find all nodes of a specific type using the language pack
+   */
+  private findNodesByQuery(
+    tree: Tree,
+    queryType: keyof LanguagePackConfig["queries"]
+  ): { node: SyntaxNode; captures: Record<string, SyntaxNode> }[] {
+    if (!this.languagePack || !this.languagePack.queries[queryType]) {
+      return [];
+    }
+    return this.executeQuery(tree, this.languagePack.queries[queryType]);
+  }
+
+  /**
+   * Parse a path to detect block syntax like describe("name") vs regular paths
+   */
+  private parseSimplePath(simplePath: string): {
+    type: "block" | "regular";
+    functionName?: string;
+    argument?: string;
+    parts: string[];
+  } {
+    // Check for function call syntax like describe("name") or test("should work")
+    const blockPattern = /^(\w+)\s*\(\s*["'`]([^"'`]*)["'`]\s*\)$/;
+    const blockMatch = simplePath.match(blockPattern);
+
+    if (blockMatch) {
+      return {
+        type: "block",
+        functionName: blockMatch[1],
+        argument: blockMatch[2],
+        parts: [blockMatch[1]],
+      };
+    }
+
+    // Check for parameterless function calls like beforeEach()
+    const parameterlessBlockPattern = /^(\w+)\s*\(\s*\)$/;
+    const parameterlessMatch = simplePath.match(parameterlessBlockPattern);
+
+    if (parameterlessMatch) {
+      return {
+        type: "block",
+        functionName: parameterlessMatch[1],
+        parts: [parameterlessMatch[1]],
+      };
+    }
+
+    // Regular path like "ClassName.methodName" or just "name"
+    return {
+      type: "regular",
+      parts: simplePath.split("."),
+    };
+  }
+  /**
+   * Find block matches for syntax like describe("name") or beforeEach()
+   */
+  private findBlockMatches(
+    tree: Tree,
+    functionName: string,
+    argument: string | undefined,
+    simplePath: string
+  ): SimplePathMatch[] {
+    const matches: SimplePathMatch[] = [];
+    const blockMatches = this.findNodesByQuery(tree, "blocks");
+
+    for (const match of blockMatches) {
+      const calleeNode = match.captures.callee;
+      const nameNode = match.captures.name;
+
+      if (!calleeNode || calleeNode.text !== functionName) {
+        continue;
+      }
+
+      // For parameterless blocks like beforeEach(), just match the function name
+      if (!argument) {
+        matches.push({
+          node: match.node,
+          path: this.getNodePath(tree.rootNode, match.node),
+          simplePath,
+          description: `${functionName} block`,
+        });
+        continue;
+      }
+
+      // For blocks with arguments, match the argument text
+      if (nameNode) {
+        // Extract string content from quotes
+        let nameText = nameNode.text;
+        if (
+          (nameText.startsWith('"') && nameText.endsWith('"')) ||
+          (nameText.startsWith("'") && nameText.endsWith("'")) ||
+          (nameText.startsWith("`") && nameText.endsWith("`"))
+        ) {
+          nameText = nameText.slice(1, -1);
+        }
+
+        if (nameText === argument) {
+          matches.push({
+            node: match.node,
+            path: this.getNodePath(tree.rootNode, match.node),
+            simplePath,
+            description: `${functionName} block: ${argument}`,
+          });
+        }
+      }
+    }
+
+    return matches;
+  }
+  /**
+   * Find nodes using human-readable paths like:
+   * - "ClassName.methodName" - finds a method in a class
+   * - "ClassName" - finds a class declaration
+   * - "methodName" - finds any method with that name
+   * - "ClassName.propertyName" - finds a property in a class
+   * - "describe(\"test name\")" - finds a describe block
+   */
+  findBySimplePath(tree: Tree, simplePath: string): SimplePathMatch[] {
+    if (!tree.rootNode) {
+      return [];
+    }
+
+    const matches: SimplePathMatch[] = [];
+    const pathInfo = this.parseSimplePath(simplePath);
+    const parts = pathInfo.parts;
+
+    // Handle block syntax like describe("Authentication") or beforeEach()
+    if (pathInfo.type === "block") {
+      return this.findBlockMatches(
+        tree,
+        pathInfo.functionName!,
+        pathInfo.argument,
+        simplePath
+      );
+    }
+
+    if (parts.length === 1) {
+      // Single part - could be class, method, or property
+      const singleName = parts[0];
+
+      // Check for classes
+      const classMatches = this.findNodesByQuery(tree, "classes");
+      for (const match of classMatches) {
+        const nameNode = match.captures.name;
+        if (nameNode && nameNode.text === singleName) {
+          matches.push({
+            node: match.node,
+            path: this.getNodePath(tree.rootNode, match.node),
+            simplePath,
+            description: `Class declaration: ${singleName}`,
+          });
+        }
+      }
+      // Check for methods
+      const methodMatches = this.findNodesByQuery(tree, "methods");
+      for (const match of methodMatches) {
+        const nameNode = match.captures.name;
+        if (nameNode && nameNode.text === singleName) {
+          const className = this.findContainingClassName(tree, match.node);
+          const description = className
+            ? `${singleName} method in class ${className}`
+            : `Method declaration: ${singleName}`;
+          matches.push({
+            node: match.node,
+            path: this.getNodePath(tree.rootNode, match.node),
+            simplePath,
+            description,
+          });
+        }
+      }
+
+      // Check for properties
+      const propertyMatches = this.findNodesByQuery(tree, "properties");
+      for (const match of propertyMatches) {
+        const nameNode = match.captures.name;
+        if (nameNode && nameNode.text === singleName) {
+          matches.push({
+            node: match.node,
+            path: this.getNodePath(tree.rootNode, match.node),
+            simplePath,
+            description: `Property declaration: ${singleName}`,
+          });
+        }
+      }
+
+      // Check for generic blocks like describe(), test(), it(), etc.
+      const blockMatches = this.findNodesByQuery(tree, "blocks");
+      for (const match of blockMatches) {
+        const calleeNode = match.captures.callee;
+        const nameNode = match.captures.name;
+
+        // Check if this is a parameterless call matching the search term
+        if (calleeNode && calleeNode.text === singleName) {
+          matches.push({
+            node: match.node,
+            path: this.getNodePath(tree.rootNode, match.node),
+            simplePath,
+            description: `${singleName} block`,
+          });
+          continue;
+        }
+
+        if (nameNode && nameNode.text === singleName && calleeNode) {
+          matches.push({
+            node: match.node,
+            path: this.getNodePath(tree.rootNode, match.node),
+            simplePath,
+            description: `${calleeNode.text} block: ${singleName}`,
+          });
+        }
+      }
+    } else if (parts.length === 2) {
+      const [className, memberName] = parts;
+      // Find classes with the given name
+      const classMatches = this.findNodesByQuery(tree, "classes");
+      for (const classMatch of classMatches) {
+        const classNameNode = classMatch.captures.name;
+        if (classNameNode && classNameNode.text === className) {
+          // Look for methods in this class
+          const methodMatches = this.findNodesByQuery(tree, "methods");
+          for (const methodMatch of methodMatches) {
+            const methodNameNode = methodMatch.captures.name;
+            if (methodNameNode && methodNameNode.text === memberName) {
+              // Check if this method is within the target class
+              if (this.isNodeWithinNode(methodMatch.node, classMatch.node)) {
+                matches.push({
+                  node: methodMatch.node,
+                  path: this.getNodePath(tree.rootNode, methodMatch.node),
+                  simplePath,
+                  description: `${memberName} method in class ${className}`,
+                });
+              }
+            }
+          }
+
+          // Look for properties in this class
+          const propertyMatches = this.findNodesByQuery(tree, "properties");
+          for (const propertyMatch of propertyMatches) {
+            const propertyNameNode = propertyMatch.captures.name;
+            if (propertyNameNode && propertyNameNode.text === memberName) {
+              // Check if this property is within the target class
+              if (this.isNodeWithinNode(propertyMatch.node, classMatch.node)) {
+                matches.push({
+                  node: propertyMatch.node,
+                  path: this.getNodePath(tree.rootNode, propertyMatch.node),
+                  simplePath,
+                  description: `Property ${memberName} in class ${className}`,
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return matches;
+  }
+  /**
+   * Find the containing class name for a method node
+   */
+  private findContainingClassName(
+    tree: Tree,
+    methodNode: SyntaxNode
+  ): string | null {
+    if (!this.languagePack) return null;
+
+    // Find all classes and check if this method is within any of them
+    const classMatches = this.findNodesByQuery(tree, "classes");
+
+    for (const classMatch of classMatches) {
+      if (this.isNodeWithinNode(methodNode, classMatch.node)) {
+        const nameNode = classMatch.captures.name;
+        return nameNode ? nameNode.text : null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get the parser instance (for testing or advanced usage)
+   */
+  getParser(): LanguageAgnosticParser {
+    return this.parser;
+  }
+
+  private getNodePath(rootNode: SyntaxNode, targetNode: SyntaxNode): string {
+    const path: string[] = [];
+    let current: SyntaxNode | null = targetNode;
+
+    while (current && current !== rootNode) {
+      if (current.parent) {
+        const siblings = current.parent.children;
+        const index = siblings.indexOf(current);
+        path.unshift(`${current.type}[${index}]`);
+        current = current.parent;
+      } else {
+        break;
+      }
+    }
+
+    return path.join("/");
+  }
+  /**
+   * Get all possible human-readable paths for a tree
+   */
+  getAllSimplePaths(tree: Tree): string[] {
+    const paths: string[] = [];
+
+    if (!this.languagePack || !tree.rootNode) {
+      return paths;
+    }
+
+    // Add class names
+    const classMatches = this.findNodesByQuery(tree, "classes");
+    for (const classMatch of classMatches) {
+      const classNameNode = classMatch.captures.name;
+      if (classNameNode && classNameNode.text) {
+        const className = classNameNode.text;
+        paths.push(className);
+
+        // Add methods within this class
+        const methodMatches = this.findNodesByQuery(tree, "methods");
+        for (const methodMatch of methodMatches) {
+          const methodNameNode = methodMatch.captures.name;
+          if (
+            methodNameNode &&
+            methodNameNode.text &&
+            this.isNodeWithinNode(methodMatch.node, classMatch.node)
+          ) {
+            const methodName = methodNameNode.text;
+            paths.push(`${className}.${methodName}`);
+          }
+        }
+
+        // Add properties within this class
+        const propertyMatches = this.findNodesByQuery(tree, "properties");
+        for (const propertyMatch of propertyMatches) {
+          const propertyNameNode = propertyMatch.captures.name;
+          if (
+            propertyNameNode &&
+            propertyNameNode.text &&
+            this.isNodeWithinNode(propertyMatch.node, classMatch.node)
+          ) {
+            const propertyName = propertyNameNode.text;
+            paths.push(`${className}.${propertyName}`);
+          }
+        }
+      }
+    }
+    // Add standalone methods (not within classes)
+    const standaloneMethods = this.findNodesByQuery(tree, "methods");
+    for (const methodMatch of standaloneMethods) {
+      const methodNameNode = methodMatch.captures.name;
+      if (methodNameNode && methodNameNode.text) {
+        const methodName = methodNameNode.text;
+
+        // Check if this method is NOT within a class
+        let isWithinClass = false;
+        for (const classMatch of classMatches) {
+          if (this.isNodeWithinNode(methodMatch.node, classMatch.node)) {
+            isWithinClass = true;
+            break;
+          }
+        }
+
+        if (!isWithinClass) {
+          paths.push(methodName);
+        }
+      }
+    }
+
+    // Add blocks
+    const blockMatches = this.findNodesByQuery(tree, "blocks");
+    for (const blockMatch of blockMatches) {
+      const calleeNode = blockMatch.captures.callee;
+      const nameNode = blockMatch.captures.name;
+
+      if (calleeNode && calleeNode.text) {
+        const callee = calleeNode.text;
+
+        if (nameNode && nameNode.text) {
+          // Extract the name from quotes if needed
+          let name = nameNode.text;
+          if (
+            (name.startsWith('"') && name.endsWith('"')) ||
+            (name.startsWith("'") && name.endsWith("'"))
+          ) {
+            name = name.slice(1, -1);
+          }
+          paths.push(`${callee}("${name}")`);
+        } else {
+          // Block without name parameter
+          paths.push(`${callee}()`);
+        }
+      }
+    }
+
+    return paths;
+  }
+
+  /**
+   * Helper method to check if one node is contained within another
+   */
+  private isNodeWithinNode(
+    childNode: SyntaxNode,
+    parentNode: SyntaxNode
+  ): boolean {
+    let current = childNode.parent;
+    while (current) {
+      if (current === parentNode) {
+        return true;
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+}

package/src/plugins/types.ts

@@ -1,4 +1,7 @@
 import { Embeddable, MinimalEmbedding } from "../types";
+import { AgentService, EventService, ToolsService } from "../services";
+import { AIClient } from "../clients";
+import { PluginService } from "./plugins";
 
 export interface PluginMeta {
   key: string;
@@ -16,3 +19,11 @@ export interface Plugin {
 
   meta: PluginMeta;
 }
+
+export interface PluginContext {
+  Agents?: AgentService;
+  Events?: EventService;
+  Clients?: AIClient;
+  Tools?: ToolsService;
+  Plugins?: PluginService;
+}

package/src/plugins/url.ts

@@ -1,5 +1,5 @@
 import { PluginBase, PluginMeta } from "./PluginBase";
-import { Plugin } from "./types";
+import { Plugin, PluginContext } from "./types";
 import { MinimalEmbedding } from "../types";
 import axios from "axios";
 import * as cheerio from "cheerio";
@@ -12,8 +12,10 @@ export class UrlPlugin extends PluginBase implements Plugin {
     requires: [],
   };
 
-  constructor() {
-    super(UrlPlugin.meta);
+  meta = UrlPlugin.meta;
+
+  constructor(context: PluginContext) {
+    super(context);
   }
 
   async embed(userPrompt: string): Promise<MinimalEmbedding[]> {

package/src/plugins/vim.ts

@@ -1,16 +1,19 @@
-import glob from "glob";
+import { globSync } from "glob";
 import { readFile, fileExists, fileStat } from "../utils";
 import { PluginBase, PluginMeta } from "./PluginBase";
+import { PluginContext } from "./types";
 
 export class VimPlugin extends PluginBase {
   static readonly meta: PluginMeta = {
     key: "vim",
     name: "Vim Plugin",
-    requires: []
+    requires: [],
   };
 
-  constructor() {
-    super(VimPlugin.meta);
+  meta = VimPlugin.meta;
+
+  constructor(context: PluginContext) {
+    super(context);
   }
 
   async embed(userPrompt: string) {
@@ -18,7 +21,7 @@ export class VimPlugin extends PluginBase {
   }
 
   async getVimFiles() {
-    const vimFiles = await glob.sync("./**/*.swp", { dot: true });
+    const vimFiles = globSync("./**/*.swp", { dot: true });
     return vimFiles;
   }
 

package/src/processors/CustomVariables.ts

@@ -136,14 +136,28 @@ export class CustomVariables {
   }
 
   /**
-   * Recursively processes a value to substitute {{variable}} patterns
+   * Processes a value to substitute {{variableName}} patterns
    */
   private substituteVariables(
     value: any,
     processedVars: Set<string> = new Set()
   ): any {
     if (typeof value === "string") {
-      // Find all {{variable}} patterns
+      // 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, '');
+          return !(varName in this.variables);
+        });
+        
+        if (allUndefined && variableMatches.length > 0) {
+          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
         if (processedVars.has(varName)) {
@@ -156,11 +170,9 @@ export class CustomVariables {
 
         const varValue = this.variables[varName];
 
-        // If the variable value is a string, recursively process it
+        // For nested variables, return the raw value without further processing
         if (typeof varValue === "string") {
-          const newProcessedVars = new Set(processedVars);
-          newProcessedVars.add(varName);
-          return this.substituteVariables(varValue, newProcessedVars);
+          return varValue;
         }
 
         // For non-string values, convert to JSON
@@ -422,4 +434,4 @@ export const deleteVariableToolDefinition: Tool = {
       required: ["varName"],
     },
   },
-};
+};

package/src/processors/TokenCompressor.ts

@@ -54,10 +54,6 @@ export class TokenCompressor {
    * Compresses a string into chunks from the end, creating a chain of references
    */
   public compressStringInChunks(content: string, path: string = ""): string {
-    if (path === "" && this.estimateTokens(content) <= this.maxTokens) {
-      return content;
-    }
-
     if (content.length <= this.characterLimit) {
       return content;
     }
@@ -80,10 +76,14 @@ export class TokenCompressor {
     }
 
     // Store chunks and create chain of references
-    for (let i = chunks.length - 1; i >= 0; i--) {
+    // First, generate all keys
+    for (let i = 0; i < chunks.length; i++) {
       const key = this.generateKey();
-      chunkKeys.unshift(key);
+      chunkKeys.push(key);
+    }
 
+    // Then store chunks with proper linking
+    for (let i = 0; i < chunks.length; i++) {
       let chunkContent = chunks[i];
 
       // Add reference to next chunk if it exists
@@ -92,7 +92,7 @@ export class TokenCompressor {
         chunkContent += `\n\n[NEXT_CHUNK_KEY: ${nextKey}]`;
       }
 
-      this.storeString(key, chunkContent);
+      this.storeString(chunkKeys[i], chunkContent);
     }
 
     // Return reference to the first chunk
@@ -114,11 +114,11 @@ export class TokenCompressor {
   public compressContent(content: string, path: string = ""): string {
     const tokens = this.estimateTokens(content);
 
-    if (path === "" && tokens <= this.maxTokens) {
-      return content;
-    }
-
-    if (tokens <= this.compressionThreshold) {
+    // 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;
+    
+    if (tokens <= thresholdToUse) {
       return content;
     }
 
@@ -239,7 +239,7 @@ export class TokenCompressor {
 
       // If not JSON or compression wasn't effective, handle as regular string
       const tokens = this.estimateTokens(obj);
-      if (tokens > this.characterLimit * 4) {
+      if (tokens > this.compressionThreshold) {
         const key = this.generateKey();
         this.storeString(key, obj);