cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/php.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phpProvider = void 0;
+/**
+ * PHP language provider.
+ *
+ * PHP uses named imports (use statements for classes/functions/constants),
+ * and standard export/import resolution. PHP files can use a variety of
+ * extensions from legacy versions through modern PHP 8.
+ */
+const index_js_1 = require("./php/index.js");
+const index_js_2 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const php_js_1 = require("../class-extractors/configs/php.js");
+const php_js_2 = require("../cfg/visitors/php.js");
+const language_provider_js_1 = require("../language-provider.js");
+const php_js_3 = require("../type-extractors/php.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const php_js_4 = require("../import-resolvers/configs/php.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const generic_js_2 = require("../field-extractors/generic.js");
+const php_js_5 = require("../field-extractors/configs/php.js");
+const generic_js_3 = require("../method-extractors/generic.js");
+const php_js_6 = require("../method-extractors/configs/php.js");
+const generic_js_4 = require("../variable-extractors/generic.js");
+const php_js_7 = require("../variable-extractors/configs/php.js");
+const generic_js_5 = require("../call-extractors/generic.js");
+const php_js_8 = require("../call-extractors/configs/php.js");
+const BUILT_INS = new Set([
+    'echo',
+    'isset',
+    'empty',
+    'unset',
+    'list',
+    'array',
+    'compact',
+    'extract',
+    'count',
+    'strlen',
+    'strpos',
+    'strrpos',
+    'substr',
+    'strtolower',
+    'strtoupper',
+    'trim',
+    'ltrim',
+    'rtrim',
+    'str_replace',
+    'str_contains',
+    'str_starts_with',
+    'str_ends_with',
+    'sprintf',
+    'vsprintf',
+    'printf',
+    'number_format',
+    'array_map',
+    'array_filter',
+    'array_reduce',
+    'array_push',
+    'array_pop',
+    'array_shift',
+    'array_unshift',
+    'array_slice',
+    'array_splice',
+    'array_merge',
+    'array_keys',
+    'array_values',
+    'array_key_exists',
+    'in_array',
+    'array_search',
+    'array_unique',
+    'usort',
+    'rsort',
+    'json_encode',
+    'json_decode',
+    'serialize',
+    'unserialize',
+    'intval',
+    'floatval',
+    'strval',
+    'boolval',
+    'is_null',
+    'is_string',
+    'is_int',
+    'is_array',
+    'is_object',
+    'is_numeric',
+    'is_bool',
+    'is_float',
+    'var_dump',
+    'print_r',
+    'var_export',
+    'date',
+    'time',
+    'strtotime',
+    'mktime',
+    'microtime',
+    'file_exists',
+    'file_get_contents',
+    'file_put_contents',
+    'is_file',
+    'is_dir',
+    'preg_match',
+    'preg_match_all',
+    'preg_replace',
+    'preg_split',
+    'header',
+    'session_start',
+    'session_destroy',
+    'ob_start',
+    'ob_end_clean',
+    'ob_get_clean',
+    'dd',
+    'dump',
+]);
+/** Eloquent model properties whose array values are worth indexing. */
+const ELOQUENT_ARRAY_PROPS = new Set(['fillable', 'casts', 'hidden', 'guarded', 'with', 'appends']);
+/** Eloquent relationship method names. */
+const ELOQUENT_RELATIONS = new Set([
+    'hasMany',
+    'hasOne',
+    'belongsTo',
+    'belongsToMany',
+    'morphTo',
+    'morphMany',
+    'morphOne',
+    'morphToMany',
+    'morphedByMany',
+    'hasManyThrough',
+    'hasOneThrough',
+]);
+/**
+ * For a PHP property_declaration node, extract array values as a description string.
+ * Returns null if not an Eloquent model property or no array values found.
+ */
+function extractPhpPropertyDescription(propName, propDeclNode) {
+    if (!ELOQUENT_ARRAY_PROPS.has(propName))
+        return null;
+    const arrayNode = (0, ast_helpers_js_1.findDescendant)(propDeclNode, 'array_creation_expression');
+    if (!arrayNode)
+        return null;
+    const items = [];
+    for (const child of arrayNode.children ?? []) {
+        if (child.type !== 'array_element_initializer')
+            continue;
+        const children = child.children ?? [];
+        const arrowIdx = children.findIndex((c) => c.type === '=>');
+        if (arrowIdx !== -1) {
+            const key = (0, ast_helpers_js_1.extractStringContent)(children[arrowIdx - 1]);
+            const val = (0, ast_helpers_js_1.extractStringContent)(children[arrowIdx + 1]);
+            if (key && val)
+                items.push(`${key}:${val}`);
+        }
+        else {
+            const val = (0, ast_helpers_js_1.extractStringContent)(children[0]);
+            if (val)
+                items.push(val);
+        }
+    }
+    return items.length > 0 ? items.join(', ') : null;
+}
+/**
+ * For a PHP method_declaration node, detect if it defines an Eloquent relationship.
+ * Returns description like "hasMany(Post)" or null.
+ */
+function extractEloquentRelationDescription(methodNode) {
+    function findRelationCall(root) {
+        const stack = [root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node.type === 'member_call_expression') {
+                const children = node.children ?? [];
+                const objectNode = children.find((c) => c.type === 'variable_name' && c.text === '$this');
+                const nameNode = children.find((c) => c.type === 'name');
+                if (objectNode && nameNode && ELOQUENT_RELATIONS.has(nameNode.text))
+                    return node;
+            }
+            const children = node.children ?? [];
+            for (let i = children.length - 1; i >= 0; i--) {
+                stack.push(children[i]);
+            }
+        }
+        return null;
+    }
+    const callNode = findRelationCall(methodNode);
+    if (!callNode)
+        return null;
+    const relType = callNode.children?.find((c) => c.type === 'name')?.text;
+    const argsNode = callNode.children?.find((c) => c.type === 'arguments');
+    let targetModel = null;
+    if (argsNode) {
+        const firstArg = argsNode.children?.find((c) => c.type === 'argument');
+        if (firstArg) {
+            const classConstant = firstArg.children?.find((c) => c.type === 'class_constant_access_expression');
+            if (classConstant) {
+                targetModel =
+                    classConstant.children?.find((c) => c.type === 'name')?.text ?? null;
+            }
+        }
+    }
+    if (relType && targetModel)
+        return `${relType}(${targetModel})`;
+    if (relType)
+        return relType;
+    return null;
+}
+/** PHPDoc-docblock fallback, shared with the other leading-comment languages. */
+const phpLeadingDocFallback = (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)();
+/**
+ * LanguageProvider.descriptionExtractor implementation for PHP.
+ * Eloquent model property metadata and relationship descriptions take
+ * precedence (they are richer than prose); otherwise documentable symbols fall
+ * back to their leading PHPDoc docblock (issue #2270), mirroring the other
+ * leading-comment languages.
+ */
+function phpDescriptionExtractor(nodeLabel, nodeName, captureMap) {
+    const propertyNode = captureMap['definition.property'];
+    if (nodeLabel === 'Property' && propertyNode) {
+        const eloquentProperty = extractPhpPropertyDescription(nodeName, propertyNode);
+        if (eloquentProperty)
+            return eloquentProperty;
+    }
+    const methodNode = captureMap['definition.method'];
+    if (nodeLabel === 'Method' && methodNode) {
+        const eloquentRelation = extractEloquentRelationDescription(methodNode);
+        if (eloquentRelation)
+            return eloquentRelation;
+    }
+    return phpLeadingDocFallback(nodeLabel, nodeName, captureMap);
+}
+/** Detect Laravel route files by path convention. */
+function isPhpRouteFile(filePath) {
+    return (filePath.endsWith('.php') && (filePath.includes('/routes/') || filePath.startsWith('routes/')));
+}
+exports.phpProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_2.SupportedLanguages.PHP,
+    extensions: ['.php', '.phtml', '.php3', '.php4', '.php5', '.php8'],
+    entryPointPatterns: [
+        /Controller$/,
+        /^handle$/,
+        /^execute$/,
+        /^boot$/,
+        /^register$/,
+        /^__invoke$/,
+        /^(index|show|store|update|destroy|create|edit)$/,
+        /^(get|post|put|delete|patch)[A-Z]/,
+        /^run$/,
+        /^fire$/,
+        /^dispatch$/,
+        /Service$/,
+        /Repository$/,
+        /^find$/,
+        /^findAll$/,
+        /^save$/,
+        /^delete$/,
+    ],
+    astFrameworkPatterns: [
+        {
+            framework: 'laravel',
+            entryPointMultiplier: 3.0,
+            reason: 'php-route-attribute',
+            patterns: [
+                'Route::get',
+                'Route::post',
+                'Route::put',
+                'Route::delete',
+                'Route::resource',
+                'Route::apiResource',
+                '#[Route(',
+            ],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.PHP_QUERIES,
+    typeConfig: php_js_3.typeConfig,
+    exportChecker: export_detection_js_1.phpExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(php_js_4.phpImportConfig),
+    callExtractor: (0, generic_js_5.createCallExtractor)(php_js_8.phpCallConfig),
+    fieldExtractor: (0, generic_js_2.createFieldExtractor)(php_js_5.phpConfig),
+    methodExtractor: (0, generic_js_3.createMethodExtractor)(php_js_6.phpMethodConfig),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(php_js_7.phpVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(php_js_1.phpClassConfig),
+    descriptionExtractor: phpDescriptionExtractor,
+    isRouteFile: isPhpRouteFile,
+    builtInNames: BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks ──────────────────────
+    emitScopeCaptures: index_js_1.emitPhpScopeCaptures,
+    cfgVisitor: (0, php_js_2.createPhpCfgVisitor)(),
+    interpretImport: index_js_1.interpretPhpImport,
+    interpretTypeBinding: index_js_1.interpretPhpTypeBinding,
+    // LanguageProvider uses (def, callsite); phpArityCompatibility uses (def, callsite) — same.
+    arityCompatibility: index_js_1.phpArityCompatibility,
+    // LanguageProvider adapter: (parsedImport, workspaceIndex) → string | null
+    resolveImportTarget: index_js_1.resolvePhpImportTarget,
+    // mergeBindings on LanguageProvider: (scope, bindings) — ignore scope id,
+    // delegate to phpMergeBindings which uses binding origin tiers.
+    mergeBindings: (_scope, bindings) => [...(0, index_js_1.phpMergeBindings)(bindings)],
+    bindingScopeFor: index_js_1.phpBindingScopeFor,
+    importOwningScope: index_js_1.phpImportOwningScope,
+    receiverBinding: index_js_1.phpReceiverBinding,
+});

package/dist/core/code/engine/core/ingestion/languages/python/arity-metadata.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Extract Python arity metadata from a `function_definition` tree-sitter
+ * node — parameter count, required count, and (where present) a type
+ * list that the existing `pythonArityCompatibility` hook reads.
+ *
+ * Mirrors the legacy `buildMethodProps` conversion so scope-extracted
+ * defs carry the same arity semantics as the parse-worker path:
+ *   - `self` / `cls` are stripped (consumed by `extractPythonParameters`).
+ *   - Defaulted params contribute to `optionalCount`, flipping
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - Variadic (`*args` / `**kwargs`) collapses `parameterCount` to
+ *     `undefined`, which `pythonArityCompatibility` then treats as
+ *     `'unknown'` — keeping the candidate in the registry's lookup set.
+ *   - `parameterTypes` is populated only with real type text, matching
+ *     legacy behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computePythonArityMetadata = computePythonArityMetadata;
+const python_js_1 = require("../../method-extractors/configs/python.js");
+function computePythonArityMetadata(fnNode) {
+    const params = python_js_1.pythonMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVariadic = false;
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic)
+            hasVariadic = true;
+        else if (p.isOptional)
+            optionalCount++;
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    const total = params.length;
+    const parameterCount = hasVariadic ? undefined : total;
+    // Unlike legacy `buildMethodProps`, we populate `requiredParameterCount`
+    // whenever the function isn't variadic — even when it equals
+    // `parameterCount`. The scope-resolution registry needs a concrete min
+    // to rule out under-application (e.g. picking `write_audit(x, y)` for
+    // a 1-arg call). Legacy could get away with leaving it undefined
+    // because its call-graph builder had a separate arity pre-filter.
+    const requiredParameterCount = hasVariadic ? undefined : total - optionalCount;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+        parameterNames: params.map((parameter) => parameter.name),
+    };
+}

