cgraphx 2.0.2 → 2.0.6

package/dist/core/code/shared/language-detection.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Language Detection — maps file paths to SupportedLanguages enum values.
+ *
+ * Shared between CLI (ingestion pipeline) and web (syntax highlighting).
+ *
+ * ADDING A NEW LANGUAGE:
+ * 1. Add enum member to SupportedLanguages in languages.ts
+ * 2. Add file extensions to EXTENSION_MAP below
+ * 3. TypeScript will error if you miss either step (exhaustive Record)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSyntaxLanguageFromFilename = exports.getLanguageFromFilename = exports.isBladeTemplateFilename = void 0;
+const languages_js_1 = require("./languages.js");
+/** Ruby extensionless filenames recognised as Ruby source */
+const RUBY_EXTENSIONLESS_FILES = new Set([
+    'Rakefile',
+    'Gemfile',
+    'Guardfile',
+    'Vagrantfile',
+    'Brewfile',
+]);
+/**
+ * Exhaustive map: every SupportedLanguages member → its file extensions.
+ *
+ * If a new language is added to the enum without adding an entry here,
+ * TypeScript emits a compile error: "Property 'NewLang' is missing in type..."
+ */
+const EXTENSION_MAP = {
+    [languages_js_1.SupportedLanguages.JavaScript]: ['.js', '.jsx', '.mjs', '.cjs'],
+    [languages_js_1.SupportedLanguages.TypeScript]: ['.ts', '.tsx', '.mts', '.cts'],
+    [languages_js_1.SupportedLanguages.Python]: ['.py'],
+    [languages_js_1.SupportedLanguages.Java]: ['.java'],
+    [languages_js_1.SupportedLanguages.C]: ['.c'],
+    [languages_js_1.SupportedLanguages.CPlusPlus]: [
+        '.cpp',
+        '.cc',
+        '.cxx',
+        '.h',
+        '.hpp',
+        '.hxx',
+        '.hh',
+        '.cu',
+        '.cuh',
+    ],
+    [languages_js_1.SupportedLanguages.CSharp]: ['.cs'],
+    [languages_js_1.SupportedLanguages.Go]: ['.go'],
+    [languages_js_1.SupportedLanguages.Ruby]: ['.rb', '.rake', '.gemspec'],
+    [languages_js_1.SupportedLanguages.Rust]: ['.rs'],
+    [languages_js_1.SupportedLanguages.PHP]: ['.php', '.phtml', '.php3', '.php4', '.php5', '.php8'],
+    [languages_js_1.SupportedLanguages.Kotlin]: ['.kt', '.kts'],
+    [languages_js_1.SupportedLanguages.Swift]: ['.swift'],
+    [languages_js_1.SupportedLanguages.Dart]: ['.dart'],
+    [languages_js_1.SupportedLanguages.Vue]: ['.vue'],
+}; // Ensure exhaustiveness
+/** Pre-built reverse lookup: extension → language (built once at module load). */
+const extToLang = new Map();
+for (const [lang, exts] of Object.entries(EXTENSION_MAP)) {
+    for (const ext of exts) {
+        extToLang.set(ext, lang);
+    }
+}
+/**
+ * Laravel Blade templates are source templates whose filename convention ends
+ * in `.blade.php`.  They may contain PHP snippets, but the full file is not a
+ * pure PHP translation unit and must not enter the generic PHP provider path.
+ */
+const isBladeTemplateFilename = (filePath) => filePath.replace(/\\/g, '/').toLowerCase().endsWith('.blade.php');
+exports.isBladeTemplateFilename = isBladeTemplateFilename;
+/**
+ * Map file extension to SupportedLanguage enum.
+ * Returns null if the file extension is not recognized.
+ */
+const getLanguageFromFilename = (filename) => {
+    if ((0, exports.isBladeTemplateFilename)(filename))
+        return null;
+    // Fast path: check the extension map
+    const lastDot = filename.lastIndexOf('.');
+    if (lastDot >= 0) {
+        const ext = filename.slice(lastDot).toLowerCase();
+        const lang = extToLang.get(ext);
+        if (lang !== undefined)
+            return lang;
+    }
+    // Ruby extensionless files (Rakefile, Gemfile, etc.)
+    const basename = filename.split('/').pop() || filename;
+    if (RUBY_EXTENSIONLESS_FILES.has(basename)) {
+        return languages_js_1.SupportedLanguages.Ruby;
+    }
+    return null;
+};
+exports.getLanguageFromFilename = getLanguageFromFilename;
+/**
+ * Exhaustive map: every SupportedLanguages member → Prism syntax identifier.
+ *
+ * If a new language is added to the enum without adding an entry here,
+ * TypeScript emits a compile error.
+ */
+const SYNTAX_MAP = {
+    [languages_js_1.SupportedLanguages.JavaScript]: 'javascript',
+    [languages_js_1.SupportedLanguages.TypeScript]: 'typescript',
+    [languages_js_1.SupportedLanguages.Python]: 'python',
+    [languages_js_1.SupportedLanguages.Java]: 'java',
+    [languages_js_1.SupportedLanguages.C]: 'c',
+    [languages_js_1.SupportedLanguages.CPlusPlus]: 'cpp',
+    [languages_js_1.SupportedLanguages.CSharp]: 'csharp',
+    [languages_js_1.SupportedLanguages.Go]: 'go',
+    [languages_js_1.SupportedLanguages.Ruby]: 'ruby',
+    [languages_js_1.SupportedLanguages.Rust]: 'rust',
+    [languages_js_1.SupportedLanguages.PHP]: 'php',
+    [languages_js_1.SupportedLanguages.Kotlin]: 'kotlin',
+    [languages_js_1.SupportedLanguages.Swift]: 'swift',
+    [languages_js_1.SupportedLanguages.Dart]: 'dart',
+    [languages_js_1.SupportedLanguages.Vue]: 'typescript',
+}; // Ensure exhaustiveness
+/** Non-code file extensions → Prism-compatible syntax identifiers */
+const AUXILIARY_SYNTAX_MAP = {
+    json: 'json',
+    yaml: 'yaml',
+    yml: 'yaml',
+    md: 'markdown',
+    mdx: 'markdown',
+    html: 'markup',
+    htm: 'markup',
+    erb: 'markup',
+    xml: 'markup',
+    css: 'css',
+    scss: 'css',
+    sass: 'css',
+    sh: 'bash',
+    bash: 'bash',
+    zsh: 'bash',
+    sql: 'sql',
+    toml: 'toml',
+    ini: 'ini',
+    dockerfile: 'docker',
+};
+/** Extensionless filenames → Prism-compatible syntax identifiers */
+const AUXILIARY_BASENAME_MAP = {
+    Makefile: 'makefile',
+    Dockerfile: 'docker',
+};
+/**
+ * Map file path to a Prism-compatible syntax highlight language string.
+ * Covers all SupportedLanguages (code files) plus common non-code formats.
+ * Returns 'text' for unrecognised files.
+ */
+const getSyntaxLanguageFromFilename = (filePath) => {
+    if ((0, exports.isBladeTemplateFilename)(filePath))
+        return 'markup';
+    const lang = (0, exports.getLanguageFromFilename)(filePath);
+    if (lang)
+        return SYNTAX_MAP[lang];
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    if (ext && ext in AUXILIARY_SYNTAX_MAP)
+        return AUXILIARY_SYNTAX_MAP[ext];
+    const basename = filePath.split('/').pop() || '';
+    if (basename in AUXILIARY_BASENAME_MAP)
+        return AUXILIARY_BASENAME_MAP[basename];
+    return 'text';
+};
+exports.getSyntaxLanguageFromFilename = getSyntaxLanguageFromFilename;

