cgraphx 2.0.2 → 2.0.6

package/dist/core/code/engine/core/ingestion/route-extractors/constant-resolver.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Language-agnostic string-constant folding for route-path resolution (#2391).
+ *
+ * Route decorators/annotations frequently build their path from a constant rather
+ * than a string literal — `@router.post(API_V1_WIDGETS_GET)` (Python),
+ * `@GetMapping(PathConstants.WIDGETS)` (Spring), and the Kotlin/C# equivalents are
+ * the same shape. This module folds such a constant — or an inline
+ * `+`-concatenation — to its literal value, following `+` operands and import
+ * chains across a repo-wide, file-keyed constant map.
+ *
+ * The FOLD is language-neutral: it walks {@link Operand} lists and
+ * {@link ModuleConstants} that ANY language's extractor can produce, and defers
+ * the one language-specific decision — mapping an import specifier to the file it
+ * refers to — to a caller-supplied {@link ImportResolver}. A language binding
+ * (e.g. `python-const-resolver.ts`) provides that resolver plus a tree →
+ * {@link ModuleConstants} extractor and, if wanted, thin pre-bound wrappers.
+ *
+ * This mirrors how `route-path.ts` (URL normalization) and `spring-shared.ts`
+ * (annotation primitives) are shared across the ingestion and group layers and
+ * across languages: the reusable core lives in one place; per-language semantics
+ * plug in. It deliberately does NOT reuse `ScopeResolver` (which resolves symbol
+ * IDENTITIES, not literal string VALUES) or the `--pdg` `REACHING_DEF` layer
+ * (intra-procedural, function-local, def→use reachability — not module-level
+ * cross-file value folding).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConstant = resolveConstant;
+exports.resolveOperands = resolveOperands;
+/** Depth ceiling for the import/constant chase. A heuristic bound, not a proven
+ * one; overrun floors to `null` (skip), never a wrong value. */
+const MAX_RESOLVE_DEPTH = 8;
+/** Max length of a folded path. Real route paths are well under this; a fold that
+ * exceeds it is a pathological self-multiplying concat (`X = A + A; A = B + B; …`)
+ * whose true value is genuinely huge — building it risks a `RangeError`/heap OOM,
+ * so we floor to `null` (skip) instead (#2393). The depth cap bounds recursion but
+ * NOT output size, which grows multiplicatively; this bounds the output. */
+const MAX_FOLD_LENGTH = 8192;
+/**
+ * Fold an operand list to its concatenated literal, or `null` if any operand is
+ * unresolvable (an unknown name, a non-string term, a cycle, or a depth overrun).
+ */
+function foldExpr(fileKey, operands, state, depth) {
+    if (depth > MAX_RESOLVE_DEPTH)
+        return null;
+    let out = '';
+    for (const op of operands) {
+        if (op.kind === 'literal') {
+            out += op.value;
+        }
+        else {
+            const resolved = foldName(fileKey, op.name, state, depth + 1);
+            if (resolved === null)
+                return null;
+            out += resolved;
+        }
+        if (out.length > MAX_FOLD_LENGTH)
+            return null; // pathological self-multiplying concat → drop
+    }
+    return out;
+}
+function foldName(fileKey, name, state, depth) {
+    if (depth > MAX_RESOLVE_DEPTH)
+        return null;
+    const guard = `${fileKey}::${name}`;
+    // Memoize successful folds. `visited` (below) is the ACTIVE resolution stack
+    // for cycle detection — popped on unwind so `A + A` / diamonds fold instead of
+    // false-cycling (#2393) — but popping it alone reintroduces recomputation: a
+    // wide shared-descendant DAG re-folds each child once per reference, O(fanout^depth),
+    // which can exhaust the heap. The never-popped `memo` caps that at O(nodes): a
+    // name resolved on one branch is returned directly on the next. Only SUCCESSES
+    // are cached — a `null` may be transient (a name that is a cycle on the current
+    // branch can resolve on another), so caching it would be unsound.
+    const memoized = state.memo.get(guard);
+    if (memoized !== undefined)
+        return memoized;
+    if (state.visited.has(guard))
+        return null; // cycle: `name` is on the active stack
+    state.visited.add(guard);
+    try {
+        const result = computeFold(fileKey, name, state, depth);
+        if (result !== null)
+            state.memo.set(guard, result);
+        return result;
+    }
+    finally {
+        state.visited.delete(guard);
+    }
+}
+/** The literal/expr/import resolution for one name. Cycle guard + memo live in
+ * {@link foldName}; this is the pure lookup body. */
+function computeFold(fileKey, name, state, depth) {
+    const mc = state.repo.get(fileKey);
+    if (!mc)
+        return null;
+    const literal = mc.literals.get(name);
+    if (literal !== undefined)
+        return literal;
+    const expr = mc.exprs.get(name);
+    if (expr !== undefined)
+        return foldExpr(fileKey, expr, state, depth + 1);
+    const imp = mc.imports.get(name);
+    if (imp !== undefined) {
+        const targetKey = state.resolveImport(fileKey, imp.module, state.repoKeys);
+        if (targetKey === null)
+            return null;
+        return foldName(targetKey, imp.originalName, state, depth + 1);
+    }
+    return null;
+}
+function newState(repo, resolveImport) {
+    return {
+        repo,
+        repoKeys: new Set(repo.keys()),
+        resolveImport,
+        visited: new Set(),
+        memo: new Map(),
+    };
+}
+/**
+ * Resolve a single named constant referenced in `fileKey` to its literal string
+ * value, folding `+` concatenation and following import chains via
+ * `resolveImport`, or `null` when it cannot be fully folded.
+ */
+function resolveConstant(fileKey, name, repo, resolveImport) {
+    return foldName(fileKey, name, newState(repo, resolveImport), 0);
+}
+/**
+ * Resolve an inline operand list (an unnamed `+`-expression captured directly at
+ * a decorator/annotation argument, e.g. `@router.get(API_V1 + "/widgets")`)
+ * against `fileKey`.
+ */
+function resolveOperands(fileKey, operands, repo, resolveImport) {
+    return foldExpr(fileKey, operands, newState(repo, resolveImport), 0);
+}

package/dist/core/code/engine/core/ingestion/route-extractors/django-root-discovery.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.djangoModuleToFilePaths = djangoModuleToFilePaths;
+exports.discoverDjangoRootUrls = discoverDjangoRootUrls;
+/**
+ * Given a `manage.py` file content, extract the Django settings module.
+ * e.g. `os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'cmrMngt.settings')`
+ * returns `'cmrMngt.settings'`
+ */
+function extractDjangoSettingsModule(manageContent) {
+    const m = manageContent.match(/DJANGO_SETTINGS_MODULE\s*['"]?[,= ]\s*['"]([^'"]+)['"]/);
+    return m ? m[1] : null;
+}
+/**
+ * Given a dotted Python module path, produce possible file paths.
+ * e.g. `cmrMngt.settings` → `['cmrMngt/settings.py', 'cmrMngt/settings/__init__.py']`
+ */
+function djangoModuleToFilePaths(modulePath) {
+    const base = modulePath.replace(/\./g, '/');
+    return [`${base}.py`, `${base}/__init__.py`];
+}
+/**
+ * Read a file, trying first the in-memory content map, then the optional
+ * reader (typically a disk-backed reader on the main thread). The map keeps
+ * already-loaded content cheap; the reader lets discovery reach files that
+ * were never pre-loaded — critical because the relevant files (manage.py,
+ * settings, the root urls.py) can be scattered across parse chunks.
+ */
+function tryReadFile(relativePath, contentMap, reader) {
+    return contentMap.get(relativePath) ?? reader?.(relativePath) ?? null;
+}
+/**
+ * Extract a module-level string assignment value from Python source.
+ * e.g. `content` contains `ROOT_URLCONF = 'cmrMngt.urls'`
+ * returns `'cmrMngt.urls'`
+ */
+function extractPythonStringAssignment(content, varName) {
+    const regex = new RegExp(`^${varName}\\s*=\\s*['"]([^'"]+)['"]`, 'm');
+    const m = content.match(regex);
+    return m ? m[1] : null;
+}
+/**
+ * Extract `from <module> import *` statements from Python source.
+ * e.g. `from .settings_base import *` → `settings_base`
+ *      `from cmrMngt.settings_base import *` → `cmrMngt.settings_base`
+ */
+function extractStarImports(content) {
+    const modules = [];
+    const regex = /^from\s+(\.?[\w.]+)\s+import\s+\*/gm;
+    let m;
+    while ((m = regex.exec(content)) !== null) {
+        // Relative (leading-dot) and absolute module names are both pushed verbatim;
+        // the caller resolves relative ones against the current module path.
+        modules.push(m[1]);
+    }
+    return modules;
+}
+/**
+ * Resolve a relative Python import path.
+ * `from .settings_base import *` in `cmrMngt/settings.py`
+ * → `cmrMngt/settings_base.py`
+ */
+function resolveRelativeImport(currentModulePath, importPath) {
+    if (!importPath.startsWith('.'))
+        return null;
+    const currentDir = currentModulePath.includes('/')
+        ? currentModulePath.substring(0, currentModulePath.lastIndexOf('/'))
+        : '';
+    let relPath = importPath;
+    let dir = currentDir;
+    while (relPath.startsWith('.')) {
+        if (relPath.startsWith('..')) {
+            dir = dir.includes('/') ? dir.substring(0, dir.lastIndexOf('/')) : '';
+            relPath = relPath.substring(2);
+        }
+        else {
+            relPath = relPath.substring(1);
+            break;
+        }
+    }
+    return dir ? `${dir}/${relPath}` : relPath;
+}
+/**
+ * Resolve the root URL file for a SINGLE Django project rooted at `managePyPath`.
+ *
+ * Module paths in `manage.py`/`settings.py` are written relative to the
+ * project directory (the one containing `manage.py`), NOT the repo root — so a
+ * project under `backend/` declares `myproj.settings`, with the file living at
+ * `backend/myproj/settings.py`. We therefore resolve every candidate against
+ * the project directory first and the repo root second. `resolvedSettingsPath`
+ * is kept project-dir-aware so the downstream star-import and urls-dir
+ * resolution anchor correctly.
+ */
+function resolveDjangoProjectRoot(managePyPath, manageContent, map, reader) {
+    const projectDir = managePyPath.includes('/')
+        ? managePyPath.substring(0, managePyPath.lastIndexOf('/'))
+        : '';
+    // Try the project dir first (the common subdir case), then the repo root.
+    const bases = projectDir ? [`${projectDir}/`, ''] : [''];
+    const settingsModule = extractDjangoSettingsModule(manageContent);
+    if (!settingsModule)
+        return null;
+    const settingsSlash = settingsModule.replace(/\./g, '/');
+    // Find the settings file, recording which base it resolved under so relative
+    // imports and the urls-dir fallback stay anchored to the right directory.
+    let settingsContent = null;
+    let resolvedSettingsPath = null;
+    for (const base of bases) {
+        for (const sp of djangoModuleToFilePaths(settingsModule)) {
+            const c = tryReadFile(base + sp, map, reader);
+            if (c !== null) {
+                settingsContent = c;
+                resolvedSettingsPath = base + settingsSlash;
+                break;
+            }
+        }
+        if (settingsContent)
+            break;
+    }
+    if (!settingsContent || resolvedSettingsPath === null)
+        return null;
+    // Check ROOT_URLCONF in the main settings and any base settings (star imports)
+    let rootUrlConf = extractPythonStringAssignment(settingsContent, 'ROOT_URLCONF');
+    if (!rootUrlConf) {
+        // Check star-imported base settings
+        const starImports = extractStarImports(settingsContent);
+        for (const imp of starImports) {
+            let baseModule = null;
+            if (imp.startsWith('.')) {
+                const resolved = resolveRelativeImport(resolvedSettingsPath, imp);
+                if (resolved)
+                    baseModule = resolved;
+            }
+            else {
+                baseModule = imp;
+            }
+            if (!baseModule)
+                continue;
+            // `baseModule` is always a slash-path here: a relative import is resolved
+            // by `resolveRelativeImport` (which never returns a leading-dot path), and
+            // an absolute import is the bare module name. So there is no remaining
+            // dot-prefixed case to handle.
+            const basePaths = [];
+            const baseSlash = baseModule.replace(/\./g, '/');
+            // A relative import (`imp` started with `.`) is already anchored under
+            // the project dir via `resolvedSettingsPath`; an absolute module name
+            // may live under the project dir OR the repo root.
+            const candidateBases = imp.startsWith('.') ? [''] : bases;
+            for (const cb of candidateBases) {
+                basePaths.push(`${cb}${baseSlash}.py`);
+                basePaths.push(`${cb}${baseSlash}/__init__.py`);
+            }
+            for (const bp of basePaths) {
+                const bc = tryReadFile(bp, map, reader);
+                if (bc) {
+                    rootUrlConf = extractPythonStringAssignment(bc, 'ROOT_URLCONF');
+                    if (rootUrlConf)
+                        break;
+                }
+            }
+            if (rootUrlConf)
+                break;
+        }
+    }
+    if (!rootUrlConf)
+        return null;
+    // Convert ROOT_URLCONF module path to a file path, trying project dir then root.
+    const urlPaths = djangoModuleToFilePaths(rootUrlConf);
+    for (const base of bases) {
+        for (const up of urlPaths) {
+            if (tryReadFile(base + up, map, reader) !== null)
+                return base + up;
+        }
+    }
+    // Also try relative to the settings module's directory (project-dir-aware).
+    if (resolvedSettingsPath.includes('/')) {
+        const settingsDir = resolvedSettingsPath.substring(0, resolvedSettingsPath.lastIndexOf('/') + 1);
+        for (const up of urlPaths) {
+            const tryPath = settingsDir + up;
+            if (tryReadFile(tryPath, map, reader) !== null)
+                return tryPath;
+        }
+    }
+    return null;
+}
+/**
+ * Discover the Django root URL file(s) by following, for EVERY `manage.py` in
+ * the file set:
+ *   manage.py → DJANGO_SETTINGS_MODULE → settings → ROOT_URLCONF → urls.py
+ *
+ * Returns one root urls path per discoverable Django project, so a monorepo
+ * with several `manage.py` files (e.g. `serviceA/manage.py`, `serviceB/manage.py`)
+ * yields every project's routes rather than only the first.
+ *
+ * @param files Array of file paths (content optional — when absent, `reader`
+ *   resolves it on demand).
+ * @param contentMap Optional pre-built map of file path → content.
+ * @param reader Optional disk-backed reader for files not present in the map.
+ * @returns De-duplicated relative paths to each project's root URL file (empty if none).
+ */
+function discoverDjangoRootUrls(files, contentMap, reader) {
+    const map = contentMap ?? new Map();
+    for (const f of files)
+        if (f.content != null)
+            map.set(f.path, f.content);
+    const roots = [];
+    const seen = new Set();
+    for (const f of files) {
+        if (f.path !== 'manage.py' && !f.path.endsWith('/manage.py'))
+            continue;
+        const manageContent = f.content ?? tryReadFile(f.path, map, reader);
+        if (!manageContent)
+            continue;
+        const root = resolveDjangoProjectRoot(f.path, manageContent, map, reader);
+        if (root !== null && !seen.has(root)) {
+            seen.add(root);
+            roots.push(root);
+        }
+    }
+    return roots;
+}