@tyvm/knowhow 0.0.47 → 0.0.48

package/tests/tree-sitter/paths/debug-paths.test.ts

@@ -0,0 +1,90 @@
+import { LanguageAgnosticParser } from "../../../src/plugins/tree-sitter/parser";
+import { TreeEditor } from "../../../src/plugins/tree-sitter/editor";
+
+describe("Debug Tree Path Consistency", () => {
+  it("should analyze parser vs editor tree differences", () => {
+    const parser = LanguageAgnosticParser.createTypeScriptParser();
+    
+    const content = `export class Calculator {
+  private history: number[] = [];
+
+  constructor(private precision: number = 2) {}
+
+  add(a: number, b: number): number {
+    const result = a + b;
+    this.history.push(result);
+    return Math.round(result * Math.pow(10, this.precision)) / Math.pow(10, this.precision);
+  }
+
+  multiply(a: number, b: number): number {
+    const result = a * b;
+    this.history.push(result);
+    return result;
+  }
+
+  getHistory(): number[] {
+    return [...this.history];
+  }
+
+  clear(): void {
+    this.history = [];
+  }
+}`;
+
+    // Create tree first
+    const tree = parser.parseString(content);
+    
+    console.log("=== Sample content ===");
+    console.log("");
+    console.log(content);
+    console.log("=== End content ===");
+    
+    console.log("=== Comparing Parser vs Editor Trees ===");
+    // Use the same tree instance for both parser and editor
+    const editor = TreeEditor.fromTree(parser, tree);
+    
+    console.log(`Parser tree root: ${tree.rootNode.type}, children: ${tree.rootNode.children.length}`);
+    console.log(`Parser children types: [${tree.rootNode.children.map(c => c.type).join(', ')}]`);
+    
+    console.log(`Parser instances identical: ${parser === (editor as any).parser}`);
+    
+    console.log(`Editor tree root: ${editor.tree.rootNode.type}, children: ${editor.tree.rootNode.children.length}`);
+    console.log(`Editor children types: [${editor.tree.rootNode.children.map(c => c.type).join(', ')}]`);
+    
+    console.log(`Trees identical: ${tree === editor.tree}`);
+    console.log("==========================================");
+    
+    // Find all paths for different terms
+    const resultPaths = parser.findPathsForLine(tree, "result");
+    const historyPaths = parser.findPathsForLine(tree, "history");
+    const addPaths = parser.findPathsForLine(tree, "add");
+    
+    console.log("=== All paths containing 'result' ===");
+    resultPaths.forEach((pathInfo, i) => {
+      console.log(`${i}: ${pathInfo.path} at row ${pathInfo.row}, col ${pathInfo.column}: "${pathInfo.text}"`);
+    });
+    
+    console.log("\n=== Testing path round-trip ===");
+    if (resultPaths.length > 0) {
+      const firstPath = resultPaths[0];
+      console.log(`Testing path: ${firstPath.path}`);
+      
+      const foundNode = editor.findNodeByPath(firstPath.path);
+      if (foundNode) {
+        console.log(`✓ Node found! Text: "${foundNode.text}", Type: ${foundNode.type}`);
+        console.log(`Position: row ${foundNode.startPosition.row}, col ${foundNode.startPosition.column}`);
+        
+        // Test if we can regenerate the same path
+        const regeneratedPath = parser.getNodePath(tree.rootNode, foundNode);
+        console.log(`Original path:    ${firstPath.path}`);
+        console.log(`Regenerated path: ${regeneratedPath}`);
+        console.log(`Paths match: ${regeneratedPath === firstPath.path}`);
+      } else {
+        console.log(`✗ Node NOT found for path: ${firstPath.path}`);
+      }
+    }
+    
+    // Verify that path resolution now works
+    expect(tree === editor.tree).toBe(true);
+  });
+});

package/tests/tree-sitter/paths/paths.test.ts