package/dist/core/code/shared/languages.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupportedLanguages = void 0;
+/**
+ * Supported language enum — single source of truth.
+ *
+ * Both CLI and web use this to identify which language a file/node belongs to.
+ * The CLI uses it throughout the ingestion pipeline; the web uses it for display.
+ */
+var SupportedLanguages;
+(function (SupportedLanguages) {
+    SupportedLanguages["JavaScript"] = "javascript";
+    SupportedLanguages["TypeScript"] = "typescript";
+    SupportedLanguages["Python"] = "python";
+    SupportedLanguages["Java"] = "java";
+    SupportedLanguages["C"] = "c";
+    SupportedLanguages["CPlusPlus"] = "cpp";
+    SupportedLanguages["CSharp"] = "csharp";
+    SupportedLanguages["Go"] = "go";
+    SupportedLanguages["Ruby"] = "ruby";
+    SupportedLanguages["Rust"] = "rust";
+    SupportedLanguages["PHP"] = "php";
+    SupportedLanguages["Kotlin"] = "kotlin";
+    SupportedLanguages["Swift"] = "swift";
+    SupportedLanguages["Dart"] = "dart";
+    SupportedLanguages["Vue"] = "vue";
+})(SupportedLanguages || (exports.SupportedLanguages = SupportedLanguages = {}));

