@saluzi/codegraph 0.1.0

package/dist/resolution/frameworks/python.js

@@ -0,0 +1,278 @@
+"use strict";
+/**
+ * Python Framework Resolver
+ *
+ * Handles Django, Flask, and FastAPI patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastapiResolver = exports.flaskResolver = exports.djangoResolver = void 0;
+const strip_comments_1 = require("../strip-comments");
+exports.djangoResolver = {
+    name: 'django',
+    languages: ['python'],
+    detect(context) {
+        const requirements = context.readFile('requirements.txt');
+        if (requirements && requirements.toLowerCase().includes('django'))
+            return true;
+        const setup = context.readFile('setup.py');
+        if (setup && setup.toLowerCase().includes('django'))
+            return true;
+        const pyproject = context.readFile('pyproject.toml');
+        if (pyproject && pyproject.toLowerCase().includes('django'))
+            return true;
+        return context.fileExists('manage.py');
+    },
+    resolve(ref, context) {
+        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' };
+        }
+        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' };
+        }
+        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;
+    },
+    extract(filePath, content) {
+        if (!filePath.endsWith('.py'))
+            return { nodes: [], references: [] };
+        const nodes = [];
+        const references = [];
+        const now = Date.now();
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'python');
+        // path('url', handler, name=...) / re_path(r'...', handler) / url(r'...', handler)
+        // Capture groups: 1=function name, 2=url string, 3=handler expr
+        // Handler expr may contain one balanced () pair (e.g. View.as_view(), include('x.y'))
+        const routeRegex = /\b(path|re_path|url)\s*\(\s*r?['"]([^'"]+)['"]\s*,\s*([\w.]+(?:\s*\([^)]*\))?)/g;
+        let match;
+        while ((match = routeRegex.exec(safe)) !== null) {
+            const [, _fn, urlPath, handlerExpr] = match;
+            const line = safe.slice(0, match.index).split('\n').length;
+            const routeNode = {
+                id: `route:${filePath}:${line}:${urlPath}`,
+                kind: 'route',
+                name: urlPath,
+                qualifiedName: `${filePath}::route:${urlPath}`,
+                filePath,
+                startLine: line,
+                endLine: line,
+                startColumn: 0,
+                endColumn: match[0].length,
+                language: 'python',
+                updatedAt: now,
+            };
+            nodes.push(routeNode);
+            const handler = handlerExpr.trim();
+            const target = resolveHandlerName(handler);
+            if (target) {
+                references.push({
+                    fromNodeId: routeNode.id,
+                    referenceName: target.name,
+                    referenceKind: target.kind,
+                    line,
+                    column: 0,
+                    filePath,
+                    language: 'python',
+                });
+            }
+        }
+        return { nodes, references };
+    },
+};
+/**
+ * Parse a Django URL handler expression and return the symbol/module to link.
+ * Returns null for shapes we can't confidently link (e.g. lambdas).
+ */
+function resolveHandlerName(expr) {
+    // include('module.path')
+    const includeMatch = expr.match(/^include\s*\(\s*['"]([^'"]+)['"]/);
+    if (includeMatch)
+        return { name: includeMatch[1], kind: 'imports' };
+    // Strip trailing .as_view(...) or .as_view()
+    let head = expr.replace(/\.as_view\s*\([^)]*\)\s*$/, '');
+    // Drop any other trailing method call
+    head = head.replace(/\.\w+\s*\([^)]*\)\s*$/, '');
+    const dotted = head.split('.').filter(Boolean);
+    if (dotted.length === 0)
+        return null;
+    const last = dotted[dotted.length - 1];
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(last))
+        return null;
+    return { name: last, kind: 'references' };
+}
+exports.flaskResolver = {
+    name: 'flask',
+    languages: ['python'],
+    detect(context) {
+        const requirements = context.readFile('requirements.txt');
+        if (requirements && /\bflask\b/i.test(requirements))
+            return true;
+        const pyproject = context.readFile('pyproject.toml');
+        if (pyproject && /\bflask\b/i.test(pyproject))
+            return true;
+        for (const file of ['app.py', 'application.py', 'main.py', '__init__.py']) {
+            const content = context.readFile(file);
+            if (content && content.includes('Flask(__name__)'))
+                return true;
+        }
+        return false;
+    },
+    resolve(ref, context) {
+        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;
+    },
+    extract(filePath, content) {
+        if (!filePath.endsWith('.py'))
+            return { nodes: [], references: [] };
+        return extractDecoratorRoutes(filePath, (0, strip_comments_1.stripCommentsForRegex)(content, 'python'), {
+            // Flask: @x.route('/path', methods=[...])
+            decoratorRegex: /@(\w+)\.route\s*\(\s*['"]([^'"]+)['"](?:\s*,\s*methods\s*=\s*\[([^\]]+)\])?\s*\)\s*\n\s*(?:async\s+)?def\s+(\w+)/g,
+            defaultMethod: 'GET',
+            methodFromGroup: 3,
+            pathGroup: 2,
+            handlerGroup: 4,
+            language: 'python',
+        });
+    },
+};
+exports.fastapiResolver = {
+    name: 'fastapi',
+    languages: ['python'],
+    detect(context) {
+        const requirements = context.readFile('requirements.txt');
+        if (requirements && /\bfastapi\b/i.test(requirements))
+            return true;
+        const pyproject = context.readFile('pyproject.toml');
+        if (pyproject && /\bfastapi\b/i.test(pyproject))
+            return true;
+        for (const file of ['app.py', 'main.py', 'api.py']) {
+            const content = context.readFile(file);
+            if (content && content.includes('FastAPI('))
+                return true;
+        }
+        return false;
+    },
+    resolve(ref, context) {
+        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' };
+        }
+        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;
+    },
+    extract(filePath, content) {
+        if (!filePath.endsWith('.py'))
+            return { nodes: [], references: [] };
+        return extractDecoratorRoutes(filePath, (0, strip_comments_1.stripCommentsForRegex)(content, 'python'), {
+            // FastAPI: @x.METHOD('/path') -> handler on the next def line
+            decoratorRegex: /@(\w+)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"]([^'"]+)['"]/g,
+            defaultMethod: '',
+            methodGroup: 2,
+            pathGroup: 3,
+            findHandler: true,
+            language: 'python',
+        });
+    },
+};
+function extractDecoratorRoutes(filePath, content, opts) {
+    const nodes = [];
+    const references = [];
+    const now = Date.now();
+    let match;
+    while ((match = opts.decoratorRegex.exec(content)) !== null) {
+        const routePath = match[opts.pathGroup];
+        let method = opts.defaultMethod;
+        if (opts.methodGroup && match[opts.methodGroup]) {
+            method = match[opts.methodGroup].toUpperCase();
+        }
+        else if (opts.methodFromGroup && match[opts.methodFromGroup]) {
+            const m = match[opts.methodFromGroup].match(/['"]([A-Z]+)['"]/i);
+            if (m)
+                method = m[1].toUpperCase();
+        }
+        const line = content.slice(0, match.index).split('\n').length;
+        const name = method ? `${method} ${routePath}` : routePath;
+        const routeNode = {
+            id: `route:${filePath}:${line}:${method}:${routePath}`,
+            kind: 'route',
+            name,
+            qualifiedName: `${filePath}::${method}:${routePath}`,
+            filePath,
+            startLine: line,
+            endLine: line,
+            startColumn: 0,
+            endColumn: match[0].length,
+            language: opts.language,
+            updatedAt: now,
+        };
+        nodes.push(routeNode);
+        let handlerName;
+        if (opts.handlerGroup && match[opts.handlerGroup]) {
+            handlerName = match[opts.handlerGroup];
+        }
+        else if (opts.findHandler) {
+            const tail = content.slice(match.index + match[0].length);
+            const defMatch = tail.match(/\n\s*(?:async\s+)?def\s+(\w+)/);
+            if (defMatch)
+                handlerName = defMatch[1];
+        }
+        if (handlerName) {
+            references.push({
+                fromNodeId: routeNode.id,
+                referenceName: handlerName,
+                referenceKind: 'references',
+                line,
+                column: 0,
+                filePath,
+                language: 'python',
+            });
+        }
+    }
+    return { nodes, references };
+}
+// 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, kinds, preferredDirPatterns, context) {
+    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;
+}
+//# sourceMappingURL=python.js.map

package/dist/resolution/frameworks/react.d.ts

@@ -0,0 +1,8 @@
+/**
+ * React Framework Resolver
+ *
+ * Handles React and Next.js patterns.
+ */
+import { FrameworkResolver } from '../types'
+export declare const reactResolver: FrameworkResolver
+//# sourceMappingURL=react.d.ts.map

package/dist/resolution/frameworks/react.js

@@ -0,0 +1,272 @@
+"use strict";
+/**
+ * React Framework Resolver
+ *
+ * Handles React and Next.js patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactResolver = void 0;
+exports.reactResolver = {
+    name: 'react',
+    languages: ['javascript', 'typescript'],
+    detect(context) {
+        // Check for React in package.json
+        const packageJson = context.readFile('package.json');
+        if (packageJson) {
+            try {
+                const pkg = JSON.parse(packageJson);
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (deps.react || deps.next || deps['react-native']) {
+                    return true;
+                }
+            }
+            catch {
+                // Invalid JSON
+            }
+        }
+        // Check for .jsx/.tsx files
+        const allFiles = context.getAllFiles();
+        return allFiles.some((f) => f.endsWith('.jsx') || f.endsWith('.tsx'));
+    },
+    resolve(ref, context) {
+        // Pattern 1: Component references (PascalCase)
+        if (isPascalCase(ref.referenceName) && !isBuiltInType(ref.referenceName)) {
+            const result = resolveComponent(ref.referenceName, ref.filePath, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.8,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 2: Hook references (use*)
+        if (ref.referenceName.startsWith('use') && ref.referenceName.length > 3) {
+            const result = resolveHook(ref.referenceName, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.85,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 3: Context references
+        if (ref.referenceName.endsWith('Context') || ref.referenceName.endsWith('Provider')) {
+            const result = resolveContext(ref.referenceName, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.8,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        return null;
+    },
+    extract(filePath, content) {
+        const nodes = [];
+        const now = Date.now();
+        // Extract component definitions
+        // function Component() or const Component = () =>
+        const componentPatterns = [
+            // Function components
+            /(?:export\s+)?function\s+([A-Z][a-zA-Z0-9]*)\s*\(/g,
+            // Arrow function components
+            /(?:export\s+)?(?:const|let)\s+([A-Z][a-zA-Z0-9]*)\s*=\s*(?:\([^)]*\)|[a-zA-Z_][a-zA-Z0-9_]*)\s*=>/g,
+            // forwardRef components
+            /(?:export\s+)?(?:const|let)\s+([A-Z][a-zA-Z0-9]*)\s*=\s*(?:React\.)?forwardRef/g,
+            // memo components
+            /(?:export\s+)?(?:const|let)\s+([A-Z][a-zA-Z0-9]*)\s*=\s*(?:React\.)?memo/g,
+        ];
+        for (const pattern of componentPatterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                const [fullMatch, name] = match;
+                const line = content.slice(0, match.index).split('\n').length;
+                // Check if it returns JSX (rough heuristic)
+                const afterMatch = content.slice(match.index + fullMatch.length, match.index + fullMatch.length + 500);
+                const hasJSX = afterMatch.includes('<') && (afterMatch.includes('/>') || afterMatch.includes('</'));
+                if (hasJSX) {
+                    nodes.push({
+                        id: `component:${filePath}:${name}:${line}`,
+                        kind: 'component',
+                        name: name,
+                        qualifiedName: `${filePath}::${name}`,
+                        filePath,
+                        startLine: line,
+                        endLine: line,
+                        startColumn: 0,
+                        endColumn: fullMatch.length,
+                        language: filePath.endsWith('.tsx') ? 'tsx' : 'jsx',
+                        isExported: fullMatch.includes('export'),
+                        updatedAt: now,
+                    });
+                }
+            }
+        }
+        // Extract custom hooks
+        const hookPattern = /(?:export\s+)?(?:function|const|let)\s+(use[A-Z][a-zA-Z0-9]*)\s*[=(]/g;
+        let hookMatch;
+        while ((hookMatch = hookPattern.exec(content)) !== null) {
+            const [fullMatch, name] = hookMatch;
+            const line = content.slice(0, hookMatch.index).split('\n').length;
+            nodes.push({
+                id: `hook:${filePath}:${name}:${line}`,
+                kind: 'function',
+                name: name,
+                qualifiedName: `${filePath}::${name}`,
+                filePath,
+                startLine: line,
+                endLine: line,
+                startColumn: 0,
+                endColumn: fullMatch.length,
+                language: filePath.endsWith('.ts') || filePath.endsWith('.tsx') ? 'typescript' : 'javascript',
+                isExported: fullMatch.includes('export'),
+                updatedAt: now,
+            });
+        }
+        // Extract Next.js pages/routes (pages directory convention)
+        if (filePath.includes('pages/') || filePath.includes('app/')) {
+            // Default export in pages becomes a route
+            if (content.includes('export default')) {
+                const routePath = filePathToRoute(filePath);
+                if (routePath) {
+                    const line = content.indexOf('export default');
+                    const lineNum = content.slice(0, line).split('\n').length;
+                    nodes.push({
+                        id: `route:${filePath}:${routePath}:${lineNum}`,
+                        kind: 'route',
+                        name: routePath,
+                        qualifiedName: `${filePath}::route:${routePath}`,
+                        filePath,
+                        startLine: lineNum,
+                        endLine: lineNum,
+                        startColumn: 0,
+                        endColumn: 0,
+                        language: filePath.endsWith('.tsx') ? 'tsx' : filePath.endsWith('.ts') ? 'typescript' : 'javascript',
+                        updatedAt: now,
+                    });
+                }
+            }
+        }
+        return { nodes, references: [] };
+    },
+};
+/**
+ * Check if string is PascalCase
+ */
+function isPascalCase(str) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+}
+/**
+ * Check if name is a built-in type
+ */
+function isBuiltInType(name) {
+    return BUILT_IN_TYPES.has(name);
+}
+const BUILT_IN_TYPES = new Set([
+    'Array', 'Boolean', 'Date', 'Error', 'Function', 'JSON', 'Math', 'Number',
+    'Object', 'Promise', 'RegExp', 'String', 'Symbol', 'Map', 'Set', 'WeakMap', 'WeakSet',
+    'React', 'Component', 'Fragment', 'Suspense', 'StrictMode',
+]);
+const COMPONENT_KINDS = new Set(['component', 'function', 'class']);
+/**
+ * Resolve a component reference using name-based lookup
+ */
+function resolveComponent(name, fromFile, context) {
+    const candidates = context.getNodesByName(name);
+    if (candidates.length === 0)
+        return null;
+    const components = candidates.filter((n) => COMPONENT_KINDS.has(n.kind));
+    if (components.length === 0)
+        return null;
+    // Prefer same directory
+    const fromDir = fromFile.substring(0, fromFile.lastIndexOf('/'));
+    const sameDir = components.filter((n) => n.filePath.startsWith(fromDir));
+    if (sameDir.length > 0)
+        return sameDir[0].id;
+    // Prefer component directories
+    const COMPONENT_DIRS = ['/components/', '/src/components/', '/app/components/', '/pages/', '/src/pages/', '/views/', '/src/views/'];
+    const preferred = components.filter((n) => COMPONENT_DIRS.some((d) => n.filePath.includes(d)));
+    if (preferred.length > 0)
+        return preferred[0].id;
+    return components[0].id;
+}
+/**
+ * Resolve a custom hook reference using name-based lookup
+ */
+function resolveHook(name, context) {
+    const candidates = context.getNodesByName(name);
+    if (candidates.length === 0)
+        return null;
+    const hooks = candidates.filter((n) => n.kind === 'function' && n.name.startsWith('use'));
+    if (hooks.length === 0)
+        return null;
+    // Prefer hooks directories
+    const HOOK_DIRS = ['/hooks/', '/src/hooks/', '/lib/hooks/', '/utils/hooks/'];
+    const preferred = hooks.filter((n) => HOOK_DIRS.some((d) => n.filePath.includes(d)));
+    if (preferred.length > 0)
+        return preferred[0].id;
+    return hooks[0].id;
+}
+/**
+ * Resolve a context reference using name-based lookup
+ */
+function resolveContext(name, context) {
+    const candidates = context.getNodesByName(name);
+    if (candidates.length === 0) {
+        // Try without Context/Provider suffix
+        const baseName = name.replace(/Context$|Provider$/, '');
+        if (baseName !== name) {
+            const baseCandidates = context.getNodesByName(baseName);
+            if (baseCandidates.length > 0)
+                return baseCandidates[0].id;
+        }
+        return null;
+    }
+    // Prefer context directories
+    const CONTEXT_DIRS = ['/context/', '/contexts/', '/src/context/', '/src/contexts/', '/providers/', '/src/providers/'];
+    const preferred = candidates.filter((n) => CONTEXT_DIRS.some((d) => n.filePath.includes(d)));
+    if (preferred.length > 0)
+        return preferred[0].id;
+    return candidates[0].id;
+}
+/**
+ * Convert file path to Next.js route
+ */
+function filePathToRoute(filePath) {
+    // pages/index.tsx -> /
+    // pages/about.tsx -> /about
+    // pages/blog/[slug].tsx -> /blog/:slug
+    // app/page.tsx -> /
+    // app/about/page.tsx -> /about
+    if (filePath.includes('pages/')) {
+        let route = filePath
+            .replace(/^.*pages\//, '/')
+            .replace(/\/index\.(tsx?|jsx?)$/, '')
+            .replace(/\.(tsx?|jsx?)$/, '')
+            .replace(/\[([^\]]+)\]/g, ':$1');
+        if (route === '')
+            route = '/';
+        return route;
+    }
+    if (filePath.includes('app/')) {
+        // App router - only page.tsx files are routes
+        if (!filePath.includes('page.')) {
+            return null;
+        }
+        let route = filePath
+            .replace(/^.*app\//, '/')
+            .replace(/\/page\.(tsx?|jsx?)$/, '')
+            .replace(/\[([^\]]+)\]/g, ':$1');
+        if (route === '')
+            route = '/';
+        return route;
+    }
+    return null;
+}
+//# sourceMappingURL=react.js.map

package/dist/resolution/frameworks/ruby.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ruby Framework Resolver
+ *
+ * Handles Ruby on Rails patterns.
+ */
+import { FrameworkResolver } from '../types'
+export declare const railsResolver: FrameworkResolver
+//# sourceMappingURL=ruby.d.ts.map