entrygraph 0.1.28__tar.gz → 0.1.30__tar.gz

{entrygraph-0.1.28 → entrygraph-0.1.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entrygraph
-Version: 0.1.28
+Version: 0.1.30
 Summary: Language-agnostic code graph: query symbols, entrypoints, and source-to-sink call paths from a SQLite index
 Project-URL: Repository, https://github.com/brettbergin/entrygraph
 Author-email: Brett Bergin <brettberginbc@yahoo.com>

{entrygraph-0.1.28 → entrygraph-0.1.30}/src/entrygraph/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.28'
-__version_tuple__ = version_tuple = (0, 1, 28)
+__version__ = version = '0.1.30'
+__version_tuple__ = version_tuple = (0, 1, 30)
 
 __commit_id__ = commit_id = None

{entrygraph-0.1.28 → entrygraph-0.1.30}/src/entrygraph/cli/main.py

@@ -264,6 +264,11 @@ def _path_tree(index: int, path) -> Tree:
 def cmd_paths(args) -> int:
     if not args.source and not args.source_category:
         raise EntrygraphError("provide --source and/or --source-category")
+    # A missing sink would leave the sink set empty and print "no paths found",
+    # which reads like a clean result — require an explicit sink so an incomplete
+    # query can't be mistaken for "no reachable sinks".
+    if not args.sink and not args.sink_category:
+        raise EntrygraphError("provide --sink and/or --sink-category")
     with _open(args) as graph:
         paths = graph.paths(
             source=args.source,

{entrygraph-0.1.28 → entrygraph-0.1.30}/src/entrygraph/pipeline/scanner.py

@@ -491,13 +491,23 @@ def _write_symbols(session, extractions, file_id_by_path, alloc, table):
                     "is_exported": raw.is_exported,
                 }
             )
+    # file id -> that file's module symbol id, so a top-level symbol is parented to
+    # ITS OWN module. When several files share a package/module_path (every
+    # multi-file Go package), `module_symbol_ids` keeps only the last file's module
+    # id; parenting siblings to it means wiping one file cascade-deletes the others'
+    # symbols (parent_id FK is ondelete=CASCADE). This was the incremental-reindex
+    # data loss in #41 (F-H11).
+    module_id_by_file_id = {file_id_by_path[p]: mid for p, mid in module_ids.items()}
     for row in symbol_rows:
         qname = row["qname"]
         if row["kind"] is not SymbolKind.MODULE and "." in qname:
             parent_q = qname.rsplit(".", 1)[0]
-            row["parent_id"] = symbol_id_by_qname.get(parent_q) or table.module_symbol_ids.get(
-                parent_q
-            )
+            parent = symbol_id_by_qname.get(parent_q)
+            if parent is None:  # parent is the module itself, not a project symbol
+                parent = module_id_by_file_id.get(row["file_id"]) or table.module_symbol_ids.get(
+                    parent_q
+                )
+            row["parent_id"] = parent
     # A row's parent has one fewer qname segment, so inserting shallowest-first
     # guarantees the self-referential parent_id FK is satisfied within the batch.
     symbol_rows.sort(key=lambda r: r["qname"].count("."))
@@ -535,7 +545,13 @@ def _write_edges_and_entrypoints(
 
     for path, x, is_package in extractions:
         resolver = FileResolver(
-            x, module_ids[path], table, externals, is_package, sink_registry=sink_registry
+            x,
+            module_ids[path],
+            table,
+            externals,
+            is_package,
+            sink_registry=sink_registry,
+            local_symbol_ids=handler_ids_by_path.get(path, {}),
         )
         file_id = file_id_by_path[path]
         for edge in resolver.resolve():

{entrygraph-0.1.28 → entrygraph-0.1.30}/src/entrygraph/resolve/resolver.py

@@ -71,6 +71,7 @@ class FileResolver:
         externals: ExternalRegistry,
         is_package: bool = False,
         sink_registry: SinkRegistry | None = None,
+        local_symbol_ids: dict[str, int] | None = None,
     ) -> None:
         self.x = extraction
         self.module_symbol_id = module_symbol_id
