@tyvm/knowhow 0.0.46 → 0.0.48

package/tests/tree-sitter/test-files/completely-broken.ts

@@ -0,0 +1,7 @@
+
+      class {{{ invalid syntax here
+      function missing_name() {
+        return "broken"
+      missing closing brace
+      export const = undefined;
+    

package/tests/tree-sitter/test-files/duplicate-braces.ts

@@ -0,0 +1,39 @@
+export class Calculator {
+  private result: number = 0;
+
+  add(value: number): Calculator {
+    this.result += value;
+    return this;
+  }
+
+  subtract(value: number): Calculator {
+    this.result -= value;
+    return this;
+  }
+
+  multiply(value: number): Calculator {
+    this.result *= value;
+    return this;
+  }
+
+  getResult(): number {
+    return this.result;
+  }}
+}
+
+export function createCalculator(): Calculator {
+  return new Calculator();
+}
+
+describe("Calculator Tests", () => {
+  it("should perform basic arithmetic", () => {
+    const calc = createCalculator();
+    const result = calc.add(5).multiply(2).subtract(3).getResult();
+    expect(result).toBe(7);
+  });
+
+  it("should chain operations correctly", () => {
+    const calc = new Calculator();
+    expect(calc.add(10).add(5).getResult()).toBe(15);
+  });
+});

package/tests/tree-sitter/test-files/invalid-nesting.ts

@@ -0,0 +1,39 @@
+export class Calculator {
+  private result: number = 0;
+
+  add(value: number): Calculator {
+    this.result += value;
+    return this;
+  }
+
+  subtract(value: number): Calculator {
+    this.result -= value;
+    return this;
+  }
+
+  multiply(value: number): Calculator {
+    this.result *= value;
+    return this;
+  }
+
+  getResult(): number {
+    return this.result;
+  }
+}
+
+export function createCalculator(): Calculator {
+  return new Calculator();
+}
+
+describe("Calculator Tests", (() => {
+  it("should perform basic arithmetic", () => {
+    const calc = createCalculator();
+    const result = calc.add(5).multiply(2).subtract(3).getResult();
+    expect(result).toBe(7);
+  });
+
+  it("should chain operations correctly", () => {
+    const calc = new Calculator();
+    expect(calc.add(10).add(5).getResult()).toBe(15);
+  });
+});

package/tests/tree-sitter/test-files/malformed-signature.ts

@@ -0,0 +1,39 @@
+export class Calculator {
+  private result: number = 0;
+
+  add(value: number): Calculator {
+    this.result += value;
+    return this;
+  }
+
+  subtract(value number): Calculator {
+    this.result -= value;
+    return this;
+  }
+
+  multiply(value: number): Calculator {
+    this.result *= value;
+    return this;
+  }
+
+  getResult(): number {
+    return this.result;
+  }
+}
+
+export function createCalculator(): Calculator {
+  return new Calculator();
+}
+
+describe("Calculator Tests", () => {
+  it("should perform basic arithmetic", () => {
+    const calc = createCalculator();
+    const result = calc.add(5).multiply(2).subtract(3).getResult();
+    expect(result).toBe(7);
+  });
+
+  it("should chain operations correctly", () => {
+    const calc = new Calculator();
+    expect(calc.add(10).add(5).getResult()).toBe(15);
+  });
+});

package/tests/tree-sitter/test-files/mismatched-parens.ts

@@ -0,0 +1,39 @@
+export class Calculator {
+  private result: number = 0;
+
+  add(value: number: Calculator {
+    this.result += value;
+    return this;
+  }
+
+  subtract(value: number): Calculator {
+    this.result -= value;
+    return this;
+  }
+
+  multiply(value: number): Calculator {
+    this.result *= value;
+    return this;
+  }
+
+  getResult(): number {
+    return this.result;
+  }
+}
+
+export function createCalculator(): Calculator {
+  return new Calculator();
+}
+
+describe("Calculator Tests", () => {
+  it("should perform basic arithmetic", () => {
+    const calc = createCalculator();
+    const result = calc.add(5).multiply(2).subtract(3).getResult();
+    expect(result).toBe(7);
+  });
+
+  it("should chain operations correctly", () => {
+    const calc = new Calculator();
+    expect(calc.add(10).add(5).getResult()).toBe(15);
+  });
+});

package/tests/tree-sitter/test-files/missing-semicolon.ts

@@ -0,0 +1,39 @@
+export class Calculator {
+  private result: number = 0
+
+  add(value: number): Calculator {
+    this.result += value;
+    return this;
+  }
+
+  subtract(value: number): Calculator {
+    this.result -= value;
+    return this;
+  }
+
+  multiply(value: number): Calculator {
+    this.result *= value;
+    return this;
+  }
+
+  getResult(): number {
+    return this.result;
+  }
+}
+
+export function createCalculator(): Calculator {
+  return new Calculator();
+}
+
+describe("Calculator Tests", () => {
+  it("should perform basic arithmetic", () => {
+    const calc = createCalculator();
+    const result = calc.add(5).multiply(2).subtract(3).getResult();
+    expect(result).toBe(7);
+  });
+
+  it("should chain operations correctly", () => {
+    const calc = new Calculator();
+    expect(calc.add(10).add(5).getResult()).toBe(15);
+  });
+});

package/tests/tree-sitter/test-files/partially-broken.ts

@@ -0,0 +1,20 @@
+
+export class Calculator {
+  private result: number = 0;
+
+  add(value: number): Calculator {
+    this.result += value;
+    return this;
+  }
+
+  // This method has broken syntax
+  subtract(value number): Calculator {  // Missing colon
+    this.result -= value;
+    return this;
+  }
+
+  multiply(value: number): Calculator {
+    this.result *= value;
+    return this;
+  }
+}

package/tests/tree-sitter/test-files/specific-errors.ts

@@ -0,0 +1,14 @@
+
+export class TestClass {
+  method1() {
+    return "valid";
+  }
+
+  method2( {  // Missing parameter, extra opening brace
+    return "broken";
+  }
+
+  method3() {
+    return "valid again";
+  }
+}

package/tests/tree-sitter/test-files/unclosed-string.ts

@@ -0,0 +1,39 @@
+export class Calculator {
+  private result: number = 0;
+
+  add(value: number): Calculator {
+    this.result += value;
+    return this;
+  }
+
+  subtract(value: number): Calculator {
+    this.result -= value;
+    return this;
+  }
+
+  multiply(value: number): Calculator {
+    this.result *= value;
+    return this;
+  }
+
+  getResult(): number {
+    return this.result;
+  }
+}
+
+export function createCalculator(): Calculator {
+  return new Calculator();
+}
+
+describe("Calculator Tests", () => {
+  it("should perform basic arithmetic", () => {
+    const calc = createCalculator();
+    const result = calc.add(5).multiply(2).subtract(3).getResult();
+    expect(result).toBe("unclosed string;
+  });
+
+  it("should chain operations correctly", () => {
+    const calc = new Calculator();
+    expect(calc.add(10).add(5).getResult()).toBe(15);
+  });
+});

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

@@ -0,0 +1,251 @@
+import {
+  LanguageAgnosticParser,
+  compareTreeStructures,
+} from "../../src/plugins/tree-sitter/parser";
+import { join } from "path";
+
+describe("Tree-sitter TypeScript Parser", () => {
+  let parser: LanguageAgnosticParser;
+  const beforeFilePath = join(__dirname, "sample-before.ts");
+  const afterFilePath = join(__dirname, "sample-after.ts");
+
+  beforeEach(() => {
+    parser = LanguageAgnosticParser.createTypeScriptParser();
+
+    // Debug: Check if parser is properly initialized
+    const testTree = parser.parseString("class Test {}");
+    console.log("Test parse successful:", !!testTree);
+    console.log("Test tree has rootNode:", !!testTree.rootNode);
+    console.log(testTree);
+    console.log(
+      "Test rootNode type:",
+      testTree.rootNode ? testTree.rootNode.type : "undefined"
+    );
+  });
+
+  test("should parse TypeScript files", () => {
+    const beforeTree = parser.parseFile(beforeFilePath);
+    const afterTree = parser.parseFile(afterFilePath);
+
+    expect(beforeTree).toBeDefined();
+    expect(beforeTree.rootNode).toBeDefined();
+    expect(afterTree).toBeDefined();
+    expect(afterTree.rootNode).toBeDefined();
+  });
+
+  test("should find class declarations", () => {
+    const beforeTree = parser.parseFile(beforeFilePath);
+    const afterTree = parser.parseFile(afterFilePath);
+
+    const beforeClasses = parser.findClassDeclarations(beforeTree);
+    const afterClasses = parser.findClassDeclarations(afterTree);
+
+    expect(beforeClasses).toHaveLength(1);
+    expect(afterClasses).toHaveLength(1);
+    expect(beforeClasses[0].text).toContain("Calculator");
+    expect(afterClasses[0].text).toContain("Calculator");
+  });
+
+  test("should find method declarations", () => {
+    const beforeTree = parser.parseFile(beforeFilePath);
+    const afterTree = parser.parseFile(afterFilePath);
+
+    const beforeMethods = parser.findMethodDeclarations(beforeTree);
+    const afterMethods = parser.findMethodDeclarations(afterTree);
+
+    // Both should have methods, but after might have more
+    expect(beforeMethods.length).toBeGreaterThan(0);
+    expect(afterMethods.length).toBeGreaterThan(0);
+
+    const methodNames = beforeMethods.map((method) => {
+      const nameNode = method.children.find(
+        (child) => child.type === "property_identifier"
+      );
+      return nameNode ? nameNode.text : "unknown";
+    });
+
+    expect(methodNames).toContain("add");
+    expect(methodNames).toContain("multiply");
+  });
+
+  test("should convert nodes to objects", () => {
+    const beforeTree = parser.parseFile(beforeFilePath);
+    const rootObj = parser.nodeToObject(beforeTree.rootNode);
+
+    expect(rootObj).toHaveProperty("type");
+    expect(rootObj).toHaveProperty("text");
+    expect(rootObj).toHaveProperty("startPosition");
+    expect(rootObj).toHaveProperty("endPosition");
+    expect(rootObj).toHaveProperty("children");
+    expect(Array.isArray(rootObj.children)).toBe(true);
+  });
+
+  test("should print tree structure", () => {
+    const beforeTree = parser.parseFile(beforeFilePath);
+    const treeString = parser.printTree(beforeTree.rootNode);
+
+    expect(typeof treeString).toBe("string");
+    expect(treeString.length).toBeGreaterThan(0);
+    expect(treeString).toContain("program");
+    expect(treeString).toContain("export_statement");
+  });
+
+  test("should compare tree structures and find differences", () => {
+    const beforeTree = parser.parseFile(beforeFilePath);
+    const afterTree = parser.parseFile(afterFilePath);
+
+    const comparison = compareTreeStructures(beforeTree, afterTree);
+
+    expect(comparison).toHaveProperty("differences");
+    expect(comparison).toHaveProperty("summary");
+    expect(Array.isArray(comparison.differences)).toBe(true);
+    expect(typeof comparison.summary).toBe("string");
+
+    // We expect differences since the files have different content
+    expect(comparison.differences.length).toBeGreaterThan(0);
+
+    console.log("\n=== Tree Comparison Results ===");
+    console.log(comparison.summary);
+    console.log("\nDifferences:");
+    comparison.differences.forEach((diff, index) => {
+      console.log(`${index + 1}. ${diff}`);
+    });
+  });
+
+  test("should display tree structures for visual inspection", () => {
+    const beforeTree = parser.parseFile(beforeFilePath);
+    const afterTree = parser.parseFile(afterFilePath);
+
+    console.log("\n=== BEFORE FILE TREE STRUCTURE ===");
+    console.log(parser.printTree(beforeTree.rootNode));
+
+    console.log("\n=== AFTER FILE TREE STRUCTURE ===");
+    console.log(parser.printTree(afterTree.rootNode));
+
+    // Focus on method nodes specifically
+    const beforeMethods = parser.findMethodDeclarations(beforeTree);
+    const afterMethods = parser.findMethodDeclarations(afterTree);
+
+    console.log("\n=== BEFORE FILE METHODS ===");
+    beforeMethods.forEach((method, index) => {
+      console.log(`Method ${index + 1}:`);
+      console.log(parser.printTree(method));
+    });
+
+    console.log("\n=== AFTER FILE METHODS ===");
+    afterMethods.forEach((method, index) => {
+      console.log(`Method ${index + 1}:`);
+      console.log(parser.printTree(method));
+    });
+  });
+
+  test("should parse string content directly", () => {
+    const simpleClass = `
+class Test {
+  method(): string {
+    return "hello";
+  }
+}`;
+
+    const tree = parser.parseString(simpleClass);
+    const methods = parser.findMethodDeclarations(tree);
+
+    expect(tree).toBeDefined();
+    expect(methods).toHaveLength(1);
+    expect(methods[0].text).toContain("method");
+  });
+});
+
+describe("Language Agnostic Parser", () => {
+  let parser: LanguageAgnosticParser;
+  const beforeFilePath = join(__dirname, "sample-before.ts");
+  const afterFilePath = join(__dirname, "sample-after.ts");
+
+  afterEach(() => {
+    // Clean up parser instance
+    parser = null as any;
+  });
+
+  beforeEach(() => {
+    parser = LanguageAgnosticParser.createTypeScriptParser();
+    console.log("Language Agnostic Parser created:", !!parser);
+    const testTree = parser.parseString("class Test {}");
+    console.log(
+      "Language Agnostic test parse successful:",
+      !!testTree && !!testTree.rootNode
+    );
+  });
+
+  test("should create TypeScript parser", () => {
+    const tsParser = LanguageAgnosticParser.createTypeScriptParser();
+    expect(tsParser).toBeInstanceOf(LanguageAgnosticParser);
+
+    const tree = tsParser.parseString("class Test { method() {} }");
+    expect(tree).toBeDefined();
+  });
+
+  test("should create JavaScript parser", () => {
+    const jsParser = LanguageAgnosticParser.createJavaScriptParser();
+    expect(jsParser).toBeInstanceOf(LanguageAgnosticParser);
+
+    const tree = jsParser.parseString("class Test { method() {} }");
+    expect(tree).toBeDefined();
+  });
+
+  test("should get file text from tree", () => {
+    const sourceCode = 'class Test { method() { return "hello"; } }';
+    const tree = parser.parseString(sourceCode);
+    const fileText = parser.getFileText(tree);
+
+    expect(fileText).toBe(sourceCode);
+  });
+
+  test("should find paths for a given line/text", () => {
+    const tree = parser.parseFile(beforeFilePath);
+    const paths = parser.findPathsForLine(tree, "add");
+
+    expect(paths.length).toBeGreaterThan(0);
+
+    const addMethodPath = paths.find((p) => p.text === "add");
+    expect(addMethodPath).toBeDefined();
+    expect(addMethodPath!.path).toBeDefined();
+    expect(addMethodPath!.row).toBeGreaterThanOrEqual(0);
+    expect(addMethodPath!.column).toBeGreaterThanOrEqual(0);
+
+    console.log('Found paths for "add":', paths);
+  });
+
+  test("should find multiple occurrences of text", () => {
+    const sourceCode = `
+class Test {
+  method test() { return test; }
+  test() { return "test"; }
+}`;
+    const tree = parser.parseString(sourceCode);
+    const paths = parser.findPathsForLine(tree, "test");
+
+    expect(paths.length).toBeGreaterThan(1);
+    console.log('Multiple "test" occurrences:', paths);
+  });
+
+  test("should find method and class declarations with configurable types", () => {
+    const tree = parser.parseFile(beforeFilePath);
+
+    const methods = parser.findMethodDeclarations(tree);
+    const classes = parser.findClassDeclarations(tree);
+
+    expect(methods.length).toBeGreaterThan(0);
+    expect(classes.length).toBe(1);
+
+    const methodNames = methods.map((method) => {
+      const nameNode = method.children.find(
+        (child) => child.type === "property_identifier"
+      );
+      return nameNode ? nameNode.text : "unknown";
+    });
+
+    console.log("Found methods:", methodNames);
+    expect(methodNames).toContain("add");
+    expect(methodNames).toContain("multiply");
+  });
+});

package/ts_build/package.json

@@ -1,13 +1,13 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.46",
+    "version": "0.0.48",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {
         "knowhow": "ts_build/src/cli.js"
     },
     "scripts": {
-        "test": "jest --detectOpenHandles --forceExit --testTimeout 300000",
+        "test": "jest --testTimeout 300000",
         "test:debug": "node --inspect-brk ../../node_modules/jest/bin/jest.js --detectOpenHandles --forceExit --testTimeout 300000",
         "compile": "tsc",
         "start": "npm run compile && node ts_build/src/server/index.js",
@@ -41,7 +41,7 @@
         "@anthropic-ai/sdk": "^0.39.0",
         "@aws-sdk/client-s3": "^3.588.0",
         "@google/genai": "^0.14.1",
-        "@inquirer/editor": "^1.2.13",
+        "@inquirer/editor": "^4.2.18",
         "@linear/sdk": "^12.0.0",
         "@modelcontextprotocol/sdk": "^1.13.3",
         "@notionhq/client": "^2.2.14",
@@ -56,11 +56,13 @@
         "express": "^4.19.2",
         "figma-js": "^1.16.1-0",
         "gitignore-to-glob": "^0.3.0",
+        "glob": "11.0.3",
         "ink": "^6.0.1",
         "isolated-vm": "^5.0.4",
         "jira-client": "^8.2.2",
         "marked": "^10.0.0",
         "marked-terminal": "^6.2.0",
+        "minimatch": "^10.0.3",
         "morgan": "^1.10.0",
         "node-fetch": "^3.2.3",
         "node-jq": "^6.0.1",
@@ -77,6 +79,9 @@
         "puppeteer-extra-plugin-stealth": "^2.11.2",
         "react": "^19.1.0",
         "source-map-support": "^0.5.21",
+        "tree-sitter": "^0.21.1",
+        "tree-sitter-javascript": "^0.23.1",
+        "tree-sitter-typescript": "^0.23.1",
         "typescript": "^4.6.3",
         "ws": "^8.18.1",
         "youtube-dl-exec": "^2.5.5",

package/ts_build/src/agents/base/base.d.ts

@@ -40,6 +40,7 @@ export declare abstract class BaseAgent implements IAgent {
     protected pendingUserMessages: Message[];
     protected taskBreakdown: string;
     protected summaries: string[];
+    protected currentTaskId: string | null;
     agentEvents: EventEmitter<[never]>;
     eventTypes: {
         newThread: string;
@@ -60,7 +61,7 @@ export declare abstract class BaseAgent implements IAgent {
     setMaxTurns(maxTurns: number | null): void;
     setMaxSpend(maxSpend: number | null): void;
     setMaxRunTime(maxRunTimeMs: number | null): void;
-    newTask(): void;
+    newTask(taskId?: string): void;
     register(): void;
     setModelPreferences(value: ModelPreference[]): void;
     updatePreferences(value: ModelPreference): void;
@@ -100,7 +101,6 @@ export declare abstract class BaseAgent implements IAgent {
     pause(): void;
     unpause(): void;
     unpaused(): Promise<unknown>;
-    resume(resumeReason: string): Promise<void>;
     kill(): Promise<void>;
     call(userInput: string, _messages?: Message[]): any;
     addPendingUserMessage(message: Message): void;