attocode-code-intel 0.1.0__py3-none-any.whl

attocode_intel/_internal/integrations/context/hydration.py

@@ -0,0 +1,90 @@
+"""Progressive hydration state and tier classification.
+
+Determines how aggressively to index a repository based on its size,
+and tracks progressive indexing state across phases.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import time
+
+# Tier constants
+TIER_SMALL = "small"
+TIER_MEDIUM = "medium"
+TIER_LARGE = "large"
+TIER_HUGE = "huge"
+
+# Tier boundaries (source file count)
+_MEDIUM_THRESHOLD = 1_000
+_LARGE_THRESHOLD = 5_000
+_HUGE_THRESHOLD = 20_000
+
+# Skeleton parse budgets per tier
+_SKELETON_BUDGETS = {
+    TIER_SMALL: None,    # None = parse all
+    TIER_MEDIUM: 500,
+    TIER_LARGE: 300,
+    TIER_HUGE: 200,
+}
+
+
+def classify_tier(source_file_count: int) -> str:
+    """Classify repo into a hydration tier based on source file count."""
+    if source_file_count >= _HUGE_THRESHOLD:
+        return TIER_HUGE
+    if source_file_count >= _LARGE_THRESHOLD:
+        return TIER_LARGE
+    if source_file_count >= _MEDIUM_THRESHOLD:
+        return TIER_MEDIUM
+    return TIER_SMALL
+
+
+def skeleton_budget(tier: str, total_files: int) -> int:
+    """Return how many files to parse in Phase 1 (skeleton)."""
+    budget = _SKELETON_BUDGETS.get(tier)
+    if budget is None:
+        return total_files  # small: parse all
+    return min(budget, total_files)
+
+
+@dataclass
+class HydrationState:
+    """Tracks progressive indexing state."""
+    tier: str = TIER_SMALL
+    total_files: int = 0
+    parsed_files: int = 0
+    reference_indexed_files: int = 0
+    dep_graph_files: int = 0
+    embedding_coverage: float = 0.0
+    phase: str = "skeleton"              # skeleton | hydrating | ready
+    started_at: float = field(default_factory=time.monotonic)
+
+    @property
+    def parse_coverage(self) -> float:
+        if self.total_files == 0:
+            return 1.0
+        return self.parsed_files / self.total_files
+
+    @property
+    def reference_coverage(self) -> float:
+        if self.total_files == 0:
+            return 1.0
+        return self.reference_indexed_files / self.total_files
+
+    @property
+    def elapsed_ms(self) -> float:
+        return (time.monotonic() - self.started_at) * 1000
+
+    def to_dict(self) -> dict:
+        return {
+            "tier": self.tier,
+            "phase": self.phase,
+            "total_files": self.total_files,
+            "parsed_files": self.parsed_files,
+            "parse_coverage": round(self.parse_coverage, 3),
+            "reference_indexed_files": self.reference_indexed_files,
+            "reference_coverage": round(self.reference_coverage, 3),
+            "dep_graph_files": self.dep_graph_files,
+            "embedding_coverage": round(self.embedding_coverage, 3),
+            "elapsed_ms": round(self.elapsed_ms, 1),
+        }

attocode_intel/_internal/integrations/context/index_repair.py

@@ -0,0 +1,87 @@
+"""Repair a complete structural snapshot after filesystem changes."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .codebase_context import build_dependency_graph
+from .cross_references import CrossRefIndex
+
+
+def changed_paths(before: dict, after: dict) -> set[str]:
+    old, new = before["files"], after["files"]
+    return {path for path in old.keys() | new.keys() if old.get(path) != new.get(path)}
+
+
+def repair_index(service, asts: dict, identity: dict, changed: set[str]) -> dict:
+    """Keep unaffected references; rebuild graph resolution from current ASTs.
+
+    A definition added or removed can affect calls in unchanged source files.
+    Shortlist those files using changed symbol names before extracting their
+    references again. All definitions exist before any reference extraction.
+    """
+    old = service._index
+    new = CrossRefIndex()
+    for path, ast in asts.items():
+        service._index_definitions(path, ast, index=new)
+
+    names = {name.rsplit(".", 1)[-1] for name in old.definitions.keys() ^ new.definitions.keys()}
+    affected = changed & asts.keys()
+    if names:
+        # Broad refactors fall back to complete reference extraction. Small
+        # edits scan text once without parsing every call site again.
+        pattern = re.compile("|".join(re.escape(name) for name in sorted(names))) if len(names) <= 128 else None
+        for path in asts.keys() - affected:
+            if pattern is None or pattern.search(
+                (Path(service.root_dir) / path).read_text(encoding="utf-8", errors="replace")
+            ):
+                affected.add(path)
+
+    for refs in old.references.values():
+        for ref in refs:
+            if ref.file_path in asts and ref.file_path not in affected:
+                new.add_reference(ref)
+    for path in sorted(affected):
+        service._index_references(path, asts[path], index=new)
+
+    graph = build_dependency_graph(service._context_mgr._files, service.root_dir, ast_cache=asts)
+    for source, targets in graph.forward.items():
+        for target in targets:
+            new.add_file_dependency(source, target)
+    if service._snapshot_identity() != identity:
+        raise ValueError("Workspace changed during index repair; retry")
+
+    # Invalidate before the first write: a crash cannot bless a partial update.
+    store = service._store
+    store.set_meta("structural_snapshot_v1", "")
+    removed = {row.path for row in store.get_all_files()} - asts.keys()
+    for path in sorted(removed):
+        store.remove_file(path)
+    store.save_files_batch([
+        service._build_stored_file(path, asts[path], identity["files"][path][0] / 1e9)
+        for path in sorted(affected)
+    ])
+    new.set_store(store)
+    new.persist_files(affected)
+
+    service._index = new
+    service._ast_cache = asts
+    service._reference_indexed_files = set(asts)
+    service._context_mgr._dep_graph = graph
+    service._context_mgr._ast_cache = dict(asts)
+    service._context_mgr._repo_map = None
+    service._snapshot_start = identity
+    state = service._hydration_state
+    state.total_files = state.parsed_files = state.reference_indexed_files = len(asts)
+    state.dep_graph_files = len(graph.forward)
+    state.phase = "ready"
+    if not service._save_snapshot():
+        raise ValueError("Workspace changed before index repair completed; retry")
+    store.record_scan_time()
+    return {
+        "changed_files": len(changed),
+        "removed_files": len(removed),
+        "reindexed_reference_files": len(affected),
+        "reused_reference_files": len(asts) - len(affected),
+    }