@tyvm/knowhow 0.0.46 → 0.0.48

package/src/plugins/tree-sitter/parser.ts

@@ -0,0 +1,444 @@
+import Parser from "tree-sitter";
+import TypeScript from "tree-sitter-typescript";
+import JavaScript from "tree-sitter-javascript";
+import { readFileSync } from "fs";
+import {
+  LanguagePackConfig,
+  BodyRule,
+  NormalizedKind,
+} from "./lang-packs/types";
+import { languagePacks, getLanguagePack } from "./lang-packs";
+
+export type Tree = Parser.Tree;
+export type SyntaxNode = Parser.SyntaxNode;
+
+export interface TreeNode {
+  type: string;
+  text: string;
+  startPosition: { row: number; column: number };
+  endPosition: { row: number; column: number };
+  children: TreeNode[];
+}
+
+export interface LanguageConfig {
+  language: any;
+  methodDeclarationTypes: string[];
+  classDeclarationTypes: string[];
+}
+
+export interface PathLocation {
+  path: string;
+  row: number;
+  column: number;
+  text: string;
+}
+
+export interface TreeEdit {
+  type: "add" | "remove" | "update";
+  path: string;
+  content?: string;
+  lineNumber?: number;
+}
+
+// Utility function to get language pack by language name
+export function getLanguagePackForLanguage(
+  languageName: string
+): LanguagePackConfig | undefined {
+  const normalizedName =
+    LanguageAgnosticParser.resolveLanguageName(languageName);
+  return getLanguagePack(normalizedName);
+}
+
+export class LanguageAgnosticParser {
+  public parser: Parser;
+  public currentLanguagePack?: LanguagePackConfig;
+
+  constructor(language: string) {
+    this.parser = new Parser();
+    this.setupFromLanguageName(language);
+  }
+
+  static resolveLanguageName(extOrName: string): string {
+    const aliases: Record<string, string> = {
+      js: "javascript",
+      jsx: "javascript",
+      ts: "typescript",
+      tsx: "typescript",
+      javascript: "javascript",
+      typescript: "typescript",
+    };
+    return aliases[extOrName.toLowerCase()] || extOrName;
+  }
+
+  static suportedLanguages(): string[] {
+    return Array.from(new Set(Object.keys(languagePacks)));
+  }
+
+  static createParserForFile(filePath: string): LanguageAgnosticParser {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return new LanguageAgnosticParser(ext);
+  }
+
+  static createTypeScriptParser(): LanguageAgnosticParser {
+    return new LanguageAgnosticParser("typescript");
+  }
+
+  static createJavaScriptParser(): LanguageAgnosticParser {
+    return new LanguageAgnosticParser("javascript");
+  }
+
+  static supportsLanguage(languageName: string): boolean {
+    return !!getLanguagePackForLanguage(languageName);
+  }
+
+  static supportsFile(filePath: string): boolean {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return !!getLanguagePackForLanguage(ext || "");
+  }
+
+  private setupFromLanguageName(languageName: string) {
+    this.setLanguagePack(languageName);
+    this.setupParserForLanguage(languageName);
+  }
+
+  private setupParserForLanguage(languageName: string) {
+    const normalizedName =
+      LanguageAgnosticParser.resolveLanguageName(languageName);
+
+    switch (normalizedName) {
+      case "javascript":
+        this.parser.setLanguage(JavaScript);
+        break;
+      case "typescript":
+        this.parser.setLanguage(TypeScript.typescript);
+        break;
+      default:
+        throw new Error(`Unsupported language: ${languageName}`);
+    }
+  }
+
+  setLanguagePack(languageName: string) {
+    const pack = getLanguagePackForLanguage(languageName);
+    if (pack) {
+      this.currentLanguagePack = pack;
+    }
+  }
+
+  getLanguagePack(): LanguagePackConfig | undefined {
+    return this.currentLanguagePack;
+  }
+
+  getLanguage(): string | undefined {
+    return this.currentLanguagePack?.language;
+  }
+
+  // Helper function to get normalized node kind
+  nodeKind(node: Parser.SyntaxNode): NormalizedKind {
+    const pack = this.currentLanguagePack;
+    return pack.kindMap[node.type] || "unknown";
+  }
+
+  // Apply a body rule to find the body node
+  applyRule(
+    node: Parser.SyntaxNode,
+    rule: BodyRule,
+    pack: LanguagePackConfig
+  ): Parser.SyntaxNode | undefined {
+    switch (rule.kind) {
+      case "self":
+        return node;
+
+      case "child":
+        if (!rule.nodeType) return undefined;
+        return node.children.find((child) => child.type === rule.nodeType);
+
+      case "field":
+        if (!rule.field) return undefined;
+        return node.childForFieldName(rule.field);
+
+      case "functionBody":
+        // Find statement_block child for functions
+        return node.children.find((child) => child.type === "statement_block");
+
+      case "callCallbackBody":
+        // For call expressions, find the last argument if it's a function
+        const args = node.childForFieldName("arguments");
+        if (!args) return undefined;
+        const lastArg = args.children[args.children.length - 1];
+        if (!lastArg) return undefined;
+
+        // If it's a function-like node, get its body
+        if (
+          lastArg.type === "arrow_function" ||
+          lastArg.type === "function_expression"
+        ) {
+          return this.applyRule(lastArg, { kind: "functionBody" }, pack);
+        }
+        return lastArg;
+
+      default:
+        return undefined;
+    }
+  }
+
+  // Get body node using mini language pack
+  getBodyNodeWithLanguagePack(
+    node: Parser.SyntaxNode,
+    pack: LanguagePackConfig
+  ): Parser.SyntaxNode | undefined {
+    const rules = pack.bodyMap[node.type];
+    if (!rules || rules.length === 0) {
+      return undefined;
+    }
+
+    // Try each rule in order until one succeeds
+    for (const rule of rules) {
+      const result = this.applyRule(node, rule, pack);
+      if (result) {
+        return result;
+      }
+    }
+
+    return undefined;
+  }
+
+  getBodyNode(node: Parser.SyntaxNode): Parser.SyntaxNode | null {
+    if (!this.currentLanguagePack) {
+      return null;
+    }
+    const result = this.getBodyNodeWithLanguagePack(
+      node,
+      this.currentLanguagePack
+    );
+    return result || null;
+  }
+
+  // Get body node using mini language pack (public method for editor)
+  getBodyNodeForLanguage(
+    node: Parser.SyntaxNode,
+    language: string
+  ): Parser.SyntaxNode | undefined {
+    const pack = getLanguagePackForLanguage(language.toLowerCase());
+    if (!pack) return undefined;
+    return this.getBodyNodeWithLanguagePack(node, pack);
+  }
+
+  // Get normalized node kind for a language
+  getNodeKindForLanguage(
+    node: Parser.SyntaxNode,
+    language: string
+  ): NormalizedKind {
+    const pack = getLanguagePackForLanguage(language.toLowerCase());
+    if (!pack) return "unknown";
+    return this.nodeKind(node);
+  }
+
+  parseFile(filePath: string): Parser.Tree {
+    const sourceCode = readFileSync(filePath, "utf8");
+    return this.parser.parse(sourceCode);
+  }
+
+  parseString(sourceCode: string): Parser.Tree {
+    return this.parser.parse(sourceCode);
+  }
+
+  getFileText(tree: Parser.Tree): string {
+    return tree.rootNode.text;
+  }
+
+  findPathsForLine(tree: Parser.Tree, searchText: string): PathLocation[] {
+    const results: PathLocation[] = [];
+    const sourceText = tree.rootNode.text;
+    const lines = sourceText.split("\n");
+
+    lines.forEach((line, lineIndex) => {
+      let columnIndex = line.indexOf(searchText);
+      while (columnIndex !== -1) {
+        // Find the node at this position
+        const node = tree.rootNode.descendantForPosition(
+          { row: lineIndex, column: columnIndex },
+          { row: lineIndex, column: columnIndex + searchText.length }
+        );
+
+        if (node) {
+          const path = this.getNodePath(tree.rootNode, node);
+          results.push({
+            path,
+            row: lineIndex,
+            column: columnIndex,
+            text: searchText,
+          });
+        }
+
+        columnIndex = line.indexOf(searchText, columnIndex + 1);
+      }
+    });
+
+    return results;
+  }
+
+  getNodePath(
+    rootNode: Parser.SyntaxNode,
+    targetNode: Parser.SyntaxNode
+  ): string {
+    const path: string[] = [];
+    let current: Parser.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("/");
+  }
+  nodeToObject(node: Parser.SyntaxNode): TreeNode {
+    return {
+      type: node.type,
+      text: node.text,
+      startPosition: {
+        row: node.startPosition.row,
+        column: node.startPosition.column,
+      },
+      endPosition: {
+        row: node.endPosition.row,
+        column: node.endPosition.column,
+      },
+      children: node.children.map((child) => this.nodeToObject(child)),
+    };
+  }
+
+  findNodesByType(tree: Parser.Tree, nodeType: string): Parser.SyntaxNode[] {
+    const results: Parser.SyntaxNode[] = [];
+
+    function traverse(node: Parser.SyntaxNode) {
+      if (node.type === nodeType) {
+        results.push(node);
+      }
+
+      for (const child of node.children) {
+        traverse(child);
+      }
+    }
+
+    traverse(tree.rootNode);
+    return results;
+  }
+
+  getTypesForKind(kind: NormalizedKind): string[] {
+    if (!this.currentLanguagePack) return [];
+    return Object.entries(this.currentLanguagePack.kindMap)
+      .filter(([_, v]) => v === kind)
+      .map(([k, _]) => k);
+  }
+
+  findNodesByKind(
+    tree: Parser.Tree,
+    kind: NormalizedKind
+  ): Parser.SyntaxNode[] {
+    const types = this.getTypesForKind(kind);
+    const results: Parser.SyntaxNode[] = [];
+    for (const type of types) {
+      results.push(...this.findNodesByType(tree, type));
+    }
+    return results;
+  }
+
+  findClassDeclarations(tree: Parser.Tree): Parser.SyntaxNode[] {
+    return this.findNodesByKind(tree, "class");
+  }
+
+  findMethodDeclarations(tree: Parser.Tree): Parser.SyntaxNode[] {
+    return this.findNodesByKind(tree, "method");
+  }
+
+  printTree(node: Parser.SyntaxNode, indent: string = ""): string {
+    let result = `${indent}${node.type}`;
+    if (node.isNamed && node.text.length < 50) {
+      result += `: "${node.text.replace(/\n/g, "\\n")}"`;
+    }
+    result += "\n";
+
+    for (const child of node.children) {
+      result += this.printTree(child, indent + "  ");
+    }
+
+    return result;
+  }
+
+  findErrorNodes(node: Parser.SyntaxNode): Parser.SyntaxNode[] {
+    const errorNodes: Parser.SyntaxNode[] = [];
+
+    function traverse(n: any) {
+      if (n.type === "ERROR" || n.hasError) {
+        errorNodes.push(n);
+      }
+
+      for (const child of n.children || []) {
+        traverse(child);
+      }
+    }
+
+    traverse(node);
+    return errorNodes;
+  }
+}
+
+export function compareTreeStructures(
+  tree1: Parser.Tree,
+  tree2: Parser.Tree
+): {
+  differences: string[];
+  summary: string;
+} {
+  const differences: string[] = [];
+
+  function compareNodes(
+    node1: Parser.SyntaxNode | null,
+    node2: Parser.SyntaxNode | null,
+    path: string = "root"
+  ) {
+    if (!node1 && !node2) return;
+
+    if (!node1) {
+      differences.push(`Node removed at ${path}: ${node2!.type}`);
+      return;
+    }
+
+    if (!node2) {
+      differences.push(`Node added at ${path}: ${node1.type}`);
+      return;
+    }
+
+    if (node1.type !== node2.type) {
+      differences.push(
+        `Node type changed at ${path}: ${node1.type} -> ${node2.type}`
+      );
+    }
+
+    if (node1.text !== node2.text && node1.text.length < 100) {
+      differences.push(
+        `Node text changed at ${path} (${node1.type}): "${node1.text}" -> "${node2.text}"`
+      );
+    }
+
+    const maxChildren = Math.max(node1.children.length, node2.children.length);
+    for (let i = 0; i < maxChildren; i++) {
+      const child1 = node1.children[i] || null;
+      const child2 = node2.children[i] || null;
+      compareNodes(child1, child2, `${path}.${i}`);
+    }
+  }
+
+  compareNodes(tree1.rootNode, tree2.rootNode);
+
+  return {
+    differences,
+    summary: `Found ${differences.length} differences between the two trees`,
+  };
+}