fix: resolve merge conflicts with main

Author: carlos-alm

.github/workflows/ci.yml

@@ -174,17 +174,11 @@ jobs:
     steps:
       - uses: actions/checkout@v6
 
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 22
-
-      - name: Install dependencies
-        timeout-minutes: 20
-        run: npm ci
-
       - name: Audit production dependencies
-        run: npm audit --omit=dev --audit-level=high
+        # --package-lock-only reads the lock file directly — no npm install needed.
+        # This avoids flaky binary downloads (e.g. onnxruntime-node) that would
+        # abort the audit before it can report real vulnerabilities.
+        run: npm audit --omit=dev --audit-level=high --package-lock-only
 
   verify-imports:
     runs-on: ubuntu-latest

CLAUDE.md

@@ -10,7 +10,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 > **Never silently skip verification.** If tests, builds, or any verification step cannot run or fails for any reason (compilation errors, platform issues, missing dependencies), STOP and report the issue to the user immediately. Never silently proceed with unverified changes. Let the user decide whether to proceed — do not make that decision yourself.
 
-> **Scope discipline — open issues, don't expand scope.** When you encounter a problem unrelated to the current task — pre-existing bugs, code that needs a bigger refactor, or any defect that does not directly affect the result of what you're doing — open a GitHub issue with `gh issue create` and keep going. Only fix it inline when it directly affects the correctness or outcome of the work in front of you. This keeps PRs focused (one concern per PR) while ensuring the finding is not lost.
+> **Scope discipline — open issues, don't expand scope.** When you encounter anything out of scope — a pre-existing bug, a refactor opportunity, a potential improvement, a missing feature, or any other finding that doesn't directly affect the correctness of the current task — **immediately open a GitHub issue with `gh issue create` before continuing**. Do not hold the finding in memory or defer it to a comment. Only address it inline when it directly blocks the result of the work in front of you. This keeps PRs focused (one concern per PR) while ensuring no finding is lost.
 
 > **Prioritize the best architecture, not the smallest diff.** Do not default to the simplest or most localized fix. Choose the approach that fits the codebase's architecture best, even when that means larger changes, moving code across modules, or restructuring an abstraction. Do not be afraid of bigger changes — a larger diff that leaves the design healthier is preferable to a small diff that entrenches a poor structure. Surface the architectural reasoning to the user; don't silently shrink the change to avoid the work.
 

crates/codegraph-core/src/edge_builder.rs

@@ -96,7 +96,7 @@ pub struct ComputedEdge {
 
 /// Internal struct for caller resolution (def line range → node ID).
 struct DefWithId<'a> {
-    _name: &'a str,
+    name: &'a str,
     line: u32,
     end_line: u32,
     node_id: Option<u32>,
@@ -106,6 +106,8 @@ struct DefWithId<'a> {
 struct EdgeContext<'a> {
     nodes_by_name: HashMap<&'a str, Vec<&'a NodeInfo>>,
     nodes_by_name_and_file: HashMap<(&'a str, &'a str), Vec<&'a NodeInfo>>,
+    /// All nodes grouped by file — used for same-file method resolution (CHA this-dispatch).
+    nodes_by_file: HashMap<&'a str, Vec<&'a NodeInfo>>,
     builtin_set: HashSet<&'a str>,
     receiver_kinds: HashSet<&'a str>,
 }