@@ -0,0 +1,170 @@
+import {
+  LanguageAgnosticParser,
+} from "../../../src/plugins/tree-sitter/parser";
+import { TreeEditor } from "../../../src/plugins/tree-sitter/editor";
+
+describe("Tree-sitter Path Functionality", () => {
+  let parser: LanguageAgnosticParser;
+  let editor: TreeEditor;
+
+  const sampleCode = `export class Calculator {
+  private history: number[] = [];
+  private operationCount: number = 0;
+
+  constructor(private precision: number = 2) {}
+
+  add(a: number, b: number): number {
+    const result = a + b;
+    this.history.push(result);
+    return result;
+  }
+
+  multiply(a: number, b: number): number {
+    const result = a * b;
+    this.history.push(result);
+    return result;
+  }
+
+  getHistory(): number[] {
+    return [...this.history];
+  }
+}`;
+
+  beforeEach(() => {
+    parser = LanguageAgnosticParser.createTypeScriptParser();
+    editor = new TreeEditor(parser, sampleCode);
+  });
+
+  describe("Path Generation and Resolution", () => {
+    test("should generate consistent paths with getNodePath and findNodeByPath", () => {
+      const tree = editor.getTree();
+      
+      // Find all variable declarations in methods
+      const paths = editor.findPathsForLine(tree, "result");
+      
+      expect(paths.length).toBeGreaterThan(0);
+      
+      paths.forEach(pathLocation => {
+        console.log(`Found path: ${pathLocation.path} at ${pathLocation.row}:${pathLocation.column}`);
+        
+        // Try to find the node back using the path
+        const foundNode = (editor as any).findNodeByPath(pathLocation.path);
+        expect(foundNode).not.toBeNull();
+        
+        if (foundNode) {
+          // The found node might be a parent of the exact location, so just verify it contains the text
+          expect(foundNode.text).toContain(pathLocation.text);
+          expect(foundNode.endPosition.column).toBeGreaterThanOrEqual(pathLocation.column + pathLocation.text.length);
+        }
+      });
+    });
+
+    test("should find paths to variables defined in methods", () => {
+      const tree = editor.getTree();
+      
+      // Find paths to 'result' variable declarations
+      const resultPaths = editor.findPathsForLine(tree, "result");
+      
+      // Filter to only variable declarations (not references)
+      const variableDeclarations = resultPaths.filter(path =>
+        path.path.includes("statement_block") && path.text === "result"
+      );
+      
+      expect(variableDeclarations.length).toBeGreaterThan(0);
+      
+      variableDeclarations.forEach(path => {
+        console.log(`Variable declaration path: ${path.path}`);
+        console.log(`Location: line ${path.row + 1}, column ${path.column + 1}`);
+        console.log(`Text: "${path.text}"`);
+        
+        // Verify we can find the node back
+        const node = (editor as any).findNodeByPath(path.path);
+        expect(node).not.toBeNull();
+        expect(node?.text).toContain("result");
+      });
+    });
+
+    test("should find paths to method parameters", () => {
+      const tree = editor.getTree();
+      
+      // Find paths to method parameters 'a' and 'b'
+      const parameterPaths = [
+        ...editor.findPathsForLine(tree, "a"),
+        ...editor.findPathsForLine(tree, "b")
+      ].filter(path => 
+        path.path.includes("formal_parameters") ||
+        path.path.includes("required_parameter")
+      );
+      
+      expect(parameterPaths.length).toBeGreaterThan(0);
+      
+      parameterPaths.forEach(path => {
+        console.log(`Parameter path: ${path.path}`);
+        const node = (editor as any).findNodeByPath(path.path);
+        expect(node).not.toBeNull();
+      });
+    });
+
+    test("should find paths to class properties", () => {
+      const tree = editor.getTree();
+      
+      // Find paths to class properties
+      const propertyPaths = editor.findPathsForLine(tree, "history");
+      
+      const propertyDeclarations = propertyPaths.filter(path =>
+        path.path.includes("public_field_definition") && path.path.includes("property_identifier")
+      );
+      
+      expect(propertyDeclarations.length).toBeGreaterThan(0);
+      
+      propertyDeclarations.forEach(path => {
+        console.log(`Property path: ${path.path}`);
+        const node = (editor as any).findNodeByPath(path.path);
+        expect(node).not.toBeNull();
+      });
+    });
+  });
+
+  describe("Path-based Node Updates", () => {
+    test("should update node content using paths", () => {
+      const tree = editor.getTree();
+      
+      // Find the first result variable declaration
+      const resultPaths = editor.findPathsForLine(tree, "result");
+      const firstResultPath = resultPaths[0];
+      
+      expect(firstResultPath).toBeDefined();
+      
+      // Update the node at this path
+      const updatedEditor = editor.updateNodeByPath(firstResultPath.path, "finalResult");
+      const updatedText = updatedEditor.getCurrentText();
+      
+      expect(updatedText).toContain("finalResult");
+      expect(updatedText).not.toBe(sampleCode);
+    });
+
+    test("should handle multi-line node updates", () => {
+      const tree = editor.getTree();
+      
+      // Find a method body
+      const addMethodPaths = editor.findPathsForLine(tree, "add");
+      const methodPath = addMethodPaths.find(path =>
+        path.path.includes("method_definition") && path.path.includes("property_identifier") && path.text === "add"
+      );
+      
+      expect(methodPath).toBeDefined();
+      
+      // Update the entire method
+      const newMethodBody = `add(a: number, b: number): number {
+    console.log("Adding numbers");
+    return a + b;
+  }`;
+      
+      const updatedEditor = editor.updateNodeByPath(methodPath!.path, newMethodBody);
+      const updatedText = updatedEditor.getCurrentText();
+      
+      expect(updatedText).toContain("console.log");
+      expect(updatedText).toContain("Adding numbers");
+    });
+  });
+});

