Merge pull request #1643 from AxiomCodeAI/fix/1392-mapper-context-seed

java: context orders equal-scoring entry points by the text file the question asks about (#1392)

Author: swapnilpaliwal-sd

plugins/axiomcode/skills/axiomcode/scripts/axiomcode-context

@@ -209,7 +209,7 @@ def rank_dirs(g, terms, depth=3, topk=DIR_EVIDENCE):
     return ranked
 
 
-def pick_seeds(g, scored, terms, want, named=()):
+def pick_seeds(g, scored, terms, want, named=(), prefer=frozenset()):
     """The entry points, in four passes, each only filling what the one before left:
 
       1. what the question NAMES: a declaration it spells out (`IRouter.RouteAsync`), a route it quotes
@@ -221,17 +221,28 @@ def pick_seeds(g, scored, terms, want, named=()):
       3. the best symbol for each term still uncovered, as before, so a task naming unrelated concepts still enters the
          graph at each of them;
       4. the best overall.
+
+    Equal scores are common: `findByCode` on a mapper, a repository, a service and a query class all match the same
+    two words the same way. A tie used to fall to the graph's symbol ids, which are hashes that change with the
+    directory a project is indexed in, so the same question on the same code picked a different four of nine from one
+    copy to the next. A tie now goes first to `prefer` (a declaration bound by a text file of the kind the question
+    asks about: the mapper method whose XML holds the SQL, when the question asks which SQL runs), then to the one
+    whose own name holds more of the matched words, then to its name and place, which do not move.
     """
     seeds, seen, covered = [], set(), set()
     def take(sid, why, sc):
         if sid in seen or len(seeds) >= want: return False
         seen.add(sid); seeds.append((sid, why, sc)); covered.update(scored.get(sid, (0, []))[1]); return True
     for sid, why in named:
         take(sid, why, scored.get(sid, (0, []))[0])
-    ranked = sorted(scored.items(), key=lambda kv: -kv[1][0])
+    # the task's words in the declaration's OWN name beat the same words reached through its owner or its path:
+    # `OrderCreatedEvent` says more about "where is an order created" than `Order.getCreatedAt` does
+    own = lambda sid: sum(t in ((g.sym.get(sid) or {}).get('name') or '').lower() for t in scored.get(sid, (0, []))[1])
+    tie = lambda sid: (sid not in prefer, -own(sid), g.disp(sid) or '', g.loc(sid) or '', sid)
+    ranked = sorted(scored.items(), key=lambda kv: (-kv[1][0],) + tie(kv[0]))
     floor = 0.05 * ranked[0][1][0] if ranked else 0
     multi = [(sid, sc, m) for sid, (sc, m) in ranked if len(m) >= 2 and sc >= floor]
-    multi.sort(key=lambda r: (-len(r[2]), -r[1]))
+    multi.sort(key=lambda r: (-len(r[2]), -r[1]) + tie(r[0]))
     for i, (sid, sc, m) in enumerate(multi):
         if len(seeds) >= want: break
         if not set(m) - covered: continue
@@ -241,7 +252,7 @@ def pick_seeds(g, scored, terms, want, named=()):
             if sib >= FLOW_FAN: break
             if m2 == m and sc2 >= 0.5 * sc and take(sid2, "matches '" + "' + '".join(m2) + "'", sc2): sib += 1
     best = {}
-    for sid, (sc, matched) in scored.items():
+    for sid, (sc, matched) in ranked:
         for t in matched:
             cur = best.get(t)
             if cur is None or sc > cur[0]: best[t] = (sc, sid)
@@ -585,6 +596,19 @@ def text_bindings(g, sids, under=(), want_ext=()):
     return [r for _k, r in sorted(out)]
 
 
+def asked_bound(g, scored, text, under=(), cap=300):
+    """{symbol id} among the multi-term matches that a text file of the kind the question asks about binds by name.
+    Empty unless the question asks about such a file (SQL, configuration, a template): only then is the tree walked,
+    and only then does it break a tie between equally scored entry points (pick_seeds)."""
+    kinds = asked_exts(text)
+    if not kinds or not NONSOURCE_ASK.search(text or ''): return frozenset()
+    cands = sorted((sid for sid, (_sc, m) in scored.items() if len(m) >= 2), key=lambda s: -scored[s][0])[:cap]
+    by_disp = collections.defaultdict(set)
+    for sid in cands: by_disp[g.disp(sid)].add(sid)
+    return frozenset(sid for f, _l, d, _n in text_bindings(g, cands, under=under, want_ext=kinds)
+                     if f.endswith(kinds) for sid in by_disp.get(d, ()))
+
+
 _SRC = {}
 def source_lines(repo, f):
     """The file's lines, read once. The graph stores repo-relative paths; a run may be started anywhere."""
@@ -990,7 +1014,7 @@ def main(argv):
     # themselves, and on Python every class has one, so they can be a third of this list while
     # naming nowhere to go.
     scored = {sid: v for sid, v in scored.items() if not is_synthetic(g.sym.get(sid, {}).get('name'))}
-    seeds = pick_seeds(g, scored, terms, seeds_wanted, named)
+    seeds = pick_seeds(g, scored, terms, seeds_wanted, named, prefer=asked_bound(g, scored, body, text_dirs))
 
     RESULT['terms'] = list(terms)
     RESULT['scope'], RESULT['scope_offered'] = (scopes[0] if scopes else None), bool(scope_offered)
@@ -1123,10 +1147,10 @@ def main(argv):
                 sp = span_of.get((f, nm))
                 if not sp: continue
                 a, b = sp
-                body = source_lines(g.repo, f)[a - 1:min(b, a + SOURCE_LINES)]
-                if not body: continue
+                code = source_lines(g.repo, f)[a - 1:min(b, a + SOURCE_LINES)]   # not `body`: that is the question
+                if not code: continue
                 print(f"    {'':22}   {nm}  ({f}:{a})")
-                for k, ln in enumerate(body, a):
+                for k, ln in enumerate(code, a):
                     print(f"    {'':22}   {k:5} | {ln.rstrip()[:110]}")
                 if b > a + SOURCE_LINES: print(f"    {'':22}   {'':5} | … +{b - a - SOURCE_LINES} more line(s)")
     if foot and budget > 0: print(foot + ", tests and benchmarks not listed")
@@ -1144,9 +1168,13 @@ def main(argv):
         if g.has('overrides') and seed_ids:
             ph = ','.join('?' * len(seed_ids))
             impls = {r[0] for r in g.q(f"SELECT overriding_method_id FROM overrides WHERE method_id IN ({ph})", *seed_ids)} - seed_ids
+            # nearer through the implementation than through the seeds' own closure counts as nearer: the mapper call
+            # in the impl is one hop from it however far the closure walk happened to place it (hop 3 is outside the ring)
             for x, d in neighbourhood(g, [i for i in impls if i in g.sym], cap=1).items():
-                if x not in seed_ids and x in g.sym and x not in depth: depth[x] = d + 1; ring.append(x)
-        near = list(seed_ids) + sorted(ring, key=lambda x: (not bodiless(g, x), depth[x], x))[:300]
+                if x in seed_ids or x not in g.sym or depth.get(x, d + 2) <= d + 1: continue
+                if depth.get(x, 3) > 2: ring.append(x)
+                depth[x] = d + 1
+        near = list(seed_ids) + sorted(ring, key=lambda x: (not bodiless(g, x), depth[x], g.disp(x) or '', x))[:300]
         kinds = asked_exts(body)
         binds = text_bindings(g, near, under=text_dirs, want_ext=kinds)
         # the question named a kind of file (SQL: mapper XML or .sql): when some binding is of that kind, the others

tests/cases/java/context-sql-tie-picks-the-bound-method/case.json

@@ -0,0 +1,15 @@
+{"lang": "java",
+ "checks": [
+  {"why": "entry points that match the task's words equally are ordered by what the question asks for, not by symbol ids: a SQL question puts the mapper method its XML binds first, and lists that XML, though four other declarations match the same two words and sort before it by name",
+   "run": ["context", "which SQL runs when an order is loaded by number"],
+   "want": ["entry points", "    OrderMapper.findByNumber ", "text files that name these declarations",
+            "src/main/resources/mapper/OrderMapper.xml:3", "names findByNumber (OrderMapper.findByNumber)"],
+   "avoid": ["WidgetMapper.xml"]},
+  {"why": "near miss: the same words without asking about SQL get no text-file section, so the XML is not listed and no tree walk is paid for",
+   "run": ["context", "where is an order loaded by number"],
+   "want": ["entry points", "Order.toNumber"],
+   "avoid": ["text files that name", "OrderMapper.xml", "WidgetMapper.xml"]},
+  {"why": "--source with a SQL question prints the code and still lists the XML (the printed code once replaced the question text, and the text-file check crashed on it)",
+   "run": ["context", "which SQL runs when an order is loaded by number", "--source"],
+   "want": ["src/main/resources/mapper/OrderMapper.xml:3"],
+   "avoid": ["Traceback", "WidgetMapper.xml"]}]}

tests/cases/java/context-sql-tie-picks-the-bound-method/src/main/java/demo/order/Order.java

@@ -0,0 +1,8 @@
+package demo.order;
+
+public class Order {
+    public long id;
+    public String ref;
+
+    public static String toNumber(String ref) { return ref.toUpperCase(); }
+}

tests/cases/java/context-sql-tie-picks-the-bound-method/src/main/java/demo/order/OrderAudit.java

@@ -0,0 +1,12 @@
+package demo.order;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class OrderAudit {
+    private final Map<String, Order> seen = new HashMap<>();
+
+    public Order findByNumber(String number) {
+        return seen.get(Order.toNumber(number));
+    }
+}

tests/cases/java/context-sql-tie-picks-the-bound-method/src/main/java/demo/order/OrderCache.java

@@ -0,0 +1,12 @@
+package demo.order;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class OrderCache {
+    private final Map<String, Order> seen = new HashMap<>();
+
+    public Order findByNumber(String number) {
+        return seen.get(Order.toNumber(number));
+    }
+}

tests/cases/java/context-sql-tie-picks-the-bound-method/src/main/java/demo/order/OrderLabel.java

@@ -0,0 +1,12 @@
+package demo.order;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class OrderLabel {
+    private final Map<String, Order> seen = new HashMap<>();
+
+    public Order findByNumber(String number) {
+        return seen.get(Order.toNumber(number));
+    }
+}

tests/cases/java/context-sql-tie-picks-the-bound-method/src/main/java/demo/order/OrderMapper.java

@@ -0,0 +1,8 @@
+package demo.order;
+
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface OrderMapper {
+    Order findByNumber(String number);
+}

tests/cases/java/context-sql-tie-picks-the-bound-method/src/main/java/demo/order/OrderService.java

@@ -0,0 +1,11 @@
+package demo.order;
+
+public class OrderService {
+    private final OrderMapper mapper;
+
+    public OrderService(OrderMapper mapper) { this.mapper = mapper; }
+
+    public Order resolve(String number) {
+        return mapper.findByNumber(number);
+    }
+}

tests/cases/java/context-sql-tie-picks-the-bound-method/src/main/resources/mapper/OrderMapper.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<mapper namespace="demo.order.OrderMapper">
+  <select id="findByNumber" resultType="demo.order.Order">select id, ref from orders where ref = #{number}</select>
+</mapper>

tests/cases/java/context-sql-tie-picks-the-bound-method/src/main/resources/mapper/WidgetMapper.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<mapper namespace="demo.widget.WidgetMapper">
+  <select id="findByNumber" resultType="demo.widget.Widget">select id from widgets where code = #{number}</select>
+</mapper>