Update app

app/detector.py

@@ -71,6 +71,17 @@ def _infer_model_hint(definitions_kind: dict[str, str]) -> str | None:
     return max(counts.items(), key=lambda item: item[1])[0]
 
 
+def _softmax_weighted(scores: list[float]) -> float:
+    if not scores:
+        return 0.0
+    max_score = max(scores)
+    weights = [float(np.exp(score - max_score)) for score in scores]
+    total = sum(weights)
+    if total <= 0:
+        return float(sum(scores)) / float(len(scores))
+    return float(sum(score * weight for score, weight in zip(scores, weights)) / total)
+
+
 def _normalize_source_path(path: str | None) -> str | None:
     if not path:
         return None
@@ -520,19 +531,25 @@ class CodeSimilarityAnalyzer:
 
         by_class_out: dict[str, list[dict[str, object]]] = {}
         for qcls, cand_map in by_class.items():
+            q_method_count = len(
+                [key for key, kind in definitions_kind.items() if kind == "method" and key.startswith(f"{qcls}.")]
+            )
+            q_method_count = max(1, q_method_count)
             rows = []
             for _, slot in cand_map.items():
                 scores = sorted(slot["scores"], reverse=True)
-                top = scores[:3]
-                score = float(sum(top) / max(1, len(top)))
+                base_score = _softmax_weighted(scores)
+                coverage_count = len(scores)
+                coverage_ratio = coverage_count / float(q_method_count)
                 contributors = sorted(slot["contributors"], key=lambda x: float(x["score"]), reverse=True)[:5]
                 rows.append(
                     {
                         "relative_path": slot["relative_path"],
                         "class_name": slot["class_name"],
                         "identifier": f"{slot['relative_path']}:{slot['class_name']}",
-                        "score": score,
-                        "coverage": len(scores),
+                        "score": base_score,
+                        "coverage": coverage_count,
+                        "coverage_pct": coverage_ratio,
                         "top_contributors": contributors,
                     }
                 )

app/main.py

@@ -85,12 +85,40 @@ def _summarize_ast(node: ast.AST) -> dict[str, list[dict[str, int]]]:
     return {"node_counts": node_counts, "calls": call_counts}
 
 
-def _extract_ast(source: str, symbol: str) -> tuple[str | None, dict[str, list[dict[str, int]]] | None]:
+def _strip_node_docstring(node: ast.AST) -> None:
+    if not isinstance(node, (ast.AsyncFunctionDef, ast.FunctionDef, ast.ClassDef)):
+        return
+    if not node.body:
+        return
+    first = node.body[0]
+    if isinstance(first, ast.Expr) and isinstance(getattr(first, "value", None), ast.Constant):
+        if isinstance(first.value.value, str):
+            node.body.pop(0)
+
+
+def _get_structural_flow(node: ast.AST) -> str:
+    flow: list[str] = []
+    for child in ast.walk(node):
+        if isinstance(child, ast.Call):
+            name = _call_name(child.func)
+            if name:
+                flow.append(name)
+        elif isinstance(child, (ast.If, ast.While, ast.For)):
+            flow.append(f"Control({type(child).__name__})")
+    return " -> ".join(flow[:15])
+
+
+def _extract_ast(source: str, symbol: str) -> tuple[str | None, dict[str, object] | None]:
     tree = ast.parse(source)
     node = _find_definition(tree, symbol)
     if node is None:
         return None, None
-    return ast.dump(node, include_attributes=False, indent=2), _summarize_ast(node)
+    _strip_node_docstring(node)
+    try:
+        code = ast.unparse(node)
+    except Exception:
+        code = None
+    return code, {"summary": _summarize_ast(node), "flow": _get_structural_flow(node)}
 
 
 @app.get("/")

static/app.js

@@ -41,11 +41,13 @@ function renderIndexInfo(info) {
 
 function formatSummary(summary) {
   if (!summary) return "No structural summary.";
-  const nodes = (summary.node_counts || [])
+  const flow = summary.flow ? `Flow: ${summary.flow}` : "";
+  const nodes = (summary.summary?.node_counts || [])
     .map((item) => `${item.name}(${item.count})`)
     .join(", ");
-  const calls = (summary.calls || []).map((item) => `${item.name}(${item.count})`).join(", ");
+  const calls = (summary.summary?.calls || []).map((item) => `${item.name}(${item.count})`).join(", ");
   const parts = [];
+  if (flow) parts.push(flow);
   if (nodes) parts.push(`Nodes: ${nodes}`);
   if (calls) parts.push(`Calls: ${calls}`);
   return parts.join(" · ") || "No structural summary.";
@@ -101,7 +103,8 @@ function renderByClass(byClass) {
       const line = document.createElement("div");
       line.className = "match-row";
       const left = document.createElement("span");
-      left.textContent = `${row.class_name} · ${Number(row.score).toFixed(4)} · ${row.coverage} defs`;
+      const coverage = row.coverage_pct !== undefined ? ` · ${(row.coverage_pct * 100).toFixed(0)}%` : "";
+      left.textContent = `${row.class_name} · ${Number(row.score).toFixed(4)} · ${row.coverage} defs${coverage}`;
       const right = document.createElement("span");
       right.textContent = row.relative_path;
       line.appendChild(left);