@@ -114,17 +116,19 @@ impl<'a> EdgeContext<'a> {
     fn new(all_nodes: &'a [NodeInfo], builtin_receivers: &'a [String]) -> Self {
         let mut nodes_by_name: HashMap<&str, Vec<&NodeInfo>> = HashMap::new();
         let mut nodes_by_name_and_file: HashMap<(&str, &str), Vec<&NodeInfo>> = HashMap::new();
+        let mut nodes_by_file: HashMap<&str, Vec<&NodeInfo>> = HashMap::new();
         for node in all_nodes {
             nodes_by_name.entry(&node.name).or_default().push(node);
             nodes_by_name_and_file
                 .entry((&node.name, &node.file))
                 .or_default()
                 .push(node);
+            nodes_by_file.entry(&node.file).or_default().push(node);
         }
         let builtin_set: HashSet<&str> = builtin_receivers.iter().map(|s| s.as_str()).collect();
         let receiver_kinds: HashSet<&str> = ["class", "struct", "interface", "type", "module"]
             .iter().copied().collect();
-        Self { nodes_by_name, nodes_by_name_and_file, builtin_set, receiver_kinds }
+        Self { nodes_by_name, nodes_by_name_and_file, nodes_by_file, builtin_set, receiver_kinds }
     }
 }
 
@@ -253,7 +257,7 @@ fn process_file<'a>(
         let node_id = file_nodes.iter()
             .find(|n| n.name == d.name && n.kind == d.kind && n.line == d.line)
             .map(|n| n.id);
-        DefWithId { _name: &d.name, line: d.line, end_line: d.end_line.unwrap_or(u32::MAX), node_id }
+        DefWithId { name: &d.name, line: d.line, end_line: d.end_line.unwrap_or(u32::MAX), node_id }
     }).collect();
 
     // Phase 8.3: build pts map for alias resolution.
@@ -280,11 +284,11 @@ fn process_file<'a>(
             if ctx.builtin_set.contains(receiver.as_str()) { continue; }
         }
 
-        let caller_id = find_enclosing_caller(&defs_with_ids, call.line, file_node_id);
+        let (caller_id, caller_name) = find_enclosing_caller(&defs_with_ids, call.line, file_node_id);
         let is_dynamic = if call.dynamic.unwrap_or(false) { 1u32 } else { 0u32 };
         let imported_from = imported_names.get(call.name.as_str()).copied();
 
-        let mut targets = resolve_call_targets(ctx, call, rel_path, imported_from, &type_map);
+        let mut targets = resolve_call_targets(ctx, call, rel_path, imported_from, &type_map, caller_name);
         sort_targets_by_confidence(&mut targets, rel_path, imported_from);
         emit_call_edges(&targets, caller_id, is_dynamic, rel_path, imported_from, &mut seen_edges, &mut pts_edge_map, edges);
 
@@ -307,7 +311,7 @@ fn process_file<'a>(
                         receiver: None,
                     };
                     let mut alias_targets = resolve_call_targets(
-                        ctx, &alias_call, rel_path, alias_imported_from, &type_map,
+                        ctx, &alias_call, rel_path, alias_imported_from, &type_map, caller_name,
                     );
                     sort_targets_by_confidence(&mut alias_targets, rel_path, alias_imported_from);
                     for t in &alias_targets {
@@ -339,30 +343,36 @@ fn process_file<'a>(
 }
 
 /// Find the narrowest enclosing definition for a call at the given line.
-fn find_enclosing_caller(defs: &[DefWithId], call_line: u32, file_node_id: u32) -> u32 {
+/// Returns `(caller_id, caller_name)` — `caller_name` is `""` when the call is at file scope.
+fn find_enclosing_caller<'a>(defs: &[DefWithId<'a>], call_line: u32, file_node_id: u32) -> (u32, &'a str) {
     let mut caller_id = file_node_id;
+    let mut caller_name = "";
     let mut caller_span = u32::MAX;
     for def in defs {
         if def.line <= call_line && call_line <= def.end_line {
             let span = def.end_line - def.line;
             if span < caller_span {
                 if let Some(id) = def.node_id {
                     caller_id = id;
+                    caller_name = def.name;
                     caller_span = span;
                 }
             }
         }
     }
-    caller_id
+    (caller_id, caller_name)
 }
 
 /// Multi-strategy call target resolution: import-aware → same-file → method → type-aware → scoped.
+/// `caller_name` is the enclosing function/method name (e.g. `"Shape.describe"`) used to scope
+/// `this`/`self`/`super` dispatch to the caller's own class before falling back to a broader scan.
 fn resolve_call_targets<'a>(
     ctx: &EdgeContext<'a>,
     call: &CallInfo,
     rel_path: &str,
     imported_from: Option<&str>,
     type_map: &HashMap<&str, (&str, f64)>,
