/**

* Python Framework Resolver

*

* Handles Django, Flask, and FastAPI patterns.

*/

import { Node } from '../../types';

import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContext } from '../types';

export const djangoResolver: FrameworkResolver = {

name: 'django',

detect(context: ResolutionContext): boolean {

// Check for Django in requirements.txt or setup.py

const requirements = context.readFile('requirements.txt');

if (requirements && requirements.includes('django')) {

return true;

}

const setup = context.readFile('setup.py');

if (setup && setup.includes('django')) {

return true;

}

const pyproject = context.readFile('pyproject.toml');

if (pyproject && pyproject.includes('django')) {

return true;

}

// Check for manage.py (Django signature)

return context.fileExists('manage.py');

},

resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {

// Pattern 1: Model references

if (ref.referenceName.endsWith('Model') || /^[A-Z][a-z]+$/.test(ref.referenceName)) {

const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, MODEL_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.8,

resolvedBy: 'framework',

};

}

}

// Pattern 2: View references

if (ref.referenceName.endsWith('View') || ref.referenceName.endsWith('ViewSet')) {

const result = resolveByNameAndKind(ref.referenceName, VIEW_KINDS, VIEW_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.8,

resolvedBy: 'framework',

};

}

}

// Pattern 3: Form references

if (ref.referenceName.endsWith('Form')) {

const result = resolveByNameAndKind(ref.referenceName, CLASS_KINDS, FORM_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.8,

resolvedBy: 'framework',

};

}

}

return null;

},