package/dist/core/code/engine/core/ingestion/languages/python/arity.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Python arity check, accommodating `*args`, `**kwargs`, and defaults.
+ *
+ * The `def` metadata we care about (set by the existing Python method/
+ * function extractor):
+ *   - `parameterCount`         — total positional + keyword params
+ *   - `requiredParameterCount` — min required (excludes defaults / `*args` / `**kwargs`)
+ *   - `parameterTypes`         — present when types are known; we also use it
+ *                                as a "we have varargs" hint (`'*args'`,
+ *                                `'**kwargs'` literals appear in the array).
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def takes `*args` (then any `argCount >= required` ok).
+ *   - `'incompatible'` — argCount is below required, OR above max with no `*args`.
+ *   - `'unknown'`      — def metadata is absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC §4.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonArityCompatibility = pythonArityCompatibility;
+function pythonArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    // Detect varargs/kwargs from parameterTypes if present (the Python
+    // method extractor stores `'*args'`/`'**kwargs'` in this list).
+    const hasVarArgs = def.parameterTypes !== undefined &&
+        def.parameterTypes.some((t) => t === '*args' || t === '**kwargs' || t.startsWith('*'));
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVarArgs)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/code/engine/core/ingestion/languages/python/cache-stats.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Dev-mode counters for the cross-phase scope-captures parse cache.
+ *
+ * Gated by `PROF_SCOPE_RESOLUTION=1`. In production the module-level
+ * `PROF` constant is `false` and V8 folds every increment site into
+ * dead code, so the hot path in `captures.ts` stays branch-free.
+ *
+ * Extracted from `captures.ts` so the production hot-path module
+ * doesn't carry a module-global counter and its reset/export surface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordCacheHit = recordCacheHit;
+exports.recordCacheMiss = recordCacheMiss;
+exports.getPythonCaptureCacheStats = getPythonCaptureCacheStats;
+exports.resetPythonCaptureCacheStats = resetPythonCaptureCacheStats;
+const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
+let CACHE_HITS = 0;
+let CACHE_MISSES = 0;
+function recordCacheHit() {
+    if (PROF)
+        CACHE_HITS++;
+}
+function recordCacheMiss() {
+    if (PROF)
+        CACHE_MISSES++;
+}
+function getPythonCaptureCacheStats() {
+    return { hits: CACHE_HITS, misses: CACHE_MISSES };
+}
+function resetPythonCaptureCacheStats() {
+    CACHE_HITS = 0;
+    CACHE_MISSES = 0;
+}