+    caller_name: &str,
 ) -> Vec<&'a NodeInfo> {
     // 1. Import-aware resolution
     if let Some(imp_file) = imported_from {
@@ -386,9 +396,18 @@ fn resolve_call_targets<'a>(
         .unwrap_or_default();
     if !method_candidates.is_empty() { return method_candidates; }
 
-    // 4. Type-aware resolution via receiver → type map
+    // 4. Type-aware resolution via receiver → type map.
+    // Strips "this." prefix so `this.repo.method()` resolves via typeMap["repo"]
+    // or typeMap["this.repo"] (both seeded by the class-field extractor).
     if let Some(ref receiver) = call.receiver {
-        if let Some(&(type_name, _conf)) = type_map.get(receiver.as_str()) {
+        let effective_receiver = if receiver.starts_with("this.") {
+            &receiver["this.".len()..]
+        } else {
+            receiver.as_str()
+        };
+        let type_lookup = type_map.get(effective_receiver)
+            .or_else(|| type_map.get(receiver.as_str()));
+        if let Some(&(type_name, _conf)) = type_lookup {
             let qualified = format!("{}.{}", type_name, call.name);
             let typed: Vec<&NodeInfo> = ctx.nodes_by_name
                 .get(qualified.as_str())
@@ -415,12 +434,44 @@ fn resolve_call_targets<'a>(
         || call.receiver.as_deref() == Some("self")
         || call.receiver.as_deref() == Some("super")
     {
-        return ctx.nodes_by_name
+        // First try exact name match (e.g. an unqualified function named "area").
+        let exact: Vec<&NodeInfo> = ctx.nodes_by_name
             .get(call.name.as_str())
             .map(|v| v.iter()
                 .filter(|n| import_resolution::compute_confidence(rel_path, &n.file, None) >= 0.5)
                 .copied().collect())
             .unwrap_or_default();
+        if !exact.is_empty() { return exact; }
+
+        // For this/self/super: prefer class-scoped exact lookup (e.g. `this.area()` in
+        // `Shape.describe` → try `Shape.area` first).  This avoids false edges to unrelated
+        // classes that happen to have a method with the same name in the same file.
+        // Fall back to the broader same-file suffix scan only when the class-scoped lookup
+        // finds nothing (e.g. when the caller is at module scope or the name is unknown).
+        if call.receiver.is_some() {
+            // Extract the class prefix from the enclosing caller name (e.g. "Shape" from "Shape.describe").
+            if let Some(dot_pos) = caller_name.find('.') {
+                let class_prefix = &caller_name[..dot_pos];
+                let qualified = format!("{}.{}", class_prefix, call.name);
+                let class_scoped: Vec<&NodeInfo> = ctx.nodes_by_name
+                    .get(qualified.as_str())
+                    .map(|v| v.iter().filter(|n| n.kind == "method").copied().collect())
+                    .unwrap_or_default();
+                if !class_scoped.is_empty() { return class_scoped; }
+            }
+
+            // Broader fallback: same-file suffix scan to pick up CHA-expanded targets
+            // (subclasses that override the method).
+            let suffix = format!(".{}", call.name);
+            if let Some(file_nodes) = ctx.nodes_by_file.get(rel_path) {
+                let same_file_methods: Vec<&NodeInfo> = file_nodes.iter()
+                    .filter(|n| n.kind == "method" && n.name.ends_with(&suffix))
+                    .copied()
+                    .collect();
+                if !same_file_methods.is_empty() { return same_file_methods; }
+            }
+        }
+        return exact; // empty
     }
 
     Vec::new()

crates/codegraph-core/src/extractors/javascript.rs

@@ -140,6 +140,29 @@ fn match_js_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dep
                 }
             }
         }
+        // TypeScript class field declarations: `private repo: Repository<User>`
+        // Seeds both "repo" and "this.repo" so that `this.repo.method()` calls
+        // can be resolved to the interface/class type via the type map.
+        "public_field_definition" | "field_definition" => {
+            let name_node = node.child_by_field_name("name")
+                .or_else(|| node.child_by_field_name("property"))
+                .or_else(|| find_child(node, "property_identifier"));
+            if let Some(name_node) = name_node {
+                let kind = name_node.kind();
+                if kind == "property_identifier" || kind == "identifier"
+                    || kind == "private_property_identifier"
+                {
+                    let field_name = node_text(&name_node, source).to_string();
+                    if let Some(type_anno) = find_child(node, "type_annotation") {
+                        if let Some(type_name) = extract_simple_type_name(&type_anno, source) {
+                            push_type_map_entry(symbols, field_name.clone(), type_name.to_string());
+                            // "this.fieldName" key resolves `this.repo.method()` calls.
+                            push_type_map_entry(symbols, format!("this.{}", field_name), type_name.to_string());
+                        }
+                    }
+                }
+            }
+        }
         _ => {}
     }
 }