extractNodes(filePath: string, content: string): Node[] {

const nodes: Node[] = [];

const now = Date.now();

// Extract URL patterns

// path('route/', view, name='name')

const urlPatterns = [

/path\s*\(\s*['"]([^'"]+)['"],\s*(\w+)/g,

/url\s*\(\s*r?['"]([^'"]+)['"],\s*(\w+)/g,

];

for (const pattern of urlPatterns) {

let match;

while ((match = pattern.exec(content)) !== null) {

const [, urlPath] = match;

const line = content.slice(0, match.index).split('\n').length;

nodes.push({

id: `route:${filePath}:${urlPath}:${line}`,

kind: 'route',

name: urlPath!,

qualifiedName: `${filePath}::route:${urlPath}`,

filePath,

startLine: line,

endLine: line,

startColumn: 0,

endColumn: match[0].length,

language: 'python',

updatedAt: now,

});

}

}

return nodes;

},

};

export const flaskResolver: FrameworkResolver = {

name: 'flask',

detect(context: ResolutionContext): boolean {

const requirements = context.readFile('requirements.txt');

if (requirements && (requirements.includes('flask') || requirements.includes('Flask'))) {

return true;

}

const pyproject = context.readFile('pyproject.toml');

if (pyproject && pyproject.includes('flask')) {

return true;

}

// Check for Flask app pattern in common files

const appFiles = ['app.py', 'application.py', 'main.py', '__init__.py'];

for (const file of appFiles) {

const content = context.readFile(file);

if (content && content.includes('Flask(__name__)')) {

return true;

}

}

return false;

},

resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {

// Pattern 1: Blueprint references

if (ref.referenceName.endsWith('_bp') || ref.referenceName.endsWith('_blueprint')) {

const result = resolveByNameAndKind(ref.referenceName, VARIABLE_KINDS, [], context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.8,

resolvedBy: 'framework',

};

}

}

return null;

},

extractNodes(filePath: string, content: string): Node[] {

const nodes: Node[] = [];

const now = Date.now();

// Extract Flask route decorators

// @app.route('/path') or @blueprint.route('/path')

const routePattern = /@(\w+)\.route\s*\(\s*['"]([^'"]+)['"]/g;

let match;

while ((match = routePattern.exec(content)) !== null) {

const [, _appOrBp, routePath] = match;

const line = content.slice(0, match.index).split('\n').length;

nodes.push({

id: `route:${filePath}:${routePath}:${line}`,

kind: 'route',

name: `${routePath}`,

qualifiedName: `${filePath}::route:${routePath}`,

filePath,

startLine: line,

endLine: line,

startColumn: 0,

endColumn: match[0].length,

language: 'python',

updatedAt: now,

});

}

return nodes;

},

};

export const fastapiResolver: FrameworkResolver = {

name: 'fastapi',

detect(context: ResolutionContext): boolean {

const requirements = context.readFile('requirements.txt');

if (requirements && requirements.includes('fastapi')) {

return true;

}

const pyproject = context.readFile('pyproject.toml');

if (pyproject && pyproject.includes('fastapi')) {

return true;

}

// Check for FastAPI app pattern

const appFiles = ['app.py', 'main.py', 'api.py'];

for (const file of appFiles) {

const content = context.readFile(file);

if (content && content.includes('FastAPI()')) {

return true;

}

}

return false;

},

resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {

// Pattern 1: Router references

if (ref.referenceName.endsWith('_router') || ref.referenceName === 'router') {

const result = resolveByNameAndKind(ref.referenceName, VARIABLE_KINDS, ROUTER_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.8,

resolvedBy: 'framework',

};

}

}

// Pattern 2: Dependency references

if (ref.referenceName.startsWith('get_') || ref.referenceName.startsWith('Depends')) {

const result = resolveByNameAndKind(ref.referenceName, FUNCTION_KINDS, DEP_DIRS, context);

if (result) {

return {

original: ref,

targetNodeId: result,

confidence: 0.75,

resolvedBy: 'framework',

};

}

}

return null;

},

extractNodes(filePath: string, content: string): Node[] {

const nodes: Node[] = [];

const now = Date.now();

// Extract FastAPI route decorators

// @app.get('/path') or @router.post('/path')

const routePattern = /@(\w+)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"]([^'"]+)['"]/g;

let match;

while ((match = routePattern.exec(content)) !== null) {

const [, _appOrRouter, method, routePath] = match;

const line = content.slice(0, match.index).split('\n').length;

nodes.push({

id: `route:${filePath}:${method!.toUpperCase()}:${routePath}:${line}`,

kind: 'route',

name: `${method!.toUpperCase()} ${routePath}`,

qualifiedName: `${filePath}::${method!.toUpperCase()}:${routePath}`,

filePath,

startLine: line,

endLine: line,

startColumn: 0,

endColumn: match[0].length,

language: 'python',

updatedAt: now,

});

}

return nodes;

},

};

// Directory patterns

const MODEL_DIRS = ['models', 'app/models', 'src/models'];

const VIEW_DIRS = ['views', 'app/views', 'src/views', 'api/views'];

const FORM_DIRS = ['forms', 'app/forms', 'src/forms'];

const ROUTER_DIRS = ['/routers/', '/api/', '/routes/', '/endpoints/'];

const DEP_DIRS = ['/dependencies/', '/deps/', '/core/'];

const CLASS_KINDS = new Set(['class']);

const VIEW_KINDS = new Set(['class', 'function']);

const VARIABLE_KINDS = new Set(['variable']);

const FUNCTION_KINDS = new Set(['function']);

/**

* Resolve a symbol by name using indexed queries instead of scanning all files.

*/

function resolveByNameAndKind(

name: string,

kinds: Set<string>,

preferredDirPatterns: string[],

context: ResolutionContext,

): string | null {

const candidates = context.getNodesByName(name);

if (candidates.length === 0) return null;

const kindFiltered = candidates.filter((n) => kinds.has(n.kind));

if (kindFiltered.length === 0) return null;

// Prefer candidates in framework-conventional directories

if (preferredDirPatterns.length > 0) {

const preferred = kindFiltered.filter((n) =>

preferredDirPatterns.some((d) => n.filePath.includes(d))

);

if (preferred.length > 0) return preferred[0]!.id;

}

// Fall back to any match

return kindFiltered[0]!.id;

}