scriptoriumadmin/GitNexus
1
0
Fork 0
mirror of https://github.com/abhigyanpatwari/GitNexus.git synced 2026-10-06 02:49:56 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

removed any types from call-processor.ts

Browse source
This commit is contained in:
abhigyantrumio 2025-08-05 10:20:00 +05:30
parent 9e6ea8823c
commit bbb9cb365e
1 changed files with 39 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
src/core/ingestion/call-processor.ts
View file

@ -1,11 +1,25 @@
import type { KnowledgeGraph, GraphNode, GraphRelationship } from '../graph/types.ts';
import { generateId } from '../../lib/utils.ts';
import type Parser from 'web-tree-sitter';
// Tree-sitter AST node type definitions
interface TreeSitterNode {
type: string;
text: string;
childCount: number;
startPosition: { row: number; column: number };
parent?: TreeSitterNode;
children: TreeSitterNode[];
child(index: number): TreeSitterNode | null;
childForFieldName(fieldName: string): TreeSitterNode | null;
}
interface TreeSitterAST {
rootNode: TreeSitterNode;
}
export interface CallResolutionInput {
graph: KnowledgeGraph;
astCache: Map<string, any>;
astCache: Map<string, TreeSitterAST>;
fileContents: Map<string, string>;
}
@ -77,7 +91,7 @@ export class CallProcessor {
if (this.isPythonFile(filePath)) {
const content = fileContents.get(filePath);
if (content && ast) {
await this.extractImports(filePath, ast, content);
await this.extractImports(filePath, ast);
}
}
}
@ -101,7 +115,7 @@ export class CallProcessor {
if (this.isPythonFile(filePath)) {
const content = fileContents.get(filePath);
if (content && ast) {
await this.processFunctionCalls(graph, filePath, ast, content);
await this.processFunctionCalls(graph, filePath, ast);
}
}
}
@ -243,13 +257,13 @@ export class CallProcessor {
}
// Getter methods often return specific types
else if (methodName.startsWith('get_')) {
returnType = this.inferGetterReturnType(methodName, className);
returnType = this.inferGetterReturnType(methodName);
}
// Property methods (decorated with @property) return the property type
else if (methodNode.properties.decorators) {
const decorators = methodNode.properties.decorators as string[];
if (decorators.includes('property')) {
returnType = this.inferPropertyReturnType(methodName, className);
returnType = this.inferPropertyReturnType(methodName);
}
}
@ -288,7 +302,7 @@ export class CallProcessor {
return undefined;
}
private inferGetterReturnType(methodName: string, className: string): string | undefined {
private inferGetterReturnType(methodName: string): string | undefined {
// Common getter patterns
if (methodName === 'get_name' || methodName === 'get_title') return 'str';
if (methodName === 'get_id' || methodName === 'get_count') return 'int';
@ -300,7 +314,7 @@ export class CallProcessor {
return undefined;
}
private inferPropertyReturnType(methodName: string, className: string): string | undefined {
private inferPropertyReturnType(methodName: string): string | undefined {
// Property return type inference based on naming patterns
if (methodName === 'name' || methodName === 'title' || methodName === 'description') return 'str';
if (methodName === 'id' || methodName === 'count' || methodName === 'size') return 'int';
@ -314,10 +328,10 @@ export class CallProcessor {
return str.charAt(0).toUpperCase() + str.slice(1);
}
private async extractImports(filePath: string, ast: any, content: string): Promise<void> {
private async extractImports(filePath: string, ast: TreeSitterAST): Promise<void> {
const imports: ImportInfo[] = [];
this.traverseNode(ast.rootNode, (node: any) => {
this.traverseNode(ast.rootNode, (node: TreeSitterNode) => {
if (node.type === 'import_statement') {
this.processImportStatement(node, imports, filePath);
} else if (node.type === 'import_from_statement') {
@ -328,13 +342,13 @@ export class CallProcessor {
this.importCache.set(filePath, imports);
}
private processImportStatement(node: any, imports: ImportInfo[], filePath: string): void {
private processImportStatement(node: TreeSitterNode, imports: ImportInfo[], filePath: string): void {
const nameNode = node.childForFieldName('name');
if (nameNode) {
const moduleName = nameNode.text;
// Handle aliased imports (import module as alias)
const asNode = node.children.find((child: any) => child.type === 'as_pattern');
const asNode = node.children.find((child: TreeSitterNode) => child.type === 'as_pattern');
const alias = asNode ? asNode.childForFieldName('alias')?.text : undefined;
imports.push({
@ -347,14 +361,14 @@ export class CallProcessor {
}
}
private processImportFromStatement(node: any, imports: ImportInfo[], filePath: string): void {
private processImportFromStatement(node: TreeSitterNode, imports: ImportInfo[], filePath: string): void {
const moduleNameNode = node.childForFieldName('module_name');
const importListNode = node.children.find((child: any) => child.type === 'import_list');
const importListNode = node.children.find((child: TreeSitterNode) => child.type === 'import_list');
if (moduleNameNode && importListNode) {
const moduleName = moduleNameNode.text;
this.traverseNode(importListNode, (child: any) => {
this.traverseNode(importListNode, (child: TreeSitterNode) => {
if (child.type === 'dotted_name' || child.type === 'identifier') {
const importedName = child.text;
imports.push({
@ -384,13 +398,12 @@ export class CallProcessor {
private async processFunctionCalls(
graph: KnowledgeGraph,
filePath: string,
ast: any,
content: string
ast: TreeSitterAST
): Promise<void> {
const functionCalls: FunctionCall[] = [];
let currentFunction: string | null = null;
this.traverseNode(ast.rootNode, (node: any) => {
this.traverseNode(ast.rootNode, (node: TreeSitterNode) => {
// Track current function context
if (node.type === 'function_definition') {
const nameNode = node.childForFieldName('name');
@ -406,7 +419,7 @@ export class CallProcessor {
// Find function calls
if (node.type === 'call') {
const callInfo = this.extractCallInfo(node, filePath, currentFunction, content);
const callInfo = this.extractCallInfo(node, filePath, currentFunction);
if (callInfo) {
// Check if this call is part of an assignment
const assignmentInfo = this.extractAssignmentInfo(node);
@ -430,7 +443,7 @@ export class CallProcessor {
}
}
private processVariableAssignment(assignmentNode: any, filePath: string, currentFunction: string | null): void {
private processVariableAssignment(assignmentNode: TreeSitterNode, filePath: string, currentFunction: string | null): void {
const leftNode = assignmentNode.childForFieldName('left');
const rightNode = assignmentNode.childForFieldName('right');
@ -455,7 +468,7 @@ export class CallProcessor {
}
}
private extractAssignmentInfo(callNode: any): { variableName: string } | null {
private extractAssignmentInfo(callNode: TreeSitterNode): { variableName: string } | null {
// Walk up the AST to find if this call is part of an assignment
let parent = callNode.parent;
@ -563,10 +576,9 @@ export class CallProcessor {
}
private extractCallInfo(
callNode: any,
callNode: TreeSitterNode,
filePath: string,
currentFunction: string | null,
content: string
currentFunction: string | null
): FunctionCall | null {
const functionNode = callNode.childForFieldName('function');
if (!functionNode) return null;
@ -609,7 +621,7 @@ export class CallProcessor {
}
// Check if the object is a variable with known type (for chained calls)
let objectName = objectNode.text;
const objectName = objectNode.text;
let chainedFromVariable: string | undefined;
if (objectNode.type === 'identifier') {
@ -860,9 +872,8 @@ export class CallProcessor {
private applyDjangoHeuristics(call: FunctionCall, candidates: GraphNode[]): GraphNode[] {
// Prefer models.py for model-related functions, views.py for view functions, etc.
return candidates.sort((a, b) => {
return candidates.sort((a) => {
const pathA = a.properties.filePath as string;
const pathB = b.properties.filePath as string;
if (call.callerFilePath.includes('views.py') && pathA.includes('models.py')) {
return -1; // Prefer models.py when called from views.py
@ -1194,7 +1205,7 @@ export class CallProcessor {
};
}
private traverseNode(node: any, callback: (node: any) => void): void {
private traverseNode(node: TreeSitterNode, callback: (node: TreeSitterNode) => void): void {
callback(node);
for (let i = 0; i < node.childCount; i++) {