graphlint 0.3.2__tar.gz → 0.3.4__tar.gz

{graphlint-0.3.2 → graphlint-0.3.4}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.3.4] - 2026-07-27
+
+### Changed
+- Incremental entry detection: entry point results are now persisted to DB
+  and only re-scanned for changed files in incremental builds, reducing
+  redundant computation when most files are unchanged
+
+## [0.3.3] - 2026-07-25
+
+### Changed
+- Pre-built entry indexes (`nid_to_entries`, `fid_to_entries`) for O(1)
+  per-component entry matching, eliminating repeated linear scans in
+  `_match_entries` during connected component analysis
+- Connected component BFS now collects reachable node seeds in a single
+  traversal pass instead of a post-hoc set comprehension
+- Dead-code component merge loop replaced with BFS-based group merging,
+  eliminating repeated list scans and improving large-codebase performance
+
 ## [0.3.2] - 2026-07-25
 
 ### Changed

{graphlint-0.3.2/graphlint.egg-info → graphlint-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphlint
-Version: 0.3.2
+Version: 0.3.4
 Summary: A static analysis tool for identifying dead code in a codebase. It provides Python API and CLI for use by agents.
 Author-email: Yutong Zou <yutong.zou.24@alumni.ucl.ac.uk>
 License-Expression: MIT

{graphlint-0.3.2 → graphlint-0.3.4}/graphlint/__init__.py

@@ -3,7 +3,7 @@
 
 from typing import Any
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"
 
 __all__ = ["query", "build", "configure", "__version__"]
 

{graphlint-0.3.2 → graphlint-0.3.4}/graphlint/analyzer/_graph_algo.py

@@ -258,6 +258,17 @@ def find_connected_components(
             elif _e.target_id == 0 and _e.source_id:
                 _zero_sources.add(_e.source_id)
 
+    # Pre-build entry indexes for O(1) per-component matching
+    _nid_to_entries: dict[int, list[EntryInfo]] = {}
+    _fid_to_entries: dict[int, list[EntryInfo]] = {}
+    for entry in entries:
+        if entry.node_id:
+            _nid_to_entries.setdefault(entry.node_id, []).append(entry)
+        elif file_id_map:
+            fid = file_id_map.get(entry.file_path, 0)
+            if fid:
+                _fid_to_entries.setdefault(fid, []).append(entry)
+
     visited: set[int] = set()
     component_map: dict[int, int] = {}
     components: list[ComponentInfo] = []
@@ -268,9 +279,13 @@ def find_connected_components(
         if nid in visited:
             continue
 
+        # discover component nodes and initial reachable seeds
         queue: deque[int] = deque([nid])
         visited.add(nid)
         comp_nodes: set[int] = {nid}
+        comp_reachable: set[int] = set()
+        if nid in reachable:
+            comp_reachable.add(nid)
 
         while queue:
             current = queue.popleft()
@@ -279,15 +294,19 @@ def find_connected_components(
                     visited.add(neighbor)
                     queue.append(neighbor)
                     comp_nodes.add(neighbor)
+                    if neighbor in reachable:
+                        comp_reachable.add(neighbor)
 
-        comp_entries = _match_entries(entries, comp_nodes, node_id_map, file_id_map)
+        comp_entries = _match_entries(
+            entries, comp_nodes, node_id_map, file_id_map,
+            nid_to_entries=_nid_to_entries, fid_to_entries=_fid_to_entries,
+        )
         has_entry = len(comp_entries) > 0
-        comp_nodes.discard(0)  # Exclude module root pseudo-node
-        comp_reachable = {nid for nid in comp_nodes if nid in reachable}
+        comp_nodes.discard(0)
+        comp_reachable.discard(0)
         comp_unreachable = comp_nodes - comp_reachable
 
-        # BFS expansion from reachable seed set via undirected edges.
-        # Node 0 (module pseudo-node): only expand via read/call edges.
+        # BFS expansion from reachable seeds via undirected edges
         seed = comp_reachable
         if noprop_ids:
             seed = seed - noprop_ids
@@ -296,13 +315,13 @@ def find_connected_components(
             cur = q.popleft()
             if cur == 0:
                 continue
-            for nid in adj.get(cur, set()):
-                if nid == 0 or nid in comp_reachable:
+            for nb in adj.get(cur, set()):
+                if nb == 0 or nb in comp_reachable:
                     continue
-                if nid in comp_unreachable:
-                    comp_reachable.add(nid)
-                    comp_unreachable.discard(nid)
-                    q.append(nid)
+                if nb in comp_unreachable:
+                    comp_reachable.add(nb)
+                    comp_unreachable.discard(nb)
+                    q.append(nb)
             if cur in class_special_map:
                 for sm_nid in class_special_map[cur]:
                     if sm_nid in comp_unreachable:
@@ -370,51 +389,52 @@ def find_connected_components(
             component_map.update(sub_map)
             components.extend(sub_comps)
 
-    # Post-process: merge dead code sub-components into live components.
-    x_edges: dict[int, set[int]] = {}
+    # Post-process: merge dead components into live ones via inherit/decorate edges.
+    comp_adj: dict[int, set[int]] = {}
     for e in edges:
         if e.edge_type not in ("inherit", "decorate"):
             continue
         cs = component_map.get(e.source_id)
         ct = component_map.get(e.target_id)
         if cs is not None and ct is not None and cs != ct:
-            x_edges.setdefault(cs, set()).add(ct)
-            x_edges.setdefault(ct, set()).add(cs)
+            comp_adj.setdefault(cs, set()).add(ct)
+            comp_adj.setdefault(ct, set()).add(cs)
 
     comp_by_id: dict[int, ComponentInfo] = {c.component_id: c for c in components}
+    live_comp_ids: set[int] = {c.component_id for c in components if not c.is_dead_code}
 
-    changed = True
-    while changed:
-        changed = False
-        for comp in list(components):
-            if not comp.is_dead_code:
-                continue
-            neighbors = x_edges.get(comp.component_id, set())
-            if not neighbors:
-                continue
-            # Find all adjacent live components
-            live_nbrs = []
-            for nbr in neighbors:
-                nbr_comp = comp_by_id.get(nbr)
-                if nbr_comp and not nbr_comp.is_dead_code:
-                    live_nbrs.append(nbr_comp)
-            if not live_nbrs:
+    # each connected group containing a live
+    # component merges all its dead members into the largest live one.
+    comp_visited: set[int] = set()
+    for live_cid in sorted(live_comp_ids):
+        if live_cid in comp_visited:
+            continue
+        group: set[int] = {live_cid}
+        comp_visited.add(live_cid)
+        q_comp: deque[int] = deque([live_cid])
+        while q_comp:
+            cur_cid = q_comp.popleft()
+            for nb_cid in comp_adj.get(cur_cid, set()):
+                if nb_cid not in comp_visited:
+                    comp_visited.add(nb_cid)
+                    q_comp.append(nb_cid)
+                    group.add(nb_cid)
+
+        group_live = group & live_comp_ids
+        group_dead = group - group_live
+        if not group_dead:
+            continue
+
+        target_cid = max(group_live, key=lambda cid: len(comp_by_id[cid].node_ids))
+        target_comp = comp_by_id[target_cid]
+        for dead_cid in group_dead:
+            dead_comp = comp_by_id.pop(dead_cid, None)
+            if dead_comp is None:
                 continue
-            target = max(live_nbrs, key=lambda c: len(c.node_ids))
-            target.node_ids.update(comp.node_ids)
-            for nid in list(comp.node_ids):
-                component_map[nid] = target.component_id
-            for other in list(neighbors):
-                if other == target.component_id:
-                    continue
-                x_edges.setdefault(other, set()).discard(comp.component_id)
-                x_edges.setdefault(other, set()).add(target.component_id)
-                x_edges.setdefault(target.component_id, set()).add(other)
-            x_edges.pop(comp.component_id, None)
-            comp_by_id.pop(comp.component_id, None)
-            components.remove(comp)
-            changed = True
-            break
+            target_comp.node_ids.update(dead_comp.node_ids)
+            for _nid in dead_comp.node_ids:
+                component_map[_nid] = target_cid
+            components.remove(dead_comp)
 
     return component_map, components
 
@@ -512,11 +532,28 @@ def _match_entries(
     comp_nodes: set[int],
     node_id_map: dict[int, NodeInfo],
     file_id_map: Optional[dict[str, int]] = None,
+    nid_to_entries: Optional[dict[int, list[EntryInfo]]] = None,
+    fid_to_entries: Optional[dict[int, list[EntryInfo]]] = None,
 ) -> list[EntryInfo]:
-    """Match entry points to connected components."""
+    """Match entry points to connected components.
+    """
+    matched: list[EntryInfo] = []
+
+    if nid_to_entries is not None and fid_to_entries is not None:
+        comp_file_ids: set[int] = set()
+        for nid in comp_nodes:
+            for entry in nid_to_entries.get(nid, []):
+                matched.append(entry)
+            enode = node_id_map.get(nid)
+            if enode:
+                comp_file_ids.add(enode.file_id)
+        for fid in comp_file_ids:
+            for entry in fid_to_entries.get(fid, []):
+                matched.append(entry)
+        return matched
+
     if file_id_map is None:
         file_id_map = {}
-    matched: list[EntryInfo] = []
     for entry in entries:
         if entry.node_id in comp_nodes:
             matched.append(entry)

{graphlint-0.3.2 → graphlint-0.3.4}/graphlint/analyzer/graph.py

@@ -259,6 +259,7 @@ class GraphBuilder:
         parse_results: dict[str, ParseResult],
         changed_files: Optional[set[str]] = None,
         prebuilt_edges: Optional[list[EdgeInfo]] = None,
+        prebuilt_entries: Optional[list[EntryInfo]] = None,
         old_changed_node_ids: dict[int, tuple[str, str]] | None = None,
     ) -> GraphBuildResult:
         """Build the complete dependency graph from parse results.
@@ -267,6 +268,9 @@ class GraphBuilder:
             old_changed_node_ids: Maps old global node ID → (qualified_name, file_path)
                 for nodes in changed files. Used to remap parent_node_id when a
                 child in an unchanged file references a parent in a changed file.
+            prebuilt_entries: Pre-loaded EntryInfo from DB for unchanged files
+                (incremental mode). When provided, entry detection only scans
+                changed files and merges these prebuilt entries.
         """
         fid_map: dict[str, int] = {}
         fid_cnt = 1
@@ -332,15 +336,30 @@ class GraphBuilder:
             if fid and fid in file_nodes_by_fid:
                 fnodes_map[fp] = {n.qualified_name: n.id for n in file_nodes_by_fid[fid]}
 
-        # Detect entries via language adapters
+        # Detect entries via language adapters.
+        # In incremental mode, only scan changed files and merge prebuilt
+        # entries loaded from DB for unchanged files.
         entries: list[EntryInfo] = []
-        if self.registry:
-            for adapter in self.registry.all_adapters():
-                entries.extend(
-                    adapter.detect_entries(
-                        parse_results, self._nodes, self._node_id_map, self.config
+        if prebuilt_entries is not None and changed_files and len(changed_files) < len(parse_results):
+            changed_pr = {
+                fp: pr for fp, pr in parse_results.items() if fp in changed_files
+            }
+            if self.registry:
+                for adapter in self.registry.all_adapters():
+                    entries.extend(
+                        adapter.detect_entries(
+                            changed_pr, self._nodes, self._node_id_map, self.config
+                        )
+                    )
+            entries.extend(prebuilt_entries)
+        else:
+            if self.registry:
+                for adapter in self.registry.all_adapters():
+                    entries.extend(
+                        adapter.detect_entries(
+                            parse_results, self._nodes, self._node_id_map, self.config
+                        )
                     )
-                )
         for e in entries:
             if e.node_id and e.node_id in self._node_id_map:
                 self._node_id_map[e.node_id].is_entry = True

{graphlint-0.3.2 → graphlint-0.3.4}/graphlint/incremental/_db_ops.py

@@ -9,7 +9,7 @@ import json
 import os
 from typing import Any, Optional
 
-from graphlint.analyzer._types import EdgeInfo, NodeInfo, GraphBuildResult
+from graphlint.analyzer._types import EdgeInfo, EntryInfo, NodeInfo, GraphBuildResult
 from graphlint.storage.db import Database
 from graphlint.storage.hashing import compute_file_hash, is_test_file
 
@@ -96,13 +96,14 @@ def update_db(
         else:
             # Full build: unconditionally clear all data tables (keep files table)
             # files table is updated by subsequent _upsert_files INSERT OR REPLACE
-            for tbl in ("edges", "nodes", "imports", "warnings", "graph_snapshots"):
+            for tbl in ("edges", "nodes", "imports", "warnings", "graph_snapshots", "entries"):
                 db.execute(f"DELETE FROM {tbl}")
         _upsert_files(db, build_result, root_dir, test_patterns, changed)
         fid_map = _load_fid_map(db)
         _insert_nodes(db, build_result, fid_map, changed_files=changed_set)
         _do_insert_edges(db, build_result, fid_map, changed_files=changed_set)
         _insert_warnings(db, build_result, fid_map, changed_files=changed_set)
+        _insert_entries(db, build_result, fid_map, changed_files=changed_set)
         if incremental:
             update_snapshots(db, build_result)
         else:
@@ -115,7 +116,7 @@ def _delete_old(db: Database, removed: list[str], changed: list[str]) -> None:
         if not paths:
             continue
         ph = ",".join("?" for _ in paths)
-        for tbl in ("edges", "nodes", "imports", "warnings"):
+        for tbl in ("edges", "nodes", "imports", "warnings", "entries"):
             db.execute(
                 f"DELETE FROM {tbl} WHERE file_id IN "
                 f"(SELECT id FROM files WHERE path IN ({ph}))",
@@ -302,6 +303,77 @@ def _insert_warnings(
         )
 
 
+def _insert_entries(
+    db: Database,
+    build_result: GraphBuildResult,
+    fid_map: dict[str, int],
+    changed_files: Optional[set[str]] = None,
+) -> None:
+    """Insert entry point detection results."""
+    batch: list[tuple[Any, ...]] = []
+    for entry in build_result.entry_info_list:
+        fp = entry.file_path
+        if changed_files is not None and fp not in changed_files:
+            continue
+        fid = fid_map.get(fp, 0)
+        if not fid:
+            continue
+        batch.append(
+            (
+                fid,
+                entry.node_id or 0,
+                entry.rule_name,
+                entry.line,
+                entry.description or "",
+                1 if entry.no_propagate else 0,
+            )
+        )
+        if len(batch) >= 5000:
+            db.executemany(
+                "INSERT INTO entries (file_id, node_id, rule_name, "
+                "line, description, no_propagate) VALUES (?,?,?,?,?,?)",
+                batch,
+            )
+            batch.clear()
+    if batch:
+        db.executemany(
+            "INSERT INTO entries (file_id, node_id, rule_name, "
+            "line, description, no_propagate) VALUES (?,?,?,?,?,?)",
+            batch,
+        )
+
+
+def load_unchanged_entries(
+    db: Database,
+    unchanged_files: set[str],
+) -> list[EntryInfo]:
+    """Load entry points for unchanged files from DB (incremental build)."""
+    if not unchanged_files:
+        return []
+    ph = ",".join("?" for _ in unchanged_files)
+    rows = db.fetchall(
+        f"SELECT e.*, f.path FROM entries e "
+        f"JOIN files f ON e.file_id = f.id "
+        f"WHERE f.path IN ({ph})",
+        tuple(unchanged_files),
+    )
+    entries: list[EntryInfo] = []
+    for r in rows:
+        file_path = r["path"]
+        node_id = r["node_id"] or 0
+        entries.append(
+            EntryInfo(
+                rule_name=r["rule_name"],
+                file_path=file_path,
+                line=r["line"],
+                node_id=node_id,
+                description=r["description"] or "",
+                no_propagate=bool(r["no_propagate"]),
+            )
+        )
+    return entries
+
+
 def _precompute_edge_counts(
     component_map: dict[int, int],
     edges: list[EdgeInfo],

{graphlint-0.3.2 → graphlint-0.3.4}/graphlint/incremental/indexer.py

@@ -20,6 +20,7 @@ from graphlint.incremental._db_ops import (
     build_snapshots,
     load_old_changed_node_ids,
     load_prebuilt_edges,
+    load_unchanged_entries,
     persist_unchanged_parent_node_ids,
     update_db,
     update_snapshots,
@@ -140,7 +141,7 @@ class IncrementalIndexer:
 
         if needs_full:
             with self.db.transaction():
-                for t in ("edges", "nodes", "imports", "warnings", "graph_snapshots", "files"):
+                for t in ("edges", "nodes", "imports", "warnings", "graph_snapshots", "entries", "files"):
                     self.db.execute(f"DELETE FROM {t}")
             all_results = self._parse_batch(disk_files)
             for fp, pr in all_results:
@@ -186,11 +187,15 @@ class IncrementalIndexer:
                     prebuilt = load_prebuilt_edges(self.db, unchanged, sql_to_mem)
 
             # ------ Phase 4: Rebuild graph (upstream + downstream + analysis) --
+            prebuilt_entries: Optional[list[Any]] = None
+            if unchanged:
+                prebuilt_entries = load_unchanged_entries(self.db, unchanged)
             builder = self._create_builder(wc)
             br = builder.build(
                 pr_map,
                 changed_files=set(changed),
                 prebuilt_edges=prebuilt,
+                prebuilt_entries=prebuilt_entries,
                 old_changed_node_ids=old_ids if old_ids else None,
             )
 

{graphlint-0.3.2 → graphlint-0.3.4}/graphlint/storage/schema.py

@@ -117,6 +117,19 @@ CREATE TABLE IF NOT EXISTS graph_snapshots (
 
 CREATE INDEX IF NOT EXISTS idx_snapshots_time ON graph_snapshots(snapshot_time);
 
+-- Entry points: persisted detection results for incremental rebuild reuse
+CREATE TABLE IF NOT EXISTS entries (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_id         INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    node_id         INTEGER DEFAULT 0,
+    rule_name       TEXT NOT NULL,
+    line            INTEGER NOT NULL DEFAULT 0,
+    description     TEXT NOT NULL DEFAULT '',
+    no_propagate    INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE INDEX IF NOT EXISTS idx_entries_file ON entries(file_id);
+
 -- Component members: maps node_id to component_id for incremental connectivity analysis
 CREATE TABLE IF NOT EXISTS component_members (
     component_id    INTEGER NOT NULL,

{graphlint-0.3.2 → graphlint-0.3.4/graphlint.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphlint
-Version: 0.3.2
+Version: 0.3.4
 Summary: A static analysis tool for identifying dead code in a codebase. It provides Python API and CLI for use by agents.
 Author-email: Yutong Zou <yutong.zou.24@alumni.ucl.ac.uk>
 License-Expression: MIT

{graphlint-0.3.2 → graphlint-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphlint"
-version = "0.3.2"
+version = "0.3.4"
 description = "A static analysis tool for identifying dead code in a codebase. It provides Python API and CLI for use by agents."
 readme = "README_PYPI.md"
 license = "MIT"