src/domain/graph/builder/call-resolver.ts

@@ -64,9 +64,15 @@ export function resolveByMethodOrGlobal(
   call: { name: string; receiver?: string | null },
   relPath: string,
   typeMap: Map<string, unknown>,
+  callerName?: string | null,
 ): ReadonlyArray<{ id: number; file: string }> {
   if (call.receiver) {
-    const typeEntry = typeMap.get(call.receiver);
+    // Strip "this." so `this.repo.method()` resolves via typeMap["repo"]
+    // (or the "this.repo" key seeded directly by the TSC property-declaration enricher).
+    const effectiveReceiver = call.receiver.startsWith('this.')
+      ? call.receiver.slice('this.'.length)
+      : call.receiver;
+    const typeEntry = typeMap.get(effectiveReceiver) ?? typeMap.get(call.receiver);
     let typeName = typeEntry
       ? typeof typeEntry === 'string'
         ? typeEntry
@@ -122,7 +128,26 @@ export function resolveByMethodOrGlobal(
     call.receiver === 'self' ||
     call.receiver === 'super'
   ) {
-    return lookup.byName(call.name).filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+    const exact = lookup
+      .byName(call.name)
+      .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+    if (exact.length > 0) return exact;
+
+    // For this/self/super receiver: try same-class method lookup via callerName.
+    // e.g. `this.area()` inside `Shape.describe` → try `Shape.area`.
+    // This seeds the initial edge that runChaPostPass later expands to subclass overrides.
+    if (call.receiver && callerName) {
+      const dotIdx = callerName.lastIndexOf('.');
+      if (dotIdx > -1) {
+        const callerClass = callerName.slice(0, dotIdx);
+        const qualifiedName = `${callerClass}.${call.name}`;
+        const sameClass = lookup
+          .byName(qualifiedName)
+          .filter((t) => t.kind === 'method' && computeConfidence(relPath, t.file, null) >= 0.5);
+        if (sameClass.length > 0) return sameClass;
+      }
+    }
+    return exact; // empty
   }
   return [];
 }
@@ -133,6 +158,7 @@ export function resolveCallTargets(
   relPath: string,
   importedNames: Map<string, string>,
   typeMap: Map<string, unknown>,
+  callerName?: string | null,
 ): { targets: Array<{ id: number; file: string }>; importedFrom: string | undefined } {
   const importedFrom = importedNames.get(call.name);
   let targets: ReadonlyArray<{ id: number; file: string }> | undefined;
@@ -150,7 +176,7 @@ export function resolveCallTargets(
   if (!targets || targets.length === 0) {
     targets = lookup.byNameAndFile(call.name, relPath);
     if (targets.length === 0) {
-      targets = resolveByMethodOrGlobal(lookup, call, relPath, typeMap);
+      targets = resolveByMethodOrGlobal(lookup, call, relPath, typeMap, callerName);
     }
   }