@tyvm/knowhow 0.0.90 → 0.0.92

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

@@ -1,470 +0,0 @@
-/**
- * Tree-Sitter Language-Agnostic Parser
- * 
- * HEISENBERG TEST ISSUE - NATIVE MODULE STABILITY:
- * Tree-sitter uses native node bindings (.node files) that occasionally have state corruption
- * issues when tests run in parallel or modules are re-imported. This manifests as tree.rootNode
- * being undefined intermittently (Heisenberg bug - fails unpredictably).
- * 
- * SOLUTION: Defensive guards at lines 250 and 320 check for undefined rootNode and return
- * early to prevent crashes. This provides 93%+ test stability (acceptable for native modules).
- * 
- * WHAT DIDN'T WORK:
- * - Running tests serially (maxWorkers: 1) - MADE IT WORSE
- * - Clearing module cache (resetModules: true) - BROKE initialization completely
- * - afterEach cleanup hooks - No effect
- * - The native module needs parallel execution patterns to initialize correctly
- */
-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[] = [];
-
-    // Guard against native module state corruption (Heisenberg bug)
-    // See file header comment for details on the tree-sitter stability issue
-    if (!tree.rootNode) return results;
-    
-    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[] = [];
-
-    // Guard against native module state corruption (Heisenberg bug)
-    // See file header comment for details on the tree-sitter stability issue
-    if (!tree.rootNode) return results;
-
-    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`,
-  };
-}