package/tests/tree-sitter/paths/simple-paths.test.ts

@@ -0,0 +1,367 @@
+import { LanguageAgnosticParser } from "../../../src/plugins/tree-sitter/parser";
+import { TreeEditor } from "../../../src/plugins/tree-sitter/editor";
+import { SimplePathResolver } from "../../../src/plugins/tree-sitter/simple-paths";
+
+describe("Simple Path Functionality", () => {
+  let parser: LanguageAgnosticParser;
+  let resolver: SimplePathResolver;
+
+  beforeEach(() => {
+    parser = LanguageAgnosticParser.createTypeScriptParser();
+    resolver = new SimplePathResolver(parser);
+  });
+
+  const sampleCode = `
+export class Calculator {
+  private value: number = 0;
+
+  constructor(initialValue: number) {
+    this.value = initialValue;
+  }
+
+  add(x: number): number {
+    const result = this.value + x;
+    console.log("Adding", result);
+    return result;
+  }
+
+  multiply(x: number, y: number): number {
+    const result = x * y;
+    console.log("Multiplying", result);
+    return result;
+  }
+}
+`.trim();
+
+  describe("SimplePathResolver", () => {
+    test("should find nodes by class name", () => {
+      const tree = parser.parseString(sampleCode);
+      const matches = resolver.findBySimplePath(tree, "Calculator");
+
+      expect(matches.length).toBeGreaterThan(0);
+      expect(matches[0].description).toContain("Calculator");
+    });
+
+    test("should find nodes by method name", () => {
+      const tree = parser.parseString(sampleCode);
+      const matches = resolver.findBySimplePath(tree, "add");
+
+      expect(matches.length).toBeGreaterThan(0);
+      expect(matches.some(m => m.description.includes("add"))).toBe(true);
+    });
+
+    test("should find nodes by class.method pattern", () => {
+      const tree = parser.parseString(sampleCode);
+      const matches = resolver.findBySimplePath(tree, "Calculator.add");
+
+      expect(matches.length).toBeGreaterThan(0);
+      expect(matches[0].description).toContain("Calculator");
+      expect(matches[0].description).toContain("add");
+    });
+
+    test("should get all available simple paths", () => {
+      const tree = parser.parseString(sampleCode);
+      const paths = resolver.getAllSimplePaths(tree);
+
+      expect(paths.length).toBeGreaterThan(0);
+      expect(paths.some(p => p.includes("Calculator"))).toBe(true);
+      expect(paths.some(p => p.includes("add"))).toBe(true);
+      expect(paths.some(p => p.includes("multiply"))).toBe(true);
+    });
+  });
+
+  describe("TreeEditor Simple Path Integration", () => {
+    test("should update node using simple path", () => {
+      const editor = new TreeEditor(parser, sampleCode);
+
+      // Find a method to update
+      const matches = editor.findNodesBySimplePath("add");
+      expect(matches.length).toBeGreaterThan(0);
+
+      // Update the method body
+      const updatedEditor = editor.updateNodeBySimplePath("Calculator.add", `add(x: number): number {
+    return this.value + x + 1; // Modified
+  }`);
+
+      const newText = updatedEditor.getCurrentText();
+      expect(newText).toContain("Modified");
+      expect(newText).toContain("x + 1");
+    });
+
+    test("should find multiple nodes with same name", () => {
+      const editor = new TreeEditor(parser, sampleCode);
+
+      // Create a sample with duplicate method names to test multiple matches
+      const duplicateMethodCode = `
+class A { method() { return 1; } }
+class B { method() { return 2; } }
+      `.trim();
+
+      const duplicateEditor = new TreeEditor(parser, duplicateMethodCode);
+      const matches = duplicateEditor.findNodesBySimplePath("method");
+
+      // Should find multiple 'method' functions
+      expect(matches.length).toBeGreaterThan(1);
+      expect(matches.some(m => m.description.includes("method in class A"))).toBe(true);
+      expect(matches.some(m => m.description.includes("method in class B"))).toBe(true);
+    });
+
+    test("should get all simple paths from TreeEditor", () => {
+      const editor = new TreeEditor(parser, sampleCode);
+      const paths = editor.getAllSimplePaths();
+
+      expect(paths.length).toBeGreaterThan(0);
+      expect(paths.some(p => p.includes("Calculator"))).toBe(true);
+    });
+
+    test("should handle path not found error", () => {
+      const editor = new TreeEditor(parser, sampleCode);
+
+      expect(() => {
+        editor.updateNodeBySimplePath("NonExistentClass.nonExistentMethod", "new content");
+      }).toThrow(/Node not found at path: NonExistentClass.nonExistentMethod/);
+    });
+
+    test("should handle multiple matches error", () => {
+      const editor = new TreeEditor(parser, sampleCode);
+
+      // Create a sample with duplicate method names
+      const duplicateMethodCode = `
+class A { method() { return 1; } }
+class B { method() { return 2; } }
+      `.trim();
+
+      const duplicateEditor = new TreeEditor(parser, duplicateMethodCode);
+
+      // Try to update with ambiguous path that matches multiple nodes
+      expect(() => {
+        duplicateEditor.updateNodeBySimplePath("method", "new content");
+      }).toThrow(/Multiple nodes found for path: method.*/);
+    });
+  });
+
+  describe("Generic Block Support", () => {
+    const testFrameworkCode = `
+describe("Authentication", () => {
+  beforeEach(() => {
+    setup();
+  });
+
+  test("should login successfully", () => {
+    expect(login()).toBe(true);
+  });
+
+  it("should logout properly", () => {
+    expect(logout()).toBe(true);
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+});
+
+describe("User Management", () => {
+  test("should create user", () => {
+    expect(createUser()).toBeTruthy();
+  });
+});
+`.trim();
+
+    test("should find describe blocks by name", () => {
+      const tree = parser.parseString(testFrameworkCode);
+      const matches = resolver.findBySimplePath(tree, 'describe("Authentication")');
+
+      expect(matches.length).toBe(1);
+      expect(matches[0].description).toContain("describe");
+      expect(matches[0].description).toContain("Authentication");
+    });
+
+    test("should find test blocks by name", () => {
+      const tree = parser.parseString(testFrameworkCode);
+      const matches = resolver.findBySimplePath(tree, 'test("should login successfully")');
+
+      expect(matches.length).toBe(1);
+      expect(matches[0].description).toContain("test");
+      expect(matches[0].description).toContain("should login successfully");
+    });
+
+    test("should find it blocks by name", () => {
+      const tree = parser.parseString(testFrameworkCode);
+      const matches = resolver.findBySimplePath(tree, 'it("should logout properly")');
+
+      expect(matches.length).toBe(1);
+      expect(matches[0].description).toContain("it");
+      expect(matches[0].description).toContain("should logout properly");
+    });
+
+    test("should find beforeEach blocks", () => {
+      const tree = parser.parseString(testFrameworkCode);
+      const matches = resolver.findBySimplePath(tree, "beforeEach");
+
+      expect(matches.length).toBe(1);
+      expect(matches[0].description).toContain("beforeEach");
+    });
+
+    test("should find afterEach blocks", () => {
+      const tree = parser.parseString(testFrameworkCode);
+      const matches = resolver.findBySimplePath(tree, "afterEach");
+
+      expect(matches.length).toBe(1);
+      expect(matches[0].description).toContain("afterEach");
+    });
+
+    test("should handle template string literals", () => {
+      const templateStringCode = `
+describe(\`User \${userId} Tests\`, () => {
+  test(\`should process \${action}\`, () => {
+    // test content
+  });
+});
+`.trim();
+
+      const tree = parser.parseString(templateStringCode);
+      const matches = resolver.findBySimplePath(tree, 'describe(`User ${userId} Tests`)');
+
+      expect(matches.length).toBe(1);
+      expect(matches[0].description).toContain("describe");
+    });
+
+    test("should find multiple describe blocks with different names", () => {
+      const tree = parser.parseString(testFrameworkCode);
+      const authMatches = resolver.findBySimplePath(tree, 'describe("Authentication")');
+      const userMatches = resolver.findBySimplePath(tree, 'describe("User Management")');
+
+      expect(authMatches.length).toBe(1);
+      expect(userMatches.length).toBe(1);
+      expect(authMatches[0].description).toContain("Authentication");
+      expect(userMatches[0].description).toContain("User Management");
+    });
+
+    test("should include generic blocks in getAllSimplePaths", () => {
+      const tree = parser.parseString(testFrameworkCode);
+      const paths = resolver.getAllSimplePaths(tree);
+
+      expect(paths.some(p => p.includes('describe("Authentication")'))).toBe(true);
+      expect(paths.some(p => p.includes('test("should login successfully")'))).toBe(true);
+      expect(paths.some(p => p.includes('it("should logout properly")'))).toBe(true);
+      expect(paths.some(p => p.includes("beforeEach"))).toBe(true);
+      expect(paths.some(p => p.includes("afterEach"))).toBe(true);
+    });
+  });
+
+  describe("Multi-Language Support", () => {
+    describe("JavaScript Support", () => {
+      let jsParser: LanguageAgnosticParser;
+      let jsResolver: SimplePathResolver;
+
+      beforeEach(() => {
+        jsParser = LanguageAgnosticParser.createJavaScriptParser();
+        jsResolver = new SimplePathResolver(jsParser);
+      });
+
+      const jsCode = `
+class Calculator {
+  constructor(initialValue = 0) {
+    this.value = initialValue;
+  }
+
+  add(x) {
+    const result = this.value + x;
+    console.log(\`Adding: \${result}\`);
+    return result;
+  }
+
+  multiply(x, y) {
+    const result = x * y;
+    console.log(\`Multiplying: \${result}\`);
+    return result;
+  }
+}
+`.trim();
+
+      test("should find JavaScript classes", () => {
+        const tree = jsParser.parseString(jsCode);
+        const matches = jsResolver.findBySimplePath(tree, "Calculator");
+
+        expect(matches.length).toBeGreaterThan(0);
+        expect(matches[0].description).toContain("Calculator");
+      });
+
+      test("should find JavaScript methods", () => {
+        const tree = jsParser.parseString(jsCode);
+        const matches = jsResolver.findBySimplePath(tree, "add");
+
+        expect(matches.length).toBeGreaterThan(0);
+        expect(matches.some(m => m.description.includes("add"))).toBe(true);
+      });
+
+      test("should find JavaScript class.method patterns", () => {
+        const tree = jsParser.parseString(jsCode);
+        const matches = jsResolver.findBySimplePath(tree, "Calculator.add");
+
+        expect(matches.length).toBeGreaterThan(0);
+        expect(matches[0].description).toContain("Calculator");
+        expect(matches[0].description).toContain("add");
+      });
+
+      test("should handle JavaScript with test blocks", () => {
+        const jsTestCode = `
+describe("Calculator Tests", () => {
+  test("should add numbers", () => {
+    const calc = new Calculator();
+    expect(calc.add(2)).toBe(2);
+  });
+});
+`.trim();
+
+        const tree = jsParser.parseString(jsTestCode);
+        const matches = jsResolver.findBySimplePath(tree, 'describe("Calculator Tests")');
+
+        expect(matches.length).toBe(1);
+        expect(matches[0].description).toContain("describe");
+        expect(matches[0].description).toContain("Calculator Tests");
+      });
+    });
+  });
+
+  describe("Interface Support (TypeScript)", () => {
+    const interfaceCode = `
+interface ICalculator {
+  add(x: number): number;
+  multiply(x: number, y: number): number;
+}
+
+interface IUserManager {
+  createUser(name: string): User;
+  deleteUser(id: number): void;
+}
+
+class Calculator implements ICalculator {
+  add(x: number): number {
+    return x;
+  }
+
+  multiply(x: number, y: number): number {
+    return x * y;
+  }
+}
+`.trim();
+
+    test("should find interfaces", () => {
+      const tree = parser.parseString(interfaceCode);
+      const matches = resolver.findBySimplePath(tree, "ICalculator");
+
+      expect(matches.length).toBeGreaterThan(0);
+      expect(matches[0].description).toContain("ICalculator");
+    });
+
+    test("should find interface methods", () => {
+      const tree = parser.parseString(interfaceCode);
+      const matches = resolver.findBySimplePath(tree, "ICalculator.add");
+
+      expect(matches.length).toBeGreaterThan(0);
+      expect(matches[0].description).toContain("ICalculator");
+      expect(matches[0].description).toContain("add");
+    });
+  });
+});