package/dist/core/code/shared/lbug/schema-constants.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * LadybugDB schema constants — single source of truth.
+ *
+ * NODE_TABLES and REL_TYPES define what the knowledge graph can contain.
+ * Both CLI and web must agree on these for data compatibility.
+ *
+ * Full DDL schemas remain in each package's own schema.ts because
+ * the CLI uses native LadybugDB and the web uses WASM.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMBEDDING_TABLE_NAME = exports.REL_TYPES = exports.REL_TABLE_NAME = exports.NODE_TABLES = void 0;
+exports.NODE_TABLES = [
+    'File',
+    'Folder',
+    'Function',
+    'Class',
+    'Interface',
+    'Method',
+    'CodeElement',
+    'Community',
+    'Process',
+    'Section',
+    'Struct',
+    'Enum',
+    'Macro',
+    'Typedef',
+    'Union',
+    'Namespace',
+    'Trait',
+    'Impl',
+    'TypeAlias',
+    'Const',
+    'Static',
+    'Variable',
+    'Property',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Constructor',
+    'Template',
+    'Module',
+    'Route',
+    'Tool',
+    // Taint/PDG substrate (issue #2080) — inert until M1 (#2081) emits blocks.
+    'BasicBlock',
+    // Synthetic node for an external RPC service not present in the repository.
+    // Emitted by rpc-edges / http-api-calls phases (spec §6.1 single-side case).
+    'ExternalService',
+];
+exports.REL_TABLE_NAME = 'CodeRelation';
+exports.REL_TYPES = [
+    'CONTAINS',
+    'DEFINES',
+    'IMPORTS',
+    'CALLS',
+    'EXTENDS',
+    'IMPLEMENTS',
+    'HAS_METHOD',
+    'HAS_PROPERTY',
+    'ACCESSES',
+    'METHOD_OVERRIDES',
+    'OVERRIDES', // Legacy compat alias — kept until all stored indexes are migrated
+    'METHOD_IMPLEMENTS',
+    'MEMBER_OF',
+    'STEP_IN_PROCESS',
+    'HANDLES_ROUTE',
+    'FETCHES',
+    'HANDLES_TOOL',
+    'ENTRY_POINT_OF',
+    'WRAPS',
+    'QUERIES',
+    'INJECTS',
+    'CONDITIONAL_ON',
+    'DECLARES',
+    'ADVISED_BY',
+    // Taint/PDG substrate (issue #2080) — reserved edge types, emitted by no
+    // phase yet (CFG → M1, REACHING_DEF → M2, TAINTED/SANITIZES/TAINT_PATH →
+    // M3/M4). REACHING_DEF's variable name rides the relation's `reason` column.
+    'CFG',
+    'REACHING_DEF',
+    'TAINTED',
+    'SANITIZES',
+    'TAINT_PATH',
+    // Control dependence (PDG, issue #2085 M5) — CDG carries its 'T'|'F' branch
+    // label in the relation's `reason` column; POST_DOMINATE is debug-only
+    // (behind CGRAPH_PDG_EMIT_POST_DOMINATE). Both are BasicBlock→BasicBlock,
+    // reusing the existing FROM BasicBlock TO BasicBlock pair in RELATION_SCHEMA.
+    'CDG',
+    'POST_DOMINATE',
+    // Cross-service contract edges (spec §2, §6.1, §6.2). RCALLS = RPC annotation
+    // match (Method→Method / Method↔ExternalService); HTTP_CALLS = frontend HTTP
+    // call → backend Method (Method→Method / ExternalService→ExternalService).
+    // Emitted by the rpc-edges / http-api-calls phases (registered in T-11).
+    'RCALLS',
+    'HTTP_CALLS',
+];
+exports.EMBEDDING_TABLE_NAME = 'CodeEmbedding';

