@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-UFE77L67.js

@@ -0,0 +1,782 @@
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+
+// src/ast/type-inference.ts
+var TypeInference;
+((TypeInference2) => {
+  let TypeKind;
+  ((TypeKind2) => {
+    TypeKind2["Primitive"] = "primitive";
+    TypeKind2["Class"] = "class";
+    TypeKind2["Interface"] = "interface";
+    TypeKind2["Enum"] = "enum";
+    TypeKind2["Function"] = "function";
+    TypeKind2["Array"] = "array";
+    TypeKind2["Object"] = "object";
+    TypeKind2["Generic"] = "generic";
+    TypeKind2["Union"] = "union";
+    TypeKind2["Intersection"] = "intersection";
+    TypeKind2["Tuple"] = "tuple";
+    TypeKind2["Literal"] = "literal";
+    TypeKind2["Unknown"] = "unknown";
+    TypeKind2["Any"] = "any";
+    TypeKind2["Void"] = "void";
+  })(TypeKind = TypeInference2.TypeKind || (TypeInference2.TypeKind = {}));
+  let InferenceReason;
+  ((InferenceReason2) => {
+    InferenceReason2["Declaration"] = "declaration";
+    InferenceReason2["Assignment"] = "assignment";
+    InferenceReason2["FunctionCall"] = "function_call";
+    InferenceReason2["MethodCall"] = "method_call";
+    InferenceReason2["ControlFlow"] = "control_flow";
+    InferenceReason2["GenericInstantiation"] = "generic_instantiation";
+    InferenceReason2["TypeAssertion"] = "type_assertion";
+    InferenceReason2["Destructuring"] = "destructuring";
+    InferenceReason2["Import"] = "import";
+  })(InferenceReason = TypeInference2.InferenceReason || (TypeInference2.InferenceReason = {}));
+  class InferenceContext {
+    variableTypes = /* @__PURE__ */ new Map();
+    functionTypes = /* @__PURE__ */ new Map();
+    classTypes = /* @__PURE__ */ new Map();
+    scopeStack = [];
+    language;
+    filePath;
+    constructor(language, filePath) {
+      this.language = language;
+      this.filePath = filePath;
+      this.initializeBuiltinTypes();
+    }
+    initializeBuiltinTypes() {
+      switch (this.language) {
+        case "typescript":
+        case "javascript":
+          this.initializeJavaScriptTypes();
+          break;
+        case "python":
+          this.initializePythonTypes();
+          break;
+        case "java":
+          this.initializeJavaTypes();
+          break;
+        case "rust":
+          this.initializeRustTypes();
+          break;
+        case "cpp":
+          this.initializeCppTypes();
+          break;
+        case "csharp":
+          this.initializeCSharpTypes();
+          break;
+        default:
+          this.initializeGenericTypes();
+      }
+    }
+    initializeJavaScriptTypes() {
+      const jsTypes = ["string", "number", "boolean", "object", "undefined", "null", "symbol", "bigint"];
+      jsTypes.forEach((type) => {
+        this.classTypes.set(type, {
+          name: type,
+          kind: "primitive" /* Primitive */,
+          confidence: 1,
+          inferredAt: []
+        });
+      });
+      this.classTypes.set("Array", {
+        name: "Array",
+        kind: "class" /* Class */,
+        genericArgs: [this.getUnknownType()],
+        confidence: 1,
+        inferredAt: []
+      });
+      this.classTypes.set("Promise", {
+        name: "Promise",
+        kind: "class" /* Class */,
+        genericArgs: [this.getUnknownType()],
+        confidence: 1,
+        inferredAt: []
+      });
+    }
+    initializePythonTypes() {
+      const pythonTypes = ["int", "float", "str", "bool", "list", "dict", "tuple", "set", "None"];
+      pythonTypes.forEach((type) => {
+        this.classTypes.set(type, {
+          name: type,
+          kind: type === "None" ? "literal" /* Literal */ : "primitive" /* Primitive */,
+          confidence: 1,
+          inferredAt: []
+        });
+      });
+    }
+    initializeJavaTypes() {
+      const javaTypes = ["int", "long", "double", "float", "boolean", "char", "byte", "short", "String", "Object"];
+      javaTypes.forEach((type) => {
+        this.classTypes.set(type, {
+          name: type,
+          kind: ["String", "Object"].includes(type) ? "class" /* Class */ : "primitive" /* Primitive */,
+          confidence: 1,
+          inferredAt: []
+        });
+      });
+    }
+    initializeRustTypes() {
+      const rustTypes = ["i32", "i64", "f32", "f64", "bool", "char", "str", "String", "Vec", "Option", "Result"];
+      rustTypes.forEach((type) => {
+        this.classTypes.set(type, {
+          name: type,
+          kind: ["Vec", "Option", "Result"].includes(type) ? "generic" /* Generic */ : ["String"].includes(type) ? "class" /* Class */ : "primitive" /* Primitive */,
+          confidence: 1,
+          inferredAt: []
+        });
+      });
+    }
+    initializeCppTypes() {
+      const cppTypes = ["int", "long", "double", "float", "bool", "char", "void", "std::string", "std::vector"];
+      cppTypes.forEach((type) => {
+        this.classTypes.set(type, {
+          name: type,
+          kind: type.startsWith("std::") ? "class" /* Class */ : "primitive" /* Primitive */,
+          confidence: 1,
+          inferredAt: []
+        });
+      });
+    }
+    initializeCSharpTypes() {
+      const csharpTypes = ["int", "long", "double", "float", "bool", "char", "string", "object", "decimal"];
+      csharpTypes.forEach((type) => {
+        this.classTypes.set(type, {
+          name: type,
+          kind: ["string", "object"].includes(type) ? "class" /* Class */ : "primitive" /* Primitive */,
+          confidence: 1,
+          inferredAt: []
+        });
+      });
+    }
+    initializeGenericTypes() {
+      ["int", "string", "bool", "object"].forEach((type) => {
+        this.classTypes.set(type, {
+          name: type,
+          kind: "primitive" /* Primitive */,
+          confidence: 0.8,
+          inferredAt: []
+        });
+      });
+    }
+    // Type inference methods
+    inferVariableType(varName, assignmentNode, reason) {
+      const scopedName = this.getScopedName(varName);
+      const inferredType = this.analyzeExpression(assignmentNode);
+      inferredType.inferredAt.push({
+        filePath: this.filePath,
+        range: this.nodeToRange(assignmentNode),
+        reason
+      });
+      this.variableTypes.set(scopedName, inferredType);
+      return inferredType;
+    }
+    inferFunctionReturnType(funcName, bodyNode) {
+      const returnStatements = this.findReturnStatements(bodyNode);
+      if (returnStatements.length === 0) {
+        return this.getVoidType();
+      }
+      if (returnStatements.length === 1) {
+        return this.analyzeExpression(returnStatements[0]);
+      }
+      const returnTypes = returnStatements.map((stmt) => this.analyzeExpression(stmt));
+      return this.createUnionType(returnTypes);
+    }
+    inferMethodCallType(objectExpr, methodName) {
+      const objectType = this.analyzeExpression(objectExpr);
+      if (objectType.methods?.has(methodName)) {
+        return objectType.methods.get(methodName).returnType;
+      }
+      return this.inferMethodFromPatterns(objectType, methodName);
+    }
+    inferGenericInstantiation(genericType, typeArgs) {
+      return {
+        ...genericType,
+        genericArgs: typeArgs,
+        confidence: Math.min(genericType.confidence, ...typeArgs.map((t) => t.confidence)),
+        inferredAt: [...genericType.inferredAt]
+      };
+    }
+    // Expression analysis
+    analyzeExpression(node) {
+      switch (node.type) {
+        case "number":
+        case "integer_literal":
+        case "float_literal":
+          return this.getNumberType();
+        case "string":
+        case "string_literal":
+        case "template_literal":
+          return this.getStringType();
+        case "boolean":
+        case "true":
+        case "false":
+          return this.getBooleanType();
+        case "null":
+        case "nil":
+        case "None":
+          return this.getNullType();
+        case "identifier":
+        case "variable":
+          return this.lookupVariableType(node.text);
+        case "call_expression":
+        case "function_call":
+          return this.analyzeFunctionCall(node);
+        case "member_expression":
+        case "field_expression":
+          return this.analyzeMemberAccess(node);
+        case "array_expression":
+        case "list_expression":
+          return this.analyzeArrayExpression(node);
+        case "object_expression":
+        case "dict_expression":
+          return this.analyzeObjectExpression(node);
+        case "binary_expression":
+          return this.analyzeBinaryExpression(node);
+        case "conditional_expression":
+        case "ternary_expression":
+          return this.analyzeConditionalExpression(node);
+        default:
+          return this.getUnknownType();
+      }
+    }
+    analyzeFunctionCall(node) {
+      const functionNode = node.childForFieldName("function") || node.childForFieldName("name");
+      if (!functionNode) return this.getUnknownType();
+      const functionName = functionNode.text;
+      if (functionNode.type === "member_expression") {
+        const objectNode = functionNode.childForFieldName("object");
+        const propertyNode = functionNode.childForFieldName("property");
+        if (objectNode && propertyNode) {
+          return this.inferMethodCallType(objectNode, propertyNode.text);
+        }
+      }
+      const signature = this.functionTypes.get(functionName);
+      if (signature) {
+        return signature.returnType;
+      }
+      if (this.isConstructorCall(functionName)) {
+        const className = this.extractClassName(functionName);
+        return this.classTypes.get(className) || this.getUnknownType();
+      }
+      return this.getUnknownType();
+    }
+    analyzeMemberAccess(node) {
+      const objectNode = node.childForFieldName("object") || node.childForFieldName("expression");
+      const propertyNode = node.childForFieldName("property") || node.childForFieldName("field");
+      if (!objectNode || !propertyNode) return this.getUnknownType();
+      const objectType = this.analyzeExpression(objectNode);
+      const propertyName = propertyNode.text;
+      if (objectType.properties?.has(propertyName)) {
+        return objectType.properties.get(propertyName);
+      }
+      if (objectType.methods?.has(propertyName)) {
+        return {
+          name: `${objectType.name}.${propertyName}`,
+          kind: "function" /* Function */,
+          confidence: objectType.confidence * 0.8,
+          inferredAt: []
+        };
+      }
+      return this.getUnknownType();
+    }
+    analyzeArrayExpression(node) {
+      const elements = this.getArrayElements(node);
+      if (elements.length === 0) {
+        return {
+          name: "Array",
+          kind: "array" /* Array */,
+          genericArgs: [this.getUnknownType()],
+          confidence: 0.9,
+          inferredAt: []
+        };
+      }
+      const elementTypes = elements.map((elem) => this.analyzeExpression(elem));
+      const elementType = this.mergeTypes(elementTypes);
+      return {
+        name: "Array",
+        kind: "array" /* Array */,
+        genericArgs: [elementType],
+        confidence: elementType.confidence * 0.9,
+        inferredAt: []
+      };
+    }
+    analyzeObjectExpression(node) {
+      const properties = /* @__PURE__ */ new Map();
+      const children = node.namedChildren;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child && (child.type === "pair" || child.type === "property")) {
+          const key = this.getObjectKey(child);
+          const value = this.getObjectValue(child);
+          if (key && value) {
+            properties.set(key, this.analyzeExpression(value));
+          }
+        }
+      }
+      return {
+        name: "Object",
+        kind: "object" /* Object */,
+        properties,
+        confidence: 0.9,
+        inferredAt: []
+      };
+    }
+    analyzeBinaryExpression(node) {
+      const operator = this.getBinaryOperator(node);
+      const leftNode = node.childForFieldName("left");
+      const rightNode = node.childForFieldName("right");
+      if (!leftNode || !rightNode) return this.getUnknownType();
+      const leftType = this.analyzeExpression(leftNode);
+      const rightType = this.analyzeExpression(rightNode);
+      if (["+", "-", "*", "/", "%", "**"].includes(operator)) {
+        if (leftType.name === "string" || rightType.name === "string") {
+          return operator === "+" ? this.getStringType() : this.getUnknownType();
+        }
+        return this.getNumberType();
+      }
+      if (["<", ">", "<=", ">=", "==", "!=", "===", "!=="].includes(operator)) {
+        return this.getBooleanType();
+      }
+      if (["&&", "||"].includes(operator)) {
+        return this.mergeTypes([leftType, rightType]);
+      }
+      return this.getUnknownType();
+    }
+    analyzeConditionalExpression(node) {
+      const consequentNode = node.childForFieldName("consequence") || node.childForFieldName("then");
+      const alternateNode = node.childForFieldName("alternative") || node.childForFieldName("else");
+      if (!consequentNode || !alternateNode) return this.getUnknownType();
+      const consequentType = this.analyzeExpression(consequentNode);
+      const alternateType = this.analyzeExpression(alternateNode);
+      return this.mergeTypes([consequentType, alternateType]);
+    }
+    // Flow-sensitive analysis
+    analyzeControlFlow(node) {
+      const flowTypes = /* @__PURE__ */ new Map();
+      switch (node.type) {
+        case "if_statement":
+          return this.analyzeIfStatement(node);
+        case "while_statement":
+        case "for_statement":
+          return this.analyzeLoopStatement(node);
+        case "try_statement":
+          return this.analyzeTryStatement(node);
+        case "match_expression":
+        // Rust
+        case "switch_statement":
+          return this.analyzeMatchStatement(node);
+      }
+      return flowTypes;
+    }
+    analyzeIfStatement(node) {
+      const conditionNode = node.childForFieldName("condition");
+      const thenNode = node.childForFieldName("consequence") || node.childForFieldName("then");
+      const elseNode = node.childForFieldName("alternative") || node.childForFieldName("else");
+      const flowTypes = /* @__PURE__ */ new Map();
+      if (conditionNode) {
+        const typeGuards = this.extractTypeGuards(conditionNode);
+        typeGuards.forEach((type, variable) => {
+          flowTypes.set(variable, type);
+        });
+      }
+      return flowTypes;
+    }
+    extractTypeGuards(conditionNode) {
+      const guards = /* @__PURE__ */ new Map();
+      if (this.isTypeofCheck(conditionNode)) {
+        const variable = this.getTypeofVariable(conditionNode);
+        const typeString = this.getTypeofType(conditionNode);
+        if (variable && typeString) {
+          guards.set(variable, this.stringToType(typeString));
+        }
+      }
+      if (this.isInstanceofCheck(conditionNode)) {
+        const variable = this.getInstanceofVariable(conditionNode);
+        const className = this.getInstanceofClass(conditionNode);
+        if (variable && className) {
+          const classType = this.classTypes.get(className);
+          if (classType) {
+            guards.set(variable, classType);
+          }
+        }
+      }
+      if (this.isNullCheck(conditionNode)) {
+        const variable = this.getNullCheckVariable(conditionNode);
+        if (variable) {
+          const currentType = this.lookupVariableType(variable);
+          guards.set(variable, this.makeNonNullable(currentType));
+        }
+      }
+      return guards;
+    }
+    // Helper methods for type system
+    lookupVariableType(varName) {
+      const scopedName = this.getScopedName(varName);
+      return this.variableTypes.get(scopedName) || this.getUnknownType();
+    }
+    getScopedName(varName) {
+      if (this.scopeStack.length === 0) return varName;
+      return `${this.scopeStack.join(".")}.${varName}`;
+    }
+    mergeTypes(types) {
+      if (types.length === 0) return this.getUnknownType();
+      if (types.length === 1) return types[0];
+      const uniqueTypes = Array.from(new Set(types.map((t) => t.name)));
+      if (uniqueTypes.length === 1) {
+        return {
+          ...types[0],
+          confidence: Math.max(...types.map((t) => t.confidence))
+        };
+      }
+      return this.createUnionType(types);
+    }
+    createUnionType(types) {
+      return {
+        name: types.map((t) => t.name).join(" | "),
+        kind: "union" /* Union */,
+        unionTypes: types,
+        confidence: Math.max(...types.map((t) => t.confidence)) * 0.8,
+        inferredAt: []
+      };
+    }
+    // Built-in type getters
+    getUnknownType() {
+      return { name: "unknown", kind: "unknown" /* Unknown */, confidence: 0, inferredAt: [] };
+    }
+    getVoidType() {
+      return { name: "void", kind: "void" /* Void */, confidence: 1, inferredAt: [] };
+    }
+    getStringType() {
+      return { name: "string", kind: "primitive" /* Primitive */, confidence: 1, inferredAt: [] };
+    }
+    getNumberType() {
+      return { name: "number", kind: "primitive" /* Primitive */, confidence: 1, inferredAt: [] };
+    }
+    getBooleanType() {
+      return { name: "boolean", kind: "primitive" /* Primitive */, confidence: 1, inferredAt: [] };
+    }
+    getNullType() {
+      return { name: "null", kind: "literal" /* Literal */, confidence: 1, inferredAt: [] };
+    }
+    // Utility methods for AST navigation
+    nodeToRange(node) {
+      return {
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column + 1,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column + 1,
+        startIndex: node.startIndex,
+        endIndex: node.endIndex
+      };
+    }
+    findReturnStatements(node) {
+      const returns = [];
+      const traverse = (n) => {
+        if (n.type === "return_statement") {
+          const expression = n.childForFieldName("expression") || n.namedChild(0);
+          if (expression) returns.push(expression);
+        }
+        const children = n.namedChildren;
+        for (let i = 0; i < children.length; i++) {
+          traverse(children[i]);
+        }
+      };
+      traverse(node);
+      return returns;
+    }
+    getArrayElements(node) {
+      const elements = [];
+      const children = node.namedChildren;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child) elements.push(child);
+      }
+      return elements;
+    }
+    getObjectKey(pairNode) {
+      const keyNode = pairNode.childForFieldName("key") || pairNode.childForFieldName("name");
+      return keyNode ? keyNode.text : null;
+    }
+    getObjectValue(pairNode) {
+      return pairNode.childForFieldName("value") || pairNode.childForFieldName("expression");
+    }
+    getBinaryOperator(node) {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && ["operator", "+", "-", "*", "/", "==", "!=", "<", ">"].includes(child.type)) {
+          return child.text;
+        }
+      }
+      return "";
+    }
+    isConstructorCall(functionName) {
+      return /^[A-Z]/.test(functionName) || functionName === "new";
+    }
+    extractClassName(functionName) {
+      return functionName.replace(/^new\s+/, "");
+    }
+    isTypeofCheck(node) {
+      return node.text.includes("typeof");
+    }
+    isInstanceofCheck(node) {
+      return node.text.includes("instanceof");
+    }
+    isNullCheck(node) {
+      return node.text.includes("!= null") || node.text.includes("!== undefined");
+    }
+    getTypeofVariable(node) {
+      const match = node.text.match(/typeof\s+(\w+)/);
+      return match ? match[1] : null;
+    }
+    getTypeofType(node) {
+      const match = node.text.match(/===\s*['"](\w+)['"]/);
+      return match ? match[1] : null;
+    }
+    getInstanceofVariable(node) {
+      const match = node.text.match(/(\w+)\s+instanceof/);
+      return match ? match[1] : null;
+    }
+    getInstanceofClass(node) {
+      const match = node.text.match(/instanceof\s+(\w+)/);
+      return match ? match[1] : null;
+    }
+    getNullCheckVariable(node) {
+      const match = node.text.match(/(\w+)\s*!==?\s*(null|undefined)/);
+      return match ? match[1] : null;
+    }
+    stringToType(typeString) {
+      return this.classTypes.get(typeString) || {
+        name: typeString,
+        kind: "primitive" /* Primitive */,
+        confidence: 0.9,
+        inferredAt: []
+      };
+    }
+    makeNonNullable(type) {
+      return {
+        ...type,
+        nullable: false,
+        confidence: type.confidence * 0.95
+      };
+    }
+    inferMethodFromPatterns(objectType, methodName) {
+      const commonPatterns = {
+        // Array methods
+        "push": this.getNumberType(),
+        "pop": this.getUnknownType(),
+        "length": this.getNumberType(),
+        "size": this.getNumberType(),
+        "count": this.getNumberType(),
+        // String methods
+        "toString": this.getStringType(),
+        "toLowerCase": this.getStringType(),
+        "toUpperCase": this.getStringType(),
+        "substring": this.getStringType(),
+        "charAt": this.getStringType(),
+        // Boolean methods
+        "isEmpty": this.getBooleanType(),
+        "isNull": this.getBooleanType(),
+        "hasValue": this.getBooleanType()
+      };
+      return commonPatterns[methodName] || this.getUnknownType();
+    }
+    analyzeLoopStatement(node) {
+      return /* @__PURE__ */ new Map();
+    }
+    analyzeTryStatement(node) {
+      return /* @__PURE__ */ new Map();
+    }
+    analyzeMatchStatement(node) {
+      return /* @__PURE__ */ new Map();
+    }
+    // Scope management
+    enterScope(scopeName) {
+      this.scopeStack.push(scopeName);
+    }
+    exitScope() {
+      this.scopeStack.pop();
+    }
+    getCurrentScope() {
+      return this.scopeStack.join(".");
+    }
+    // Type registration for classes and functions
+    registerClass(className, classInfo) {
+      this.classTypes.set(className, classInfo);
+    }
+    registerFunction(functionName, signature) {
+      this.functionTypes.set(functionName, signature);
+    }
+    // Export current state for inter-procedural analysis
+    getTypeSnapshot() {
+      return {
+        variables: new Map(this.variableTypes),
+        functions: new Map(this.functionTypes),
+        classes: new Map(this.classTypes)
+      };
+    }
+  }
+  TypeInference2.InferenceContext = InferenceContext;
+  class TypeInferenceEngine {
+    contexts = /* @__PURE__ */ new Map();
+    createContext(filePath, language) {
+      const context = new InferenceContext(language, filePath);
+      this.contexts.set(filePath, context);
+      return context;
+    }
+    getContext(filePath) {
+      return this.contexts.get(filePath) || null;
+    }
+    inferTypesForFile(rootNode, content, filePath, language) {
+      const context = this.createContext(filePath, language);
+      const inferredTypes = /* @__PURE__ */ new Map();
+      this.traverseAndInferTypes(rootNode, context, inferredTypes);
+      return inferredTypes;
+    }
+    traverseAndInferTypes(node, context, inferredTypes) {
+      if (this.isVariableDeclaration(node)) {
+        const varName = this.getVariableName(node);
+        const initExpr = this.getVariableInitializer(node);
+        if (varName && initExpr) {
+          const inferredType = context.inferVariableType(
+            varName,
+            initExpr,
+            "declaration" /* Declaration */
+          );
+          inferredTypes.set(varName, inferredType);
+        }
+      }
+      if (this.isFunctionDeclaration(node)) {
+        const funcName = this.getFunctionName(node);
+        const bodyNode = this.getFunctionBody(node);
+        if (funcName && bodyNode) {
+          context.enterScope(funcName);
+          const returnType = context.inferFunctionReturnType(funcName, bodyNode);
+          context.exitScope();
+          inferredTypes.set(`${funcName}:return`, returnType);
+        }
+      }
+      const flowTypes = context.analyzeControlFlow(node);
+      flowTypes.forEach((type, variable) => {
+        inferredTypes.set(variable, type);
+      });
+      const children = node.namedChildren;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child) {
+          this.traverseAndInferTypes(child, context, inferredTypes);
+        }
+      }
+    }
+    // Cross-file type resolution
+    resolveTypesAcrossFiles(filePaths) {
+      const globalTypes = /* @__PURE__ */ new Map();
+      filePaths.forEach((filePath) => {
+        const context = this.getContext(filePath);
+        if (context) {
+          const snapshot = context.getTypeSnapshot();
+          snapshot.classes.forEach((classInfo, className) => {
+            if (!globalTypes.has(className) || classInfo.confidence > globalTypes.get(className).confidence) {
+              globalTypes.set(className, classInfo);
+            }
+          });
+        }
+      });
+      filePaths.forEach((filePath) => {
+        const context = this.getContext(filePath);
+        if (context) {
+          globalTypes.forEach((typeInfo, typeName) => {
+            context.registerClass(typeName, typeInfo);
+          });
+        }
+      });
+      return globalTypes;
+    }
+    // Language-agnostic AST node detection
+    isVariableDeclaration(node) {
+      const varDeclarationTypes = [
+        "variable_declaration",
+        "let_declaration",
+        "const_declaration",
+        "var_declaration",
+        "local_variable_declaration",
+        "assignment_statement"
+      ];
+      return varDeclarationTypes.includes(node.type);
+    }
+    isFunctionDeclaration(node) {
+      const funcDeclarationTypes = [
+        "function_declaration",
+        "function_definition",
+        "method_declaration",
+        "def",
+        "defn",
+        "fn",
+        "func"
+      ];
+      return funcDeclarationTypes.includes(node.type);
+    }
+    getVariableName(node) {
+      const nameNode = node.childForFieldName("name") || node.childForFieldName("identifier") || node.childForFieldName("pattern");
+      return nameNode ? nameNode.text : null;
+    }
+    getVariableInitializer(node) {
+      return node.childForFieldName("value") || node.childForFieldName("initializer") || node.childForFieldName("expression");
+    }
+    getFunctionName(node) {
+      const nameNode = node.childForFieldName("name") || node.childForFieldName("identifier");
+      return nameNode ? nameNode.text : null;
+    }
+    getFunctionBody(node) {
+      return node.childForFieldName("body") || node.childForFieldName("block") || node.childForFieldName("compound_statement");
+    }
+  }
+  TypeInference2.TypeInferenceEngine = TypeInferenceEngine;
+  function enhanceAnalyzerWithTypeInference(analyzer, language) {
+    const engine = new TypeInferenceEngine();
+    return {
+      analyze(rootNode, content, filePath, context) {
+        const result = analyzer.analyze(rootNode, content, filePath, context);
+        const inferredTypes = engine.inferTypesForFile(rootNode, content, filePath, language);
+        result.symbols.forEach((symbol) => {
+          const typeInfo = inferredTypes.get(symbol.name);
+          if (typeInfo) {
+            symbol.metadata = {
+              ...symbol.metadata,
+              inferredType: typeInfo,
+              typeConfidence: typeInfo.confidence,
+              typeInferenceReasons: typeInfo.inferredAt.map((loc) => loc.reason)
+            };
+          }
+        });
+        const typeRelationships = [];
+        inferredTypes.forEach((typeInfo, symbolName) => {
+          if (typeInfo.superTypes) {
+            typeInfo.superTypes.forEach((superType) => {
+              typeRelationships.push({
+                source: symbolName,
+                target: superType.name,
+                type: ASTEngine.RelationshipType.Extends,
+                confidence: typeInfo.confidence,
+                metadata: {
+                  inferredFromTypes: true,
+                  typeInference: true
+                }
+              });
+            });
+          }
+        });
+        result.relationships.push(...typeRelationships);
+        return result;
+      }
+    };
+  }
+  TypeInference2.enhanceAnalyzerWithTypeInference = enhanceAnalyzerWithTypeInference;
+})(TypeInference || (TypeInference = {}));
+
+export {
+  TypeInference
+};