codespine 0.8.0__tar.gz → 0.9.0__tar.gz

{codespine-0.8.0 → codespine-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.8.0
+Version: 0.9.0
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License

{codespine-0.8.0 → codespine-0.9.0}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.8.0"
+__version__ = "0.9.0"

{codespine-0.8.0 → codespine-0.9.0}/codespine/analysis/impact.py

@@ -115,6 +115,41 @@ def analyze_impact(store, symbol_query: str, max_depth: int = 4, project: str |
             """
         )
 
+    # Augment with DI injection edges: for each target method's class, find all
+    # classes that @Inject it (or bind it via @Component/@Service) and add their
+    # methods as implicit callers at depth+1 with edge_type "DI_INJECT".
+    try:
+        di_edges = store.query_records(
+            """
+            MATCH (a:Method), (ca:Class), (b:Method), (cb:Class),
+                  (ca)-[r:INJECTS]->(cb)
+            WHERE a.class_id = ca.id AND b.class_id = cb.id
+            RETURN a.id as src, b.id as dst, 'DI_INJECT' as edge_type,
+                   coalesce(r.confidence, 0.8) as confidence,
+                   coalesce(r.binding_type, 'field_inject') as reason
+            """
+        )
+        edges = list(edges) + di_edges
+    except Exception:
+        pass  # INJECTS table may not exist on old DBs
+
+    # Also follow BINDS_INTERFACE — any class implementing the target's interface
+    # counts as an indirect caller.
+    try:
+        bi_edges = store.query_records(
+            """
+            MATCH (a:Method), (ca:Class), (b:Method), (cb:Class),
+                  (ca)-[r:BINDS_INTERFACE]->(cb)
+            WHERE a.class_id = ca.id AND b.class_id = cb.id
+            RETURN a.id as src, b.id as dst, 'INTERFACE_BINDING' as edge_type,
+                   coalesce(r.confidence, 0.9) as confidence,
+                   coalesce(r.reason, 'implements') as reason
+            """
+        )
+        edges = list(edges) + bi_edges
+    except Exception:
+        pass
+
     reverse_adj: dict[str, list[dict]] = defaultdict(list)
     for edge in edges:
         reverse_adj[edge["dst"]].append(edge)
@@ -184,13 +219,31 @@ def analyze_impact(store, symbol_query: str, max_depth: int = 4, project: str |
         for mid in target_method_ids
     ]
 
+    # FR-06: Separate "self_callers" (same class as target, depth=1) from
+    # impacted_callers so the output is unambiguous.
+    target_class_fqcns = {
+        target_meta.get(mid, {}).get("class_fqcn")
+        for mid in target_method_ids
+        if target_meta.get(mid, {}).get("class_fqcn")
+    }
+    self_callers: list[dict] = []
+    impacted_depth1: list[dict] = []
+    for item in depth_groups["1"]:
+        if item.get("class_fqcn") and item["class_fqcn"] in target_class_fqcns:
+            self_callers.append(item)
+        else:
+            impacted_depth1.append(item)
+    depth_groups["1"] = impacted_depth1
+
     return {
         "target": symbol_query,
-        "targets_resolved": resolved_targets,
-        "depth_groups": depth_groups,
+        "resolved_to": resolved_targets,
+        "self_callers": self_callers,
+        "impacted_callers": depth_groups,
         "summary": {
             "direct": len(depth_groups["1"]),
             "indirect": len(depth_groups["2"]),
             "transitive": len(depth_groups["3+"]),
+            "self_callers": len(self_callers),
         },
     }

{codespine-0.8.0 → codespine-0.9.0}/codespine/db/schema.py

@@ -51,6 +51,16 @@ REL_TABLES: Iterable[tuple[str, str]] = [
         "CO_CHANGED_WITH",
         "CREATE REL TABLE CO_CHANGED_WITH(FROM File TO File, strength DOUBLE, cochanges INT64, days INT64)",
     ),
+    # v5: Dependency-injection edges — tracks @Inject/@Autowired/@Provides/@Bean bindings
+    (
+        "INJECTS",
+        "CREATE REL TABLE INJECTS(FROM Class TO Class, framework STRING, binding_type STRING, confidence DOUBLE)",
+    ),
+    # v5: Interface-to-implementation bindings discovered via @Component/@Service annotations
+    (
+        "BINDS_INTERFACE",
+        "CREATE REL TABLE BINDS_INTERFACE(FROM Class TO Class, confidence DOUBLE, reason STRING)",
+    ),
 ]
 
 
@@ -81,7 +91,7 @@ def ensure_schema(conn) -> None:
 
     _safe_execute(
         conn,
-        "MERGE (s:SchemaMeta {key: 'schema_version'}) SET s.value = '4'",
+        "MERGE (s:SchemaMeta {key: 'schema_version'}) SET s.value = '5'",
     )
 
     _safe_execute(conn, "ALTER TABLE Project ADD indexed_commit STRING DEFAULT ''")

{codespine-0.8.0 → codespine-0.9.0}/codespine/db/store.py

@@ -476,6 +476,163 @@ class GraphStore:
                 confidence=float(record["confidence"]),
             )
 
+    def add_injection(
+        self,
+        src_class_id: str,
+        dst_class_id: str,
+        framework: str,
+        binding_type: str,
+        confidence: float,
+    ) -> None:
+        """Write an INJECTS edge between two Class nodes."""
+        try:
+            self.execute(
+                """
+                MATCH (a:Class {id: $src}), (b:Class {id: $dst})
+                MERGE (a)-[:INJECTS {framework: $fw, binding_type: $bt, confidence: $conf}]->(b)
+                """,
+                {
+                    "src": src_class_id,
+                    "dst": dst_class_id,
+                    "fw": framework,
+                    "bt": binding_type,
+                    "conf": float(confidence),
+                },
+            )
+        except Exception as exc:
+            LOGGER.debug("add_injection: skipping edge %s→%s: %s", src_class_id, dst_class_id, exc)
+
+    def add_injections_batch(self, records: list[dict[str, Any]]) -> None:
+        for rec in records:
+            self.add_injection(
+                src_class_id=rec["src"],
+                dst_class_id=rec["dst"],
+                framework=rec.get("framework", "unknown"),
+                binding_type=rec.get("binding_type", "unknown"),
+                confidence=float(rec.get("confidence", 0.8)),
+            )
+
+    def add_interface_binding(
+        self,
+        src_class_id: str,
+        dst_class_id: str,
+        confidence: float,
+        reason: str,
+    ) -> None:
+        """Write a BINDS_INTERFACE edge between two Class nodes."""
+        try:
+            self.execute(
+                """
+                MATCH (a:Class {id: $src}), (b:Class {id: $dst})
+                MERGE (a)-[:BINDS_INTERFACE {confidence: $conf, reason: $reason}]->(b)
+                """,
+                {
+                    "src": src_class_id,
+                    "dst": dst_class_id,
+                    "conf": float(confidence),
+                    "reason": reason,
+                },
+            )
+        except Exception as exc:
+            LOGGER.debug("add_interface_binding: skipping edge %s→%s: %s", src_class_id, dst_class_id, exc)
+
+    def add_interface_bindings_batch(self, records: list[dict[str, Any]]) -> None:
+        for rec in records:
+            self.add_interface_binding(
+                src_class_id=rec["src"],
+                dst_class_id=rec["dst"],
+                confidence=float(rec.get("confidence", 0.9)),
+                reason=rec.get("reason", "implements"),
+            )
+
+    # Sub-batch sizes for direct-to-graph file writes (same policy as engine.py)
+    _FILE_METHOD_SUB_BATCH = 200
+    _FILE_SYMBOL_SUB_BATCH = 200
+    _FILE_CALL_SUB_BATCH = 500
+    _FILE_REL_SUB_BATCH = 500
+
+    def upsert_file_from_entry(self, entry: dict, project_path: str) -> None:
+        """Atomically replace one file's graph data from a build_overlay_file_entry() dict.
+
+        Clears all existing nodes/edges for the file first, then writes the
+        full parsed content (file, classes, methods, symbols, calls, type rels)
+        in sub-batched transactions to prevent Kuzu buffer pool OOM.
+
+        This is the primary path for watch-mode incremental writes — it
+        bypasses the overlay JSON store and writes directly to the write DB
+        so changes are immediately visible after snapshot_to_read_replica().
+        """
+        f_id = entry["file_id"]
+        path = entry["file_path"]
+        project_id = entry["project_id"]
+        is_test = bool(entry.get("is_test", False))
+        digest = entry.get("file_hash", "")
+        classes = entry.get("classes") or []
+        methods = entry.get("methods") or []
+        symbols = entry.get("symbols") or []
+        calls = entry.get("calls") or []
+        type_rels = entry.get("types") or []
+
+        # 1. Clear stale data for this file
+        with self.transaction():
+            self.clear_file(f_id)
+        self._recycle_conn()
+
+        # 2. Upsert file record
+        with self.transaction():
+            self.upsert_file(f_id, path, project_id, is_test, digest)
+        self._recycle_conn()
+
+        # 3. Upsert classes (typically very few per file)
+        if classes:
+            with self.transaction():
+                self.upsert_classes_batch(classes)
+            self._recycle_conn()
+
+        # 4. Upsert methods in sub-batches of 200
+        for i in range(0, len(methods), self._FILE_METHOD_SUB_BATCH):
+            batch = methods[i: i + self._FILE_METHOD_SUB_BATCH]
+            with self.transaction():
+                self.upsert_methods_batch(batch)
+            self._recycle_conn()
+
+        # 5. Upsert symbols in sub-batches of 200
+        for i in range(0, len(symbols), self._FILE_SYMBOL_SUB_BATCH):
+            batch = symbols[i: i + self._FILE_SYMBOL_SUB_BATCH]
+            with self.transaction():
+                self.upsert_symbols_batch(batch)
+            self._recycle_conn()
+
+        # 6. Write call edges in sub-batches of 500
+        for i in range(0, len(calls), self._FILE_CALL_SUB_BATCH):
+            batch = calls[i: i + self._FILE_CALL_SUB_BATCH]
+            with self.transaction():
+                for rec in batch:
+                    self.add_call(
+                        source_id=rec["src"],
+                        target_id=rec["dst"],
+                        confidence=float(rec.get("confidence", 0.5)),
+                        reason=rec.get("reason", "unknown"),
+                    )
+            self._recycle_conn()
+
+        # 7. Write type relations (IMPLEMENTS, OVERRIDES, REFERENCES_TYPE)
+        for i in range(0, len(type_rels), self._FILE_REL_SUB_BATCH):
+            batch = type_rels[i: i + self._FILE_REL_SUB_BATCH]
+            with self.transaction():
+                self.add_references_batch(batch)
+            self._recycle_conn()
+
+    def clear_file_by_path(self, project_id: str, project_path: str, file_path: str) -> None:
+        """Delete all graph data for a file identified by its filesystem path."""
+        from codespine.indexer.symbol_builder import file_id as _fid
+        import os as _os
+        rel_path = _os.path.relpath(os.path.abspath(file_path), os.path.abspath(project_path))
+        f_id = _fid(project_id, rel_path)
+        with self.transaction():
+            self.clear_file(f_id)
+        self._recycle_conn()
+
     def _recycle_conn(self) -> None:
         """Drop and recreate the per-thread connection to release buffer pages."""
         try:

codespine-0.9.0/codespine/indexer/di_resolver.py

@@ -0,0 +1,210 @@
+"""Dependency-injection binding resolver for CodeSpine.
+
+Produces INJECTS and BINDS_INTERFACE edges by inspecting:
+
+1. @Inject / @Autowired fields  →  INJECTS(consumer_class → provider_class)
+2. @Provides / @Bean methods    →  INJECTS(config_class → consumer_classes)
+3. @Component/@Service classes  →  BINDS_INTERFACE(impl → interface) when
+                                   the class implements an indexed interface.
+
+All edges are written in sub-batched transactions by the engine after
+call resolution completes.
+
+Edge schemas
+------------
+INJECTS(FROM Class TO Class,
+        framework STRING,   # "spring" | "guice" | "jakarta" | "javax" | "unknown"
+        binding_type STRING, # "field_inject" | "constructor_inject" |
+                              #  "provides_binding" | "bean_method" | "component_scan"
+        confidence DOUBLE)
+
+BINDS_INTERFACE(FROM Class TO Class,
+                confidence DOUBLE,
+                reason STRING)   # "implements" | "extends"
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Iterator
+
+LOGGER = logging.getLogger(__name__)
+
+# Annotations that mark a field/constructor parameter as injection point.
+_INJECT_ANNOTATIONS = frozenset({
+    "Inject", "Autowired", "Resource",
+    "javax.inject.Inject", "jakarta.inject.Inject",
+    "org.springframework.beans.factory.annotation.Autowired",
+})
+
+# Annotations that mark a method as a DI provider.
+_PROVIDES_ANNOTATIONS = frozenset({
+    "Provides", "Bean",
+    "com.google.inject.Provides",
+    "org.springframework.context.annotation.Bean",
+})
+
+# Component-scan annotations: classes with these are treated as injectable.
+_COMPONENT_ANNOTATIONS = frozenset({
+    "Component", "Service", "Repository", "Controller", "RestController",
+    "Configuration", "ManagedBean", "Named",
+    "org.springframework.stereotype.Component",
+    "org.springframework.stereotype.Service",
+    "javax.inject.Named", "jakarta.inject.Named",
+})
+
+# DI frameworks by annotation prefix
+_FRAMEWORK_MAP: dict[str, str] = {
+    "Autowired": "spring",
+    "Component": "spring", "Service": "spring", "Repository": "spring",
+    "Controller": "spring", "RestController": "spring", "Bean": "spring",
+    "Configuration": "spring",
+    "Inject": "guice",
+    "Provides": "guice",
+    "Named": "guice",
+    "Resource": "jakarta",
+    "ManagedBean": "jakarta",
+}
+
+
+def _framework(annotation: str) -> str:
+    simple = annotation.split(".")[-1]
+    if "springframework" in annotation:
+        return "spring"
+    if "google.inject" in annotation:
+        return "guice"
+    if "jakarta.inject" in annotation:
+        return "jakarta"
+    if "javax.inject" in annotation:
+        return "javax"
+    return _FRAMEWORK_MAP.get(simple, "unknown")
+
+
+def _simple(annotation: str) -> str:
+    return annotation.split(".")[-1]
+
+
+def resolve_di_bindings(
+    class_catalog: dict[str, list[str]],
+    class_meta: dict[str, dict[str, Any]],
+    parsed_classes: list[dict[str, Any]],
+    fqcn_to_class_ids: dict[str, list[str]],
+) -> Iterator[tuple[str, str, str, str, float, str]]:
+    """Yield (src_class_id, dst_class_id, framework, binding_type, confidence, edge_type) tuples.
+
+    edge_type is "INJECTS" or "BINDS_INTERFACE".
+
+    Parameters
+    ----------
+    class_catalog      : name → [fqcn, ...]  (full project catalog)
+    class_meta         : class_id → {fqcn, annotations, interfaces, extends, imports, package}
+    parsed_classes     : list of dicts from build_overlay_file_entry / engine — each has:
+                           id, fqcn, name, package, file_id, and extra DI metadata fields
+                           injected_fields, methods_with_provides
+    fqcn_to_class_ids  : fqcn → [class_id, ...]
+    """
+    # Build a reverse FQCN lookup: fqcn → class_id (first match)
+    fqcn_to_id: dict[str, str] = {}
+    for fqcn, ids in fqcn_to_class_ids.items():
+        if ids:
+            fqcn_to_id[fqcn] = ids[0]
+
+    # Build simple-name → [fqcn] lookup for type resolution.
+    name_to_fqcns: dict[str, list[str]] = {}
+    for fqcn in fqcn_to_id:
+        simple = fqcn.split(".")[-1]
+        name_to_fqcns.setdefault(simple, []).append(fqcn)
+    # Also add class_catalog entries.
+    for name, fqcns in class_catalog.items():
+        for fqcn in fqcns:
+            if fqcn not in name_to_fqcns.get(name, []):
+                name_to_fqcns.setdefault(name, []).append(fqcn)
+
+    # Build a set of class_ids for component-scan eligible classes.
+    component_class_ids: set[str] = set()
+    for meta in class_meta.values():
+        anns = [_simple(a) for a in (meta.get("annotations") or [])]
+        if any(a in _COMPONENT_ANNOTATIONS for a in anns):
+            cid = meta.get("id") or ""
+            if cid:
+                component_class_ids.add(cid)
+
+    def _resolve_type(type_name: str, package: str, imports: list[str]) -> list[str]:
+        """Best-effort resolution of a simple type name to known class IDs."""
+        if not type_name:
+            return []
+        # Strip generics: List<Foo> → Foo
+        if "<" in type_name:
+            type_name = type_name[type_name.index("<") + 1:].rstrip(">").strip()
+        simple = type_name.split(".")[-1]
+        candidates: list[str] = []
+        # 1. Exact FQ match.
+        if "." in type_name and type_name in fqcn_to_id:
+            candidates.append(fqcn_to_id[type_name])
+        # 2. Same package.
+        same_pkg = f"{package}.{simple}" if package else simple
+        if same_pkg in fqcn_to_id:
+            candidates.append(fqcn_to_id[same_pkg])
+        # 3. From imports.
+        for imp in imports:
+            if imp.endswith(f".{simple}") and imp in fqcn_to_id:
+                candidates.append(fqcn_to_id[imp])
+        # 4. Name catalog.
+        for fqcn in name_to_fqcns.get(simple, []):
+            cid = fqcn_to_id.get(fqcn)
+            if cid:
+                candidates.append(cid)
+        return list(dict.fromkeys(candidates))  # deduplicate preserving order
+
+    # ---------------------------------------------------------------
+    # Process each parsed class.
+    # ---------------------------------------------------------------
+    for cls in parsed_classes:
+        src_id = cls.get("id") or cls.get("class_id") or ""
+        if not src_id:
+            continue
+        meta = class_meta.get(src_id, {})
+        package = str(meta.get("package") or cls.get("package") or "")
+        imports: list[str] = meta.get("imports") or []
+        cls_annotations: list[str] = [_simple(a) for a in (meta.get("annotations") or cls.get("annotations") or [])]
+
+        # --- 1. @Inject / @Autowired fields → INJECTS edges ---------
+        for fld in cls.get("injected_fields") or []:
+            inj_ann = fld.get("injection_annotation") or ""
+            if not inj_ann or _simple(inj_ann) not in frozenset({
+                "Inject", "Autowired", "Resource"
+            }):
+                continue
+            type_name = fld.get("type_name") or ""
+            dst_ids = _resolve_type(type_name, package, imports)
+            fw = _framework(inj_ann)
+            for dst_id in dst_ids:
+                if dst_id != src_id:
+                    yield (src_id, dst_id, fw, "field_inject", 0.85, "INJECTS")
+
+        # --- 2. @Provides / @Bean methods → INJECTS (config → type) -
+        for method in cls.get("methods_with_provides") or []:
+            provides_type = method.get("provides_type") or ""
+            if not provides_type:
+                continue
+            ann = method.get("provides_annotation") or "Provides"
+            fw = _framework(ann)
+            dst_ids = _resolve_type(provides_type, package, imports)
+            for dst_id in dst_ids:
+                if dst_id != src_id:
+                    binding_type = "bean_method" if _simple(ann) == "Bean" else "provides_binding"
+                    yield (src_id, dst_id, fw, binding_type, 0.9, "INJECTS")
+
+        # --- 3. Component-scan: class implementing interfaces → BINDS_INTERFACE
+        if any(a in _COMPONENT_ANNOTATIONS for a in cls_annotations):
+            for iface_name in meta.get("interfaces") or []:
+                dst_ids = _resolve_type(iface_name, package, imports)
+                for dst_id in dst_ids:
+                    if dst_id != src_id:
+                        yield (src_id, dst_id, 1.0, "implements", 0.95, "BINDS_INTERFACE")
+            extends_name = meta.get("extends") or ""
+            if extends_name:
+                dst_ids = _resolve_type(extends_name, package, imports)
+                for dst_id in dst_ids:
+                    if dst_id != src_id:
+                        yield (src_id, dst_id, 0.7, "extends", 0.7, "BINDS_INTERFACE")

{codespine-0.8.0 → codespine-0.9.0}/codespine/indexer/engine.py

@@ -230,6 +230,7 @@ class JavaIndexer:
         fqcn_to_class_ids: dict[str, list[str]] = self._existing_class_ids_by_fqcn(project_id) if not full else {}
         class_meta: dict[str, dict] = {}
         class_methods: dict[str, dict[str, str]] = self._existing_class_methods(project_id) if not full else {}
+        di_classes: list[dict] = []  # accumulates DI metadata for resolver pass
 
         # ── Parallel parse (CPU/IO) ──────────────────────────────────────────
         # tree-sitter releases the GIL so ThreadPoolExecutor gives real speedup.
@@ -326,11 +327,13 @@ class JavaIndexer:
                     if c_id not in fqcn_to_class_ids[cls.fqcn]:
                         fqcn_to_class_ids[cls.fqcn].append(c_id)
                     class_meta[c_id] = {
+                        "id": c_id,
                         "fqcn": cls.fqcn,
                         "package": parsed.package,
                         "imports": parsed.imports,
                         "extends": cls.extends,
                         "interfaces": cls.interfaces,
+                        "annotations": cls.annotations,
                         "scope": scope,
                     }
                     class_methods.setdefault(c_id, {})
@@ -350,6 +353,38 @@ class JavaIndexer:
                     )
                     classes_indexed += 1
 
+                    # Collect DI metadata for the resolver pass.
+                    di_cls_entry: dict = {
+                        "id": c_id,
+                        "fqcn": cls.fqcn,
+                        "name": cls.name,
+                        "package": cls.package,
+                        "annotations": cls.annotations,
+                        "injected_fields": [
+                            {
+                                "name": f.name,
+                                "type_name": f.type_name,
+                                "injection_annotation": f.injection_annotation,
+                                "qualifier": f.qualifier,
+                            }
+                            for f in cls.fields
+                            if f.injection_annotation
+                        ],
+                        "methods_with_provides": [
+                            {
+                                "name": m.name,
+                                "provides_type": m.provides_type,
+                                "provides_annotation": next(
+                                    (a for a in m.annotations if a.split(".")[-1] in {"Provides", "Bean"}),
+                                    "Provides",
+                                ),
+                            }
+                            for m in cls.methods
+                            if m.provides_type
+                        ],
+                    }
+                    di_classes.append(di_cls_entry)
+
                     for fld in cls.fields:
                         fqfield = f"{cls.fqcn}#{fld.name}"
                         symbol_rows.append(
@@ -473,6 +508,42 @@ class JavaIndexer:
             self.store._recycle_conn()
         self._emit(progress, "resolve_types_done", type_relationships=type_relationships)
 
+        # ── DI binding resolution ─────────────────────────────────────────────
+        # Resolve @Inject/@Autowired/@Provides/@Bean bindings into INJECTS and
+        # BINDS_INTERFACE graph edges.  This runs after all classes/methods are
+        # written so the full cross-project catalog is available for type lookup.
+        di_inject_rows: list[dict] = []
+        di_bind_rows: list[dict] = []
+        try:
+            from codespine.indexer.di_resolver import resolve_di_bindings
+            for tup in resolve_di_bindings(class_catalog, class_meta, di_classes, fqcn_to_class_ids):
+                src, dst, fw_or_conf, bt_or_reason, conf, edge_type = tup
+                if edge_type == "INJECTS":
+                    di_inject_rows.append({
+                        "src": src, "dst": dst,
+                        "framework": fw_or_conf, "binding_type": bt_or_reason,
+                        "confidence": conf,
+                    })
+                else:
+                    di_bind_rows.append({
+                        "src": src, "dst": dst,
+                        "confidence": float(fw_or_conf), "reason": bt_or_reason,
+                    })
+        except Exception as exc:
+            LOGGER.warning("DI resolver failed (non-fatal): %s", exc)
+
+        _DI_BATCH = 500
+        for chunk in self._chunked(di_inject_rows, _DI_BATCH):
+            with self.store.transaction():
+                self.store.add_injections_batch(chunk)
+            self.store._recycle_conn()
+        for chunk in self._chunked(di_bind_rows, _DI_BATCH):
+            with self.store.transaction():
+                self.store.add_interface_bindings_batch(chunk)
+            self.store._recycle_conn()
+        self._emit(progress, "di_done",
+                   injections=len(di_inject_rows), interface_bindings=len(di_bind_rows))
+
         self._prune_meta_cache(meta_cache, current_file_ids)
         self._save_file_meta_cache(project_id, meta_cache)