package/dist/core/code/shared/mro-strategy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/shared/pipeline.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Pipeline progress types — shared between CLI and web.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/shared/scope-resolution/callable-flow-site.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Always-on callable-value-flow facts produced during scope extraction.
+ *
+ * These records deliberately contain no parser nodes or provider-private
+ * objects: they cross the worker, disk-cache, and ParsedFile-store boundaries.
+ * Language providers recognize syntax and emit `@callable-flow.*` captures;
+ * the central extractor attaches lexical scope ids and materializes this
+ * language-neutral representation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/shared/scope-resolution/def-index.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * `DefIndex` — O(1) `DefId → SymbolDefinition` materialization.
+ *
+ * The global "what is this id?" lookup. Every per-kind registry (ClassRegistry,
+ * MethodRegistry, FieldRegistry) returns `DefId[]` and resolves them back to
+ * full `SymbolDefinition` records through this index — one central hash map,
+ * one allocation per def.
+ *
+ * Part of RFC #909 Ring 2 SHARED — #913.
+ *
+ * Consumed by: #917 (`Registry.lookup` implementations), #915 (SCC finalize).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDefIndex = buildDefIndex;
+/**
+ * Build a `DefIndex` from a flat list of `SymbolDefinition` records.
+ *
+ * **Collision policy: first-write-wins.** `DefId` is meant to be unique
+ * (`nodeId` is the stable graph identifier), so a collision indicates an
+ * upstream bug — most likely the same symbol parsed twice or a duplicate
+ * commit into the pipeline. Rather than silently overwriting with a later
+ * definition that may be partial or wrong, the first record wins and
+ * subsequent records for the same id are dropped. Pipeline bugs surface
+ * later as `has(id) === true` but the def looking older than expected,
+ * which is easier to debug than a silent overwrite.
+ *
+ * Pure function — safe to call repeatedly; no side effects.
+ */
+function buildDefIndex(defs) {
+    const byId = new Map();
+    for (const def of defs) {
+        if (byId.has(def.nodeId))
+            continue; // first-write-wins
+        byId.set(def.nodeId, def);
+    }
+    return wrapIndex(byId);
+}
+// ─── Internal ───────────────────────────────────────────────────────────────
+function wrapIndex(byId) {
+    return {
+        byId,
+        get size() {
+            return byId.size;
+        },
+        get(id) {
+            return byId.get(id);
+        },
+        has(id) {
+            return byId.has(id);
+        },
+    };
+}

