trace-mcp 1.19.0 → 1.20.0

package/dist/cli.js

@@ -1365,6 +1365,11 @@ var init_symbol_repository = __esm({
       getSymbolById(id) {
         return this._stmts.getSymbolById.get(id);
       }
+      getSymbolChildren(parentId) {
+        return this.db.prepare(
+          "SELECT * FROM symbols WHERE parent_id = ?"
+        ).all(parentId);
+      }
       getSymbolByName(name, kind) {
         if (kind) {
           return this.db.prepare(
@@ -2228,6 +2233,9 @@ var init_store = __esm({
       getSymbolByName(name, kind) {
         return this.symbols.getSymbolByName(name, kind);
       }
+      getSymbolChildren(parentId) {
+        return this.symbols.getSymbolChildren(parentId);
+      }
       getExportedSymbols(filePattern) {
         return this.symbols.getExportedSymbols(filePattern);
       }
@@ -5428,6 +5436,44 @@ function extractInheritanceEdges(bases, classSymbolId) {
     metadata: { base }
   }));
 }
+function extractNameMainCallees(root) {
+  const callees = [];
+  for (const node of root.namedChildren) {
+    if (node.type !== "if_statement") continue;
+    const condition = node.childForFieldName("condition");
+    if (!condition) continue;
+    if (!isNameMainCondition(condition)) continue;
+    const body = node.childForFieldName("consequence");
+    if (!body) continue;
+    collectCalleeNames(body, callees);
+  }
+  return callees;
+}
+function isNameMainCondition(node) {
+  if (node.type !== "comparison_operator") return false;
+  const text = node.text;
+  return text.includes("__name__") && (text.includes('"__main__"') || text.includes("'__main__'"));
+}
+function collectCalleeNames(node, out) {
+  for (const child of node.namedChildren) {
+    if (child.type === "expression_statement") {
+      collectCalleeNames(child, out);
+    } else if (child.type === "call") {
+      const fn2 = child.childForFieldName("function");
+      if (fn2) {
+        if (fn2.type === "identifier") {
+          out.push(fn2.text);
+        }
+        const args = child.childForFieldName("arguments");
+        if (args) collectCalleeNames(args, out);
+      }
+    } else if (child.type === "function_definition" || child.type === "class_definition") {
+      continue;
+    } else {
+      collectCalleeNames(child, out);
+    }
+  }
+}
 function extractTypeCheckingImports(root) {
   const edges = [];
   for (const node of root.namedChildren) {
@@ -6132,6 +6178,29 @@ function extractIterableStrings(node) {
 }
 function inferLocalTypes(body) {
   const types = /* @__PURE__ */ new Map();
+  const funcDef = body.parent;
+  if (funcDef && (funcDef.type === "function_definition" || funcDef.type === "decorated_definition")) {
+    const defNode = funcDef.type === "decorated_definition" ? funcDef.namedChildren.find((c) => c.type === "function_definition") : funcDef;
+    if (defNode) {
+      const params = defNode.childForFieldName("parameters");
+      if (params) {
+        for (const param of params.namedChildren) {
+          if (param.type === "typed_parameter" || param.type === "typed_default_parameter") {
+            const nameNode = param.childForFieldName("name") ?? param.namedChildren.find((c) => c.type === "identifier");
+            const typeNode = param.childForFieldName("type");
+            if (nameNode && typeNode) {
+              const paramName = nameNode.text;
+              if (paramName === "self" || paramName === "cls") continue;
+              const typeName = extractParamAnnotationType(typeNode);
+              if (typeName) {
+                types.set(paramName, { type: typeName });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
   for (const child of body.namedChildren) {
     if (child.type === "expression_statement") {
       const expr = child.namedChildren[0];
@@ -6193,6 +6262,34 @@ function extractAnnotationType(typeNode) {
   }
   return null;
 }
+function extractParamAnnotationType(typeNode) {
+  if (typeNode.type === "type") {
+    return extractAnnotationType(typeNode);
+  }
+  if (typeNode.type === "identifier") {
+    const name = typeNode.text;
+    if (name[0] >= "A" && name[0] <= "Z") return name;
+    return null;
+  }
+  if (typeNode.type === "attribute") {
+    const attr = typeNode.childForFieldName("attribute");
+    if (attr && attr.text[0] >= "A" && attr.text[0] <= "Z") return attr.text;
+    return null;
+  }
+  if (typeNode.type === "subscript" || typeNode.type === "generic_type") {
+    for (const child of typeNode.namedChildren) {
+      if (child.type === "identifier" && child.text[0] >= "A" && child.text[0] <= "Z") {
+        const WRAPPER_TYPES = /* @__PURE__ */ new Set(["Optional", "List", "Set", "Dict", "Tuple", "Type", "Sequence", "Iterable"]);
+        if (!WRAPPER_TYPES.has(child.text)) return child.text;
+      }
+    }
+    for (const child of typeNode.namedChildren) {
+      const inner = extractParamAnnotationType(child);
+      if (inner) return inner;
+    }
+  }
+  return extractAnnotationType(typeNode);
+}
 function parseCallTarget(fn2, line, localTypes) {
   if (fn2.type === "identifier") {
     const name = fn2.text;
@@ -6447,6 +6544,17 @@ var init_python = __esm({
               sym.metadata.exported = true;
             }
           }
+          const nameMainCallees = extractNameMainCallees(root);
+          if (nameMainCallees.length > 0) {
+            const calleeSet = new Set(nameMainCallees);
+            for (const sym of symbols) {
+              if (sym.parentSymbolId) continue;
+              if (calleeSet.has(sym.name)) {
+                sym.metadata = sym.metadata ?? {};
+                sym.metadata.is_entry_point = "name_main";
+              }
+            }
+          }
           const moduleLevelCalls = extractCallSites(root);
           if (moduleLevelCalls.length > 0) {
             const moduleSymbolId = makeSymbolId3(filePath, "<module>", "function");
@@ -42528,11 +42636,17 @@ function resolvePythonCallEdges(state) {
         if (!targetSymbol) continue;
         const targetNodeId = symbolNodeMap.get(targetSymbol.id);
         if (targetNodeId == null || targetNodeId === sourceNodeId) continue;
+        const edgeMeta = { callee: call.calleeName, line: call.line };
+        if (call.receiverType) edgeMeta.receiver_type = call.receiverType;
+        else if (call.receiverAssignedFrom) {
+          const inferredType = returnTypeIndex.get(call.receiverAssignedFrom);
+          if (inferredType) edgeMeta.receiver_type = inferredType;
+        }
         insertStmt.run(
           sourceNodeId,
           targetNodeId,
           callsEdgeType.id,
-          JSON.stringify({ callee: call.calleeName, line: call.line })
+          JSON.stringify(edgeMeta)
         );
         created++;
       }
@@ -42737,6 +42851,13 @@ function resolveMethodOnClass(typeName, calleeName, fileSymbols, fileImports, na
       }
     }
   }
+  const methodCandidates = nameIndex.get(calleeName);
+  if (methodCandidates) {
+    const match = methodCandidates.find(
+      (s) => (s.kind === "method" || s.kind === "function") && s.parent_symbol_id != null
+    );
+    if (match) return match;
+  }
   return null;
 }
 function buildFileImportMap(state) {
@@ -42876,6 +42997,10 @@ function resolveTestCoversEdges(state) {
   const targetRefs = store.getNodeRefsBatch(targetNodeIds);
   const targetFileRefIds = [...targetRefs.values()].filter((r) => r.nodeType === "file").map((r) => r.refId);
   const targetFileMap = store.getFilesByIds(targetFileRefIds);
+  const targetSymbolRefIds = [...targetRefs.values()].filter((r) => r.nodeType === "symbol").map((r) => r.refId);
+  const targetSymbolMap = store.getSymbolsByIds(targetSymbolRefIds);
+  const symbolFileIds = [...new Set([...targetSymbolMap.values()].map((s) => s.file_id))];
+  const symbolFileMap = store.getFilesByIds(symbolFileIds);
   const testCoversType = store.db.prepare("SELECT id FROM edge_types WHERE name = ?").get("test_covers");
   if (!testCoversType) return;
   let created = 0;
@@ -42890,18 +43015,32 @@ function resolveTestCoversEdges(state) {
       if (edge.edge_type_name !== "imports") continue;
       if (!testNodeToFile.has(edge.source_node_id)) continue;
       const targetRef = targetRefs.get(edge.target_node_id);
-      if (!targetRef || targetRef.nodeType !== "file") continue;
-      const targetFile = targetFileMap.get(targetRef.refId);
-      if (!targetFile) continue;
-      if (TEST_PATH_RE.test(targetFile.path)) continue;
+      if (!targetRef) continue;
       const testFile = testNodeToFile.get(edge.source_node_id);
-      insertStmt.run(
-        edge.source_node_id,
-        edge.target_node_id,
-        testCoversType.id,
-        JSON.stringify({ test_file: testFile.path })
-      );
-      created++;
+      if (targetRef.nodeType === "file") {
+        const targetFile = targetFileMap.get(targetRef.refId);
+        if (!targetFile) continue;
+        if (TEST_PATH_RE.test(targetFile.path)) continue;
+        insertStmt.run(
+          edge.source_node_id,
+          edge.target_node_id,
+          testCoversType.id,
+          JSON.stringify({ test_file: testFile.path })
+        );
+        created++;
+      } else if (targetRef.nodeType === "symbol") {
+        const targetSymbol = targetSymbolMap.get(targetRef.refId);
+        if (!targetSymbol) continue;
+        const parentFile = symbolFileMap.get(targetSymbol.file_id);
+        if (!parentFile || TEST_PATH_RE.test(parentFile.path)) continue;
+        insertStmt.run(
+          edge.source_node_id,
+          edge.target_node_id,
+          testCoversType.id,
+          JSON.stringify({ test_file: testFile.path, target_symbol: targetSymbol.symbol_id })
+        );
+        created++;
+      }
     }
   })();
   if (created > 0) {
@@ -89601,7 +89740,7 @@ import https from "https";
 import { spawnSync } from "child_process";
 import path65 from "path";
 import fs66 from "fs";
-var CURRENT_VERSION = true ? "1.19.0" : "0.0.0-dev";
+var CURRENT_VERSION = true ? "1.20.0" : "0.0.0-dev";
 var UPDATE_CACHE_PATH = path65.join(TRACE_MCP_HOME, "update-check.json");
 function readCache() {
   try {
@@ -93266,6 +93405,119 @@ function resolveSymbolInput(store, opts) {
   return { symbol: sym, file, resolved_via: resolvedVia };
 }
 
+// src/tools/shared/cha.ts
+var HERITAGE_EDGE_TYPES = [
+  "ts_extends",
+  "ts_implements",
+  // TypeScript
+  "extends",
+  "implements",
+  // PHP
+  "py_inherits"
+  // Python (fallback)
+];
+function expandMethodViaCha(store, symbol, maxDepth = 10) {
+  if (symbol.kind !== "method") {
+    const nodeId = store.getNodeId("symbol", symbol.id);
+    if (nodeId == null) return [];
+    return [{ symbol, nodeId, relation: "self" }];
+  }
+  const methodName = symbol.name;
+  const parentClass = symbol.parent_id != null ? store.getSymbolById(symbol.parent_id) : null;
+  if (!parentClass || parentClass.kind !== "class" && parentClass.kind !== "interface") {
+    const nodeId = store.getNodeId("symbol", symbol.id);
+    if (nodeId == null) return [];
+    return [{ symbol, nodeId, relation: "self" }];
+  }
+  const results = [];
+  const selfNodeId = store.getNodeId("symbol", symbol.id);
+  if (selfNodeId != null) {
+    results.push({ symbol, nodeId: selfNodeId, relation: "self" });
+  }
+  const ancestorClassIds = /* @__PURE__ */ new Set();
+  const descendantClassIds = /* @__PURE__ */ new Set();
+  collectAncestors(store, parentClass, ancestorClassIds, /* @__PURE__ */ new Set(), maxDepth);
+  collectDescendants(store, parentClass.name, descendantClassIds, /* @__PURE__ */ new Set(), maxDepth);
+  for (const classId of ancestorClassIds) {
+    const method = findMethodOnClass(store, classId, methodName);
+    if (method && method.id !== symbol.id) {
+      const nodeId = store.getNodeId("symbol", method.id);
+      if (nodeId != null) {
+        results.push({ symbol: method, nodeId, relation: "ancestor_method" });
+      }
+    }
+  }
+  for (const classId of descendantClassIds) {
+    const method = findMethodOnClass(store, classId, methodName);
+    if (method && method.id !== symbol.id) {
+      const nodeId = store.getNodeId("symbol", method.id);
+      if (nodeId != null) {
+        results.push({ symbol: method, nodeId, relation: "descendant_method" });
+      }
+    }
+  }
+  return results;
+}
+function getChaNodeIds(store, symbol) {
+  return expandMethodViaCha(store, symbol).map((m) => m.nodeId);
+}
+function collectAncestors(store, classSymbol, result, visited, depth) {
+  if (depth <= 0 || visited.has(classSymbol.id)) return;
+  visited.add(classSymbol.id);
+  const nodeId = store.getNodeId("symbol", classSymbol.id);
+  if (nodeId != null) {
+    const outgoing = store.getOutgoingEdges(nodeId);
+    for (const edge of outgoing) {
+      if (!HERITAGE_EDGE_TYPES.includes(edge.edge_type_name)) continue;
+      const targetRef = store.getNodeRef(edge.target_node_id);
+      if (!targetRef || targetRef.nodeType !== "symbol") continue;
+      result.add(targetRef.refId);
+      const parentSym = store.getSymbolById(targetRef.refId);
+      if (parentSym) {
+        collectAncestors(store, parentSym, result, visited, depth - 1);
+      }
+    }
+  }
+  if (classSymbol.metadata) {
+    try {
+      const meta = JSON.parse(classSymbol.metadata);
+      const parentNames = [];
+      const ext = meta["extends"];
+      if (Array.isArray(ext)) parentNames.push(...ext.filter((n) => typeof n === "string"));
+      else if (typeof ext === "string") parentNames.push(ext);
+      const impl = meta["implements"];
+      if (Array.isArray(impl)) parentNames.push(...impl.filter((n) => typeof n === "string"));
+      const bases = meta["bases"];
+      if (Array.isArray(bases)) parentNames.push(...bases.filter((n) => typeof n === "string"));
+      for (const name of parentNames) {
+        const shortName3 = name.includes(".") ? name.split(".").pop() : name;
+        const parentSym = store.getSymbolByName(shortName3, "class") ?? store.getSymbolByName(shortName3, "interface");
+        if (parentSym && !result.has(parentSym.id)) {
+          result.add(parentSym.id);
+          collectAncestors(store, parentSym, result, visited, depth - 1);
+        }
+      }
+    } catch {
+    }
+  }
+}
+function collectDescendants(store, className, result, visited, depth) {
+  if (depth <= 0 || visited.has(className)) return;
+  visited.add(className);
+  const implementors = store.findImplementors(className);
+  for (const impl of implementors) {
+    if (result.has(impl.id)) continue;
+    result.add(impl.id);
+    collectDescendants(store, impl.name, result, visited, depth - 1);
+  }
+}
+function findMethodOnClass(store, classId, methodName) {
+  const children = store.getSymbolChildren(classId);
+  return children.find(
+    (s) => s.name === methodName && (s.kind === "method" || s.kind === "function")
+  ) ?? null;
+}
+
 // src/tools/analysis/impact.ts
 function getModule(filePath, depth = 2) {
   const parts = filePath.split("/");
@@ -93422,8 +93674,13 @@ function getChangeImpact(store, opts, depth = 3, maxDependents = 200, cwd) {
       const sym = store.getSymbolBySymbolId(sid);
       if (!sym) continue;
       if (!firstSym) firstSym = sym;
-      const nid = store.getNodeId("symbol", sym.id);
-      if (nid != null) startNodeIds.push(nid);
+      const chaNodeIds = getChaNodeIds(store, sym);
+      if (chaNodeIds.length > 0) {
+        startNodeIds.push(...chaNodeIds);
+      } else {
+        const nid = store.getNodeId("symbol", sym.id);
+        if (nid != null) startNodeIds.push(nid);
+      }
     }
     if (!firstSym) {
       return err(notFound(opts.symbolIds[0]));
@@ -93440,8 +93697,14 @@ function getChangeImpact(store, opts, depth = 3, maxDependents = 200, cwd) {
       return err(notFound(opts.symbolId ?? opts.fqn ?? "unknown"));
     }
     const sym = resolved.symbol;
-    const nodeId = store.getNodeId("symbol", sym.id);
-    if (nodeId != null) startNodeIds.push(nodeId);
+    const chaNodeIds = getChaNodeIds(store, sym);
+    if (chaNodeIds.length > 0) {
+      startNodeIds.push(...chaNodeIds);
+    } else {
+      const nodeId = store.getNodeId("symbol", sym.id);
+      if (nodeId != null) startNodeIds.push(nodeId);
+    }
+    startNodeIds = [...new Set(startNodeIds)];
     targetPath = resolved.file.path;
     targetSymbolId = sym.symbol_id;
     targetSymbolName = sym.name;
@@ -98470,8 +98733,41 @@ function findReferences(store, opts) {
   if (nodeId === void 0) {
     return ok65({ target: targetMeta, references: [], total: 0 });
   }
-  const incomingEdges = store.getIncomingEdges(nodeId);
-  const sourceNodeIds = incomingEdges.map((e) => e.source_node_id);
+  let chaExpansion;
+  let allTargetNodeIds = [nodeId];
+  if (opts.symbolId || opts.fqn) {
+    const resolved = resolveSymbolInput(store, opts);
+    if (resolved) {
+      const chaMatches = expandMethodViaCha(store, resolved.symbol);
+      if (chaMatches.length > 1) {
+        allTargetNodeIds = chaMatches.map((m) => m.nodeId);
+        chaExpansion = chaMatches.filter((m) => m.relation !== "self").map((m) => ({
+          symbol_id: m.symbol.symbol_id,
+          name: m.symbol.name,
+          relation: m.relation
+        }));
+      }
+    }
+  }
+  const allIncomingEdges = [];
+  const seenEdgeKeys = /* @__PURE__ */ new Set();
+  for (const targetNid of allTargetNodeIds) {
+    const edges = store.getIncomingEdges(targetNid);
+    const isChaTarget = targetNid !== nodeId;
+    for (const edge of edges) {
+      const key = `${edge.source_node_id}:${edge.target_node_id}:${edge.edge_type_id}`;
+      if (seenEdgeKeys.has(key)) continue;
+      seenEdgeKeys.add(key);
+      allIncomingEdges.push({
+        edge,
+        via_cha: isChaTarget ? chaExpansion?.find((c) => {
+          const ref = store.getNodeRef(targetNid);
+          return ref && ref.nodeType === "symbol" ? store.getSymbolById(ref.refId)?.symbol_id === c.symbol_id : false;
+        })?.name : void 0
+      });
+    }
+  }
+  const sourceNodeIds = allIncomingEdges.map((e) => e.edge.source_node_id);
   const nodeRefs = store.getNodeRefsBatch(sourceNodeIds);
   const symbolRefIds = [];
   const fileRefIds = [];
@@ -98485,7 +98781,7 @@ function findReferences(store, opts) {
   const allFileIds = [.../* @__PURE__ */ new Set([...fileRefIds, ...symFileIds])];
   const fileMap = allFileIds.length > 0 ? store.getFilesByIds(allFileIds) : /* @__PURE__ */ new Map();
   const references = [];
-  for (const edge of incomingEdges) {
+  for (const { edge, via_cha } of allIncomingEdges) {
     const sourceRef = nodeRefs.get(edge.source_node_id);
     if (!sourceRef) continue;
     let symbol = null;
@@ -98507,13 +98803,17 @@ function findReferences(store, opts) {
     } else {
       filePath = `[${sourceRef.nodeType}:${sourceRef.refId}]`;
     }
-    references.push({
+    const ref = {
       edge_type: edge.edge_type_name,
       symbol,
       file: filePath
-    });
+    };
+    if (via_cha) ref.via_cha = via_cha;
+    references.push(ref);
   }
-  return ok65({ target: targetMeta, references, total: references.length });
+  const result = { target: targetMeta, references, total: references.length };
+  if (chaExpansion && chaExpansion.length > 0) result.cha_expansion = chaExpansion;
+  return ok65(result);
 }
 
 // src/tools/framework/call-graph.ts
@@ -98559,9 +98859,19 @@ function getCallGraph(store, opts, depth = 2) {
       resolution_tiers: { lsp_resolved: 0, ast_resolved: 0, ast_inferred: 0, text_matched: 0 }
     });
   }
+  const chaMatches = expandMethodViaCha(store, symbol);
+  const chaAliasNodeIds = chaMatches.filter((m) => m.relation !== "self").map((m) => m.nodeId);
   const edgeTypesUsed = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  const { node: rootNode, tiers } = buildCallNode(store, symbol.id, nodeId, depth, visited, edgeTypesUsed);
+  const { node: rootNode, tiers } = buildCallNode(
+    store,
+    symbol.id,
+    nodeId,
+    depth,
+    visited,
+    edgeTypesUsed,
+    chaAliasNodeIds
+  );
   return ok66({
     root: rootNode,
     edge_types_used: [...edgeTypesUsed],
@@ -98569,12 +98879,14 @@ function getCallGraph(store, opts, depth = 2) {
     resolution_tiers: tiers
   });
 }
-function buildCallNode(store, rootSymbolId, rootNodeId, maxDepth, _visited, edgeTypesUsed) {
+function buildCallNode(store, rootSymbolId, rootNodeId, maxDepth, _visited, edgeTypesUsed, chaAliasNodeIds = []) {
   const tiers = { lsp_resolved: 0, ast_resolved: 0, ast_inferred: 0, text_matched: 0 };
   const nodeInfoMap = /* @__PURE__ */ new Map();
   const visited = /* @__PURE__ */ new Set();
-  let frontier = [rootNodeId];
+  const chaAliasSet = new Set(chaAliasNodeIds);
+  let frontier = [rootNodeId, ...chaAliasNodeIds];
   visited.add(rootNodeId);
+  for (const alias of chaAliasNodeIds) visited.add(alias);
   nodeInfoMap.set(rootNodeId, { nodeId: rootNodeId, symbolRefId: rootSymbolId, outgoing: [], incoming: [] });
   for (let d = 0; d < maxDepth; d++) {
     if (frontier.length === 0) break;
@@ -98583,15 +98895,16 @@ function buildCallNode(store, rootSymbolId, rootNodeId, maxDepth, _visited, edge
     for (const edge of batchEdges) {
       if (!CALL_EDGE_TYPES2.has(edge.edge_type_name)) continue;
       edgeTypesUsed.add(edge.edge_type_name);
-      const pivotInfo = nodeInfoMap.get(edge.pivot_node_id);
+      const effectivePivot = chaAliasSet.has(edge.pivot_node_id) ? rootNodeId : edge.pivot_node_id;
+      const pivotInfo = nodeInfoMap.get(effectivePivot);
       if (!pivotInfo) continue;
       const resolution = inferResolution(edge);
       tiers[resolution]++;
-      if (edge.source_node_id === edge.pivot_node_id && !visited.has(edge.target_node_id)) {
+      if (edge.source_node_id === edge.pivot_node_id && !visited.has(edge.target_node_id) && !chaAliasSet.has(edge.target_node_id)) {
         pivotInfo.outgoing.push({ nodeId: edge.target_node_id, edgeType: edge.edge_type_name, resolution });
         newNeighbors.add(edge.target_node_id);
       }
-      if (edge.target_node_id === edge.pivot_node_id && !visited.has(edge.source_node_id)) {
+      if (edge.target_node_id === edge.pivot_node_id && !visited.has(edge.source_node_id) && !chaAliasSet.has(edge.source_node_id)) {
         pivotInfo.incoming.push({ nodeId: edge.source_node_id, edgeType: edge.edge_type_name, resolution });
         newNeighbors.add(edge.source_node_id);
       }
@@ -98884,26 +99197,31 @@ import { ok as ok68, err as err43 } from "neverthrow";
 function getTestsFor(store, opts) {
   let targetFile;
   let targetSymbolId;
-  let nodeId;
+  let symbolNodeId;
+  let fileNodeId;
   if (opts.symbolId || opts.fqn) {
     const resolved = resolveSymbolInput(store, opts);
     if (!resolved) return err43(notFound(opts.symbolId ?? opts.fqn ?? "unknown"));
     const symbol = resolved.symbol;
     targetSymbolId = symbol.symbol_id;
     targetFile = resolved.file.path;
-    nodeId = store.getNodeId("symbol", symbol.id);
+    symbolNodeId = store.getNodeId("symbol", symbol.id);
+    fileNodeId = store.getNodeId("file", resolved.file.id);
   } else if (opts.filePath) {
     const f = store.getFile(opts.filePath);
     if (!f) return err43(notFound(opts.filePath));
     targetFile = f.path;
-    nodeId = store.getNodeId("file", f.id);
+    fileNodeId = store.getNodeId("file", f.id);
   } else {
     return err43(notFound("provide symbol_id, fqn, or file_path"));
   }
   const tests = [];
   const seen = /* @__PURE__ */ new Set();
-  if (nodeId !== void 0) {
-    const incoming = store.getIncomingEdges(nodeId);
+  const nodeIdsToCheck = /* @__PURE__ */ new Set();
+  if (symbolNodeId !== void 0) nodeIdsToCheck.add(symbolNodeId);
+  if (fileNodeId !== void 0) nodeIdsToCheck.add(fileNodeId);
+  for (const nid of nodeIdsToCheck) {
+    const incoming = store.getIncomingEdges(nid);
     for (const edge of incoming) {
       if (edge.edge_type_name !== "test_covers") continue;
       const ref = store.getNodeRef(edge.source_node_id);
@@ -99459,6 +99777,55 @@ function walkDescendants(store, name, result, visited, depth) {
     walkDescendants(store, row.name, node.children, visited, depth - 1);
   }
 }
+function collectPyprojectEntryPoints(store) {
+  const names = /* @__PURE__ */ new Set();
+  const allFiles = store.getAllFiles();
+  const pyprojectFile = allFiles.find((f) => f.path.endsWith("pyproject.toml"));
+  if (!pyprojectFile) return names;
+  const symbols = store.getSymbolsByFile(pyprojectFile.id);
+  for (const sym of symbols) {
+    if (!sym.metadata) continue;
+    try {
+      const meta = typeof sym.metadata === "string" ? JSON.parse(sym.metadata) : sym.metadata;
+      const section = typeof meta.section === "string" ? meta.section : "";
+      const isScriptSection = /(?:project\.(?:scripts|gui-scripts)|console_scripts|gui_scripts)/.test(section);
+      if (!isScriptSection) continue;
+      const value = typeof meta.value === "string" ? meta.value : sym.signature ?? "";
+      const colonIdx = value.indexOf(":");
+      if (colonIdx >= 0) {
+        const funcPart = value.slice(colonIdx + 1).trim();
+        const dotIdx = funcPart.lastIndexOf(".");
+        names.add(dotIdx >= 0 ? funcPart.slice(dotIdx + 1) : funcPart);
+      }
+    } catch {
+    }
+  }
+  const setupFile = allFiles.find((f) => f.path.endsWith("setup.py") || f.path.endsWith("setup.cfg"));
+  if (setupFile) {
+    const setupSymbols = store.getSymbolsByFile(setupFile.id);
+    for (const sym of setupSymbols) {
+      if (!sym.metadata) continue;
+      try {
+        const meta = typeof sym.metadata === "string" ? JSON.parse(sym.metadata) : sym.metadata;
+        if (meta.console_scripts || meta.gui_scripts) {
+          const scripts = meta.console_scripts ?? meta.gui_scripts;
+          if (Array.isArray(scripts)) {
+            for (const entry of scripts) {
+              const colonIdx = entry.indexOf(":");
+              if (colonIdx >= 0) {
+                const funcPart = entry.slice(colonIdx + 1).trim();
+                const dotIdx = funcPart.lastIndexOf(".");
+                names.add(dotIdx >= 0 ? funcPart.slice(dotIdx + 1) : funcPart);
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return names;
+}
 function getDeadExports(store, filePattern) {
   const exported = store.getExportedSymbols(filePattern).filter((s) => !TEST_FIXTURE_RE.test(s.file_path)).filter((s) => !TEST_FILE_RE.test(s.file_path));
   const importedNames = /* @__PURE__ */ new Set();
@@ -99478,9 +99845,18 @@ function getDeadExports(store, filePattern) {
       }
     }
   }
+  const pyprojectEntryNames = collectPyprojectEntryPoints(store);
   const dead = [];
   for (const sym of exported) {
     if (sym.kind === "method") continue;
+    if (sym.metadata) {
+      try {
+        const meta = typeof sym.metadata === "string" ? JSON.parse(sym.metadata) : sym.metadata;
+        if (meta.is_entry_point) continue;
+      } catch {
+      }
+    }
+    if (pyprojectEntryNames.has(sym.name)) continue;
     if (!importedNames.has(sym.name)) {
       dead.push({
         symbol_id: sym.symbol_id,
@@ -119137,7 +119513,7 @@ var DecisionStore = class {
 };
 
 // src/server/server.ts
-var PKG_VERSION = true ? "1.19.0" : "0.0.0-dev";
+var PKG_VERSION = true ? "1.20.0" : "0.0.0-dev";
 function j2(value) {
   return JSON.stringify(value, (_key, val) => val === null || val === void 0 ? void 0 : val);
 }
@@ -124980,7 +125356,7 @@ var ProjectManager = class {
 
 // src/cli.ts
 init_global();
-var PKG_VERSION2 = true ? "1.19.0" : "0.0.0-dev";
+var PKG_VERSION2 = true ? "1.20.0" : "0.0.0-dev";
 function registerDefaultPlugins2(registry) {
   for (const p5 of createAllLanguagePlugins()) registry.registerLanguagePlugin(p5);
   for (const p5 of createAllIntegrationPlugins()) registry.registerFrameworkPlugin(p5);