package/tests/tree-sitter/sample-after.ts

@@ -0,0 +1,48 @@
+export class Calculator {
+  private history: number[] = [];
+  private operationCount: number = 0;
+
+  constructor(private precision: number = 2) {}
+
+  add(a: number, b: number): number {
+    // Enhanced add method with validation and logging
+    if (typeof a !== 'number' || typeof b !== 'number') {
+      throw new Error('Both arguments must be numbers');
+    }
+    
+    const result = a + b;
+    this.history.push(result);
+    this.operationCount++;
+    
+    console.log(`Addition performed: ${a} + ${b} = ${result}`);
+    return Math.round(result * Math.pow(10, this.precision)) / Math.pow(10, this.precision);
+  }
+
+  multiply(a: number, b: number): number {
+    // Enhanced multiply method with validation
+    if (typeof a !== 'number' || typeof b !== 'number') {
+      throw new Error('Both arguments must be numbers');
+    }
+    
+    const result = a * b;
+    this.history.push(result);
+    this.operationCount++;
+    
+    console.log(`Multiplication performed: ${a} * ${b} = ${result}`);
+    return Math.round(result * Math.pow(10, this.precision)) / Math.pow(10, this.precision);
+  }
+
+  getHistory(): number[] {
+    return [...this.history];
+  }
+
+  getOperationCount(): number {
+    return this.operationCount;
+  }
+
+  clear(): void {
+    this.history = [];
+    this.operationCount = 0;
+    console.log('Calculator cleared');
+  }
+}

package/tests/tree-sitter/sample-before.ts

@@ -0,0 +1,25 @@
+export class Calculator {
+  private history: number[] = [];
+
+  constructor(private precision: number = 2) {}
+
+  add(a: number, b: number): number {
+    const result = a + b;
+    this.history.push(result);
+    return Math.round(result * Math.pow(10, this.precision)) / Math.pow(10, this.precision);
+  }
+
+  multiply(a: number, b: number): number {
+    const result = a * b;
+    this.history.push(result);
+    return result;
+  }
+
+  getHistory(): number[] {
+    return [...this.history];
+  }
+
+  clear(): void {
+    this.history = [];
+  }
+}