package/dist/core/code/shared/scope-resolution/evidence-weights.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * `EvidenceWeights` — RFC Appendix A (authoritative values).
+ *
+ * Starting calibration for scope-based resolution. Shadow-first rollout
+ * tunes these against legacy DAG parity. Every `ResolutionEvidence.weight`
+ * value in the codebase MUST reference this map; inline magic numbers are a
+ * lint violation. Extends issue #429 (centralize hardcoded confidence values).
+ *
+ * Evidence composes additively inside `composeEvidence`; the sum is capped
+ * at 1.0 in `Resolution.confidence`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceWeights = void 0;
+exports.typeBindingWeightAtDepth = typeBindingWeightAtDepth;
+/**
+ * Authoritative weight map. Keys are a mix of `ResolutionEvidence.kind`
+ * values and special modifiers (scope-chain depth, MRO depth decay,
+ * unlinked-import multiplicative cap).
+ */
+exports.EvidenceWeights = {
+    // ─── Where-found signals (visibility) ─────────────────────────────────────
+    /** `BindingRef.origin === 'local'` */
+    local: 0.55,
+    /** `BindingRef.origin === 'import'` */
+    import: 0.45,
+    /** `BindingRef.origin === 'reexport'` */
+    reexport: 0.4,
+    /** `BindingRef.origin === 'namespace'` */
+    namespace: 0.4,
+    /** `BindingRef.origin === 'wildcard'` */
+    wildcard: 0.3,
+    // ─── Scope-chain deduction (per-hop) ──────────────────────────────────────
+    /** Deducted per parent-hop taken (depth-0 = 0, depth-1 = −0.02, …). */
+    scopeChainPerDepth: -0.02,
+    // ─── Receiver-type-binding signal (decays by MRO depth) ───────────────────
+    /**
+     * Weight applied when the receiver's type binding resolves to a class that
+     * declares the candidate as a method/field. Decays by MRO depth: direct
+     * class = index 0; 1 parent hop = index 1; etc. Falls back to the last
+     * value for depths beyond the table.
+     */
+    typeBindingByMroDepth: [0.5, 0.42, 0.36, 0.32, 0.3],
+    // ─── Corroborating signals ────────────────────────────────────────────────
+    /** `def.ownerId === resolvedReceiver.def.id` (exact owner match). */
+    ownerMatch: 0.2,
+    /** Explanatory only — retained for debuggability. Never discriminates
+     *  because surviving candidates already passed `acceptedKinds`. */
+    kindMatch: 0.0,
+    // ─── Arity compatibility (from `provider.arityCompatibility`) ─────────────
+    /** `provider.arityCompatibility(...) === 'compatible'` */
+    arityMatchCompatible: 0.1,
+    /** `provider.arityCompatibility(...) === 'unknown'` */
+    arityMatchUnknown: 0.0,
+    /** `provider.arityCompatibility(...) === 'incompatible'` — penalizes;
+     *  candidates filtered only when a compatible candidate exists. */
+    arityMatchIncompatible: -0.15,
+    // ─── Global fallback (only when nothing lexically visible) ────────────────
+    /** Hit via `QualifiedNameIndex.byQualifiedName`. */
+    globalQualified: 0.35,
+    /** Fallback hit in a `byName` index (and nothing was lexically visible). */
+    globalName: 0.1,
+    // ─── Degraded signals ─────────────────────────────────────────────────────
+    /** Call/reference flowing through a `dynamic-unresolved` edge. */
+    dynamicImportUnresolved: 0.02,
+    // ─── Unresolved-import cap (multiplicative, applied per-signal) ───────────
+    /**
+     * Multiplicative cap on the edge-derived evidence signal
+     * (`import`/`wildcard`/`reexport`/`namespace`) when
+     * `ImportEdge.linkStatus === 'unresolved'`. Independent corroborating
+     * signals on the same candidate (`owner-match`, `arity-match`,
+     * `type-binding`) are NOT penalized.
+     */
+    unlinkedImportMultiplier: 0.5,
+};
+/**
+ * Look up the `type-binding` signal weight for a given MRO depth, falling
+ * back to the last tabulated value for depths beyond the table.
+ */
+function typeBindingWeightAtDepth(mroDepth) {
+    const table = exports.EvidenceWeights.typeBindingByMroDepth;
+    if (mroDepth < 0)
+        return table[0];
+    if (mroDepth >= table.length)
+        return table[table.length - 1];
+    return table[mroDepth];
+}