@@ -78,6 +79,11 @@ class FileResolver:
         self.externals = externals
         self.is_package = is_package
         self.sink_registry = sink_registry
+        # This file's own qname -> id. The caller of every reference lives in this
+        # file, so an edge's source must resolve here first — resolving it through
+        # the global (last-wins) table would attribute a.go's edge to a same-named
+        # symbol in b.go, and wiping b.go would then cascade-delete a.go's edge.
+        self.local_symbol_ids = local_symbol_ids or {}
         self.prefix = LANG_PREFIX.get(extraction.language, extraction.language)
         self.import_map, self.wildcard_modules = build_import_map(extraction, is_package)
 
@@ -166,7 +172,10 @@ class FileResolver:
         return edges
 
     def _resolve_reference(self, ref: RawReference) -> ResolvedEdge | None:
-        src_id = self.table.by_fqn.get(ref.caller_qualified_name or "", self.module_symbol_id)
+        caller_q = ref.caller_qualified_name or ""
+        src_id = self.local_symbol_ids.get(caller_q) or self.table.by_fqn.get(
+            caller_q, self.module_symbol_id
+        )
         kind = _REF_EDGE_KIND.get(ref.kind, EdgeKind.REFERENCES)
 
         if ref.kind == "callback":

{entrygraph-0.1.28 → entrygraph-0.1.30}/tests/test_cli.py

@@ -62,6 +62,20 @@ def test_paths_exit_codes(db, capsys):
     assert rc == 1
 
 
+def test_paths_requires_a_sink(db, capsys):
+    # A query with a source but no sink would silently print "no paths found",
+    # which reads like a clean result — it must error instead.
+    rc = main(["paths", "--db", db, "--source", "*"])
+    assert rc == 2
+    assert "provide --sink" in capsys.readouterr().err
+
+
+def test_paths_requires_a_source(db, capsys):
+    rc = main(["paths", "--db", db, "--sink-category", "command_exec"])
+    assert rc == 2
+    assert "provide --source" in capsys.readouterr().err
+
+
 def test_paths_by_category(db, capsys):
     rc = main(
         [

{entrygraph-0.1.28 → entrygraph-0.1.30}/tests/test_incremental.py

@@ -215,3 +215,34 @@ def test_parallel_matches_sequential(repo, tmp_path):
         scanner._PARALLEL_THRESHOLD = original
     seq.dispose()
     par.dispose()
+
+
+def test_reindex_shared_package_file_matches_full(tmp_path):
+    # Two files in the same Go package share a module_path and both define
+    # `func init()`. Re-indexing one file must not cascade-delete the other file's
+    # symbols/edges (parent_id and edge.src_symbol_id FKs are ondelete=CASCADE, and
+    # both were bound to the last-written colliding symbol). Regression for #41 F-H11.
+    repo = tmp_path / "gomod"
+    (repo / "middleware").mkdir(parents=True)
+    (repo / "middleware" / "a.go").write_text(
+        'package middleware\nimport "fmt"\nfunc init() { doThing() }\n'
+        'func doThing() { fmt.Println("a") }\n'
+    )
+    terminal = repo / "middleware" / "terminal.go"
+    terminal.write_text(
+        'package middleware\nimport "fmt"\nfunc init() { other() }\n'
+        'func other() { fmt.Println("b") }\n'
+    )
+    engine = make_engine(tmp_path / "inc.db")
+    index_repository(repo, engine)
+
+    terminal.write_text(terminal.read_text() + "\n// touch\n")
+    stats = index_repository(repo, engine, incremental=True)
+    assert stats.files_indexed == 1  # only terminal.go reparsed
+    incremental = _graph_snapshot(engine)
+    engine.dispose()
+
+    assert incremental == _full_reindex_snapshot(repo, tmp_path)
+    # the sibling file's symbols/edges survive the re-index
+    syms = {q for q, _ in incremental[0]}
+    assert {"middleware.doThing", "middleware.other"} <= syms