codigest 0.3.6__tar.gz → 0.3.7__tar.gz

{codigest-0.3.6 → codigest-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codigest
-Version: 0.3.6
+Version: 0.3.7
 Summary: Human-Centered Codebase Context Manager for LLMs
 Project-URL: Homepage, https://github.com/SJB777/codigest
 Project-URL: Repository, https://github.com/SJB777/codigest

{codigest-0.3.6 → codigest-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codigest"
-version = "0.3.6"
+version = "0.3.7"
 description = "Human-Centered Codebase Context Manager for LLMs"
 authors = [{name = "Codigest Team", email = "sngd024@google.com"}]
 readme = "README.md"

{codigest-0.3.6 → codigest-0.3.7}/src/codigest/commands/digest.py

@@ -55,17 +55,15 @@ def handle(
                 except ValueError:
                     rel_path = f"[EXTERNAL]/{file_path.name}"
 
-                blob_hash = cache.get_file_blob_hash(file_path)
-                summary = None
-                if blob_hash:
-                    summary = content_cache.get_summary(rel_path, blob_hash)
+                summary = content_cache.get_summary(rel_path, blob_hash=None, file_path=file_path)
 
                 if summary is None:
                     try:
+                        blob_hash = cache.get_file_blob_hash(file_path)
                         content = file_path.read_text(encoding="utf-8")
                         summary = semdiff.summarize(content)
                         if summary and blob_hash:
-                            content_cache.set_summary(rel_path, blob_hash, summary)
+                            content_cache.set_summary(rel_path, blob_hash, summary, file_path=file_path)
                     except Exception:
                         continue
 

{codigest-0.3.6 → codigest-0.3.7}/src/codigest/commands/scan.py

@@ -123,20 +123,27 @@ def handle(
             except ValueError:
                 rel_path = f"[EXTERNAL]/{file_path.name}"
 
-            blob_hash = cache.get_file_blob_hash(file_path)
-            cached_block = None
-            if blob_hash:
-                cached_block = content_cache.get_file_block(rel_path, blob_hash, line_numbers)
+            cached_block = content_cache.get_file_block(
+                rel_path=rel_path, 
+                line_numbers=line_numbers, 
+                file_path=file_path
+            )
 
             if cached_block is not None:
                 file_blocks.append(cached_block)
             else:
                 try:
+                    blob_hash = cache.get_file_blob_hash(file_path)
                     content = processor.read_file_content(file_path, add_line_numbers=line_numbers)
                     block = tags.file(rel_path, content)
                     file_blocks.append(block)
-                    if blob_hash:
-                        content_cache.set_file_block(rel_path, blob_hash, line_numbers, block)
+                    content_cache.set_file_block(
+                        rel_path=rel_path, 
+                        blob_hash=blob_hash, 
+                        line_numbers=line_numbers, 
+                        block=block, 
+                        file_path=file_path
+                    )
                 except Exception:
                     continue
 

codigest-0.3.7/src/codigest/core/cache.py

@@ -0,0 +1,170 @@
+"""
+Git Blob Hash-based Content & AST Cache.
+Provides fast caching for scan snapshot blocks and digest AST summaries.
+"""
+import json
+import hashlib
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+def compute_git_blob_hash(data: bytes) -> str:
+    """Computes Git-compatible SHA-1 blob hash for raw bytes."""
+    header = f"blob {len(data)}\0".encode("utf-8")
+    return hashlib.sha1(header + data).hexdigest()
+
+def get_file_blob_hash(file_path: Path) -> Optional[str]:
+    """Reads file and computes its Git blob hash."""
+    try:
+        data = file_path.read_bytes()
+        return compute_git_blob_hash(data)
+    except Exception:
+        return None
+
+class ContentCache:
+    def __init__(self, root_path: Path):
+        self.root_path = root_path
+        self.cache_file = root_path / ".codigest" / "cache.json"
+        self._data: Dict[str, Any] = {}
+        self.hits = 0
+        self.misses = 0
+        self._load()
+
+    def _load(self):
+        if self.cache_file.exists():
+            try:
+                with open(self.cache_file, "r", encoding="utf-8") as f:
+                    self._data = json.load(f)
+            except Exception:
+                self._data = {}
+        else:
+            self._data = {}
+
+    def save(self):
+        try:
+            self.cache_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.cache_file, "w", encoding="utf-8") as f:
+                json.dump(self._data, f, ensure_ascii=False, indent=2)
+        except Exception:
+            pass
+
+    def get_file_block(
+        self, 
+        rel_path: str, 
+        blob_hash: Optional[str] = None, 
+        line_numbers: bool = False, 
+        file_path: Optional[Path] = None
+    ) -> Optional[str]:
+        # [1] Fast path: Stat check if file_path is provided
+        if file_path is not None:
+            try:
+                stat = file_path.stat()
+                entry = self._data.get("files", {}).get(rel_path)
+                if entry and entry.get("mtime_ns") == stat.st_mtime_ns and entry.get("size") == stat.st_size:
+                    block = entry.get("blocks", {}).get(str(line_numbers))
+                    if block is not None:
+                        self.hits += 1
+                        return block
+            except Exception:
+                pass
+
+        # [2] Hash path (if blob_hash available)
+        if blob_hash:
+            entry = self._data.get("files", {}).get(rel_path)
+            if entry and entry.get("blob_hash") == blob_hash:
+                block = entry.get("blocks", {}).get(str(line_numbers))
+                if block is not None:
+                    self.hits += 1
+                    if file_path is not None:
+                        try:
+                            stat = file_path.stat()
+                            entry["mtime_ns"] = stat.st_mtime_ns
+                            entry["size"] = stat.st_size
+                        except Exception:
+                            pass
+                    return block
+
+            # Backward compatibility check for old flat cache keys
+            cache_key = f"{rel_path}:{blob_hash}:lines={line_numbers}"
+            val = self._data.get("file_blocks", {}).get(cache_key)
+            if val is not None:
+                self.hits += 1
+                return val
+
+        self.misses += 1
+        return None
+
+    def set_file_block(
+        self, 
+        rel_path: str, 
+        blob_hash: Optional[str], 
+        line_numbers: bool, 
+        block: str, 
+        file_path: Optional[Path] = None
+    ):
+        if "files" not in self._data:
+            self._data["files"] = {}
+
+        if rel_path not in self._data["files"]:
+            self._data["files"][rel_path] = {"blocks": {}}
+
+        entry = self._data["files"][rel_path]
+        if blob_hash:
+            entry["blob_hash"] = blob_hash
+
+        if file_path is not None:
+            try:
+                stat = file_path.stat()
+                entry["mtime_ns"] = stat.st_mtime_ns
+                entry["size"] = stat.st_size
+            except Exception:
+                pass
+
+        entry.setdefault("blocks", {})[str(line_numbers)] = block
+
+        # Legacy format support
+        if blob_hash:
+            if "file_blocks" not in self._data:
+                self._data["file_blocks"] = {}
+            cache_key = f"{rel_path}:{blob_hash}:lines={line_numbers}"
+            self._data["file_blocks"][cache_key] = block
+
+    def get_summary(self, rel_path: str, blob_hash: str, file_path: Optional[Path] = None) -> Optional[str]:
+        if file_path is not None:
+            try:
+                stat = file_path.stat()
+                entry = self._data.get("summaries_meta", {}).get(rel_path)
+                if entry and entry.get("mtime_ns") == stat.st_mtime_ns and entry.get("size") == stat.st_size:
+                    summary = entry.get("summary")
+                    if summary is not None:
+                        self.hits += 1
+                        return summary
+            except Exception:
+                pass
+
+        cache_key = f"{rel_path}:{blob_hash}"
+        val = self._data.get("summaries", {}).get(cache_key)
+        if val is not None:
+            self.hits += 1
+        else:
+            self.misses += 1
+        return val
+
+    def set_summary(self, rel_path: str, blob_hash: str, summary: str, file_path: Optional[Path] = None):
+        if "summaries" not in self._data:
+            self._data["summaries"] = {}
+        cache_key = f"{rel_path}:{blob_hash}"
+        self._data["summaries"][cache_key] = summary
+
+        if file_path is not None:
+            if "summaries_meta" not in self._data:
+                self._data["summaries_meta"] = {}
+            try:
+                stat = file_path.stat()
+                self._data["summaries_meta"][rel_path] = {
+                    "mtime_ns": stat.st_mtime_ns,
+                    "size": stat.st_size,
+                    "blob_hash": blob_hash,
+                    "summary": summary
+                }
+            except Exception:
+                pass

{codigest-0.3.6 → codigest-0.3.7}/src/codigest/core/shadow.py

@@ -40,6 +40,40 @@ class ContextAnchor:
             
         return (result.stdout or "").strip()
 
+    def has_changes(self, current_files: list[Path]) -> bool:
+        """Fast check to determine if any file was modified/added/deleted since last anchor baseline."""
+        if not self.git_dir.exists() or not (self.git_dir / "HEAD").exists() or not self.anchor_dir.exists():
+            return True
+
+        current_rel_paths = set()
+        for src in current_files:
+            if ".git" in src.parts or ".codigest" in src.parts:
+                continue
+            try:
+                rel = src.relative_to(self.root)
+                current_rel_paths.add(rel)
+                dest = self.anchor_dir / rel
+                if not dest.exists():
+                    return True
+                src_stat = src.stat()
+                dest_stat = dest.stat()
+                # Use size + 1ms mtime tolerance for filesystem precision differences
+                if src_stat.st_size != dest_stat.st_size or (src_stat.st_mtime_ns - dest_stat.st_mtime_ns) > 1_000_000:
+                    return True
+            except Exception:
+                return True
+
+        for anchor_file in self.anchor_dir.rglob("*"):
+            if anchor_file.is_file() and ".shadow_git" not in anchor_file.parts and anchor_file.name != ".gitignore":
+                try:
+                    rel = anchor_file.relative_to(self.anchor_dir)
+                    if rel not in current_rel_paths:
+                        return True
+                except Exception:
+                    continue
+
+        return False
+
     def update(self, source_files: list[Path]):
         self.anchor_dir.mkdir(parents=True, exist_ok=True)
         (self.anchor_dir / ".gitignore").write_text(".shadow_git\n", encoding="utf-8")
@@ -56,13 +90,9 @@ class ContextAnchor:
             self._run_git(["config", "core.autocrlf", "false"])
             self._run_git(["config", "gc.auto", "0"])
 
-        for item in self.anchor_dir.iterdir():
-            if item.name == ".shadow_git": # [변경] 보호할 폴더 이름 변경
-                continue
-            if item.is_dir():
-                shutil.rmtree(item)
-            else:
-                item.unlink()
+        # Quick check: if nothing changed since last anchor, skip work
+        if self.git_dir.exists() and (self.git_dir / "HEAD").exists() and not self.has_changes(source_files):
+            return
 
         source_rel_paths = set()
 
@@ -81,7 +111,7 @@ class ContextAnchor:
                     src_stat = src.stat()
                     dest_stat = dest.stat()
 
-                    if src_stat.st_size == dest_stat.st_size and dest_stat.st_mtime >= src_stat.st_mtime:
+                    if src_stat.st_size == dest_stat.st_size and dest_stat.st_mtime_ns >= src_stat.st_mtime_ns:
                         should_copy = False
                 
                 source_rel_paths.add(rel)
@@ -115,6 +145,9 @@ class ContextAnchor:
         if not self.git_dir.exists():
             return ""
 
+        if not self.has_changes(current_files):
+            return ""
+
         temp_current = self.root / ".codigest" / "temp_diff_current"
         temp_baseline = self.root / ".codigest" / "temp_diff_baseline"
         

codigest-0.3.6/src/codigest/core/cache.py

@@ -1,78 +0,0 @@
-"""
-Git Blob Hash-based Content & AST Cache.
-Provides fast caching for scan snapshot blocks and digest AST summaries.
-"""
-import json
-import hashlib
-from pathlib import Path
-from typing import Optional, Dict, Any
-
-def compute_git_blob_hash(data: bytes) -> str:
-    """Computes Git-compatible SHA-1 blob hash for raw bytes."""
-    header = f"blob {len(data)}\0".encode("utf-8")
-    return hashlib.sha1(header + data).hexdigest()
-
-def get_file_blob_hash(file_path: Path) -> Optional[str]:
-    """Reads file and computes its Git blob hash."""
-    try:
-        data = file_path.read_bytes()
-        return compute_git_blob_hash(data)
-    except Exception:
-        return None
-
-class ContentCache:
-    def __init__(self, root_path: Path):
-        self.root_path = root_path
-        self.cache_file = root_path / ".codigest" / "cache.json"
-        self._data: Dict[str, Any] = {}
-        self.hits = 0
-        self.misses = 0
-        self._load()
-
-    def _load(self):
-        if self.cache_file.exists():
-            try:
-                with open(self.cache_file, "r", encoding="utf-8") as f:
-                    self._data = json.load(f)
-            except Exception:
-                self._data = {}
-        else:
-            self._data = {}
-
-    def save(self):
-        try:
-            self.cache_file.parent.mkdir(parents=True, exist_ok=True)
-            with open(self.cache_file, "w", encoding="utf-8") as f:
-                json.dump(self._data, f, ensure_ascii=False, indent=2)
-        except Exception:
-            pass
-
-    def get_file_block(self, rel_path: str, blob_hash: str, line_numbers: bool) -> Optional[str]:
-        cache_key = f"{rel_path}:{blob_hash}:lines={line_numbers}"
-        val = self._data.get("file_blocks", {}).get(cache_key)
-        if val is not None:
-            self.hits += 1
-        else:
-            self.misses += 1
-        return val
-
-    def set_file_block(self, rel_path: str, blob_hash: str, line_numbers: bool, block: str):
-        if "file_blocks" not in self._data:
-            self._data["file_blocks"] = {}
-        cache_key = f"{rel_path}:{blob_hash}:lines={line_numbers}"
-        self._data["file_blocks"][cache_key] = block
-
-    def get_summary(self, rel_path: str, blob_hash: str) -> Optional[str]:
-        cache_key = f"{rel_path}:{blob_hash}"
-        val = self._data.get("summaries", {}).get(cache_key)
-        if val is not None:
-            self.hits += 1
-        else:
-            self.misses += 1
-        return val
-
-    def set_summary(self, rel_path: str, blob_hash: str, summary: str):
-        if "summaries" not in self._data:
-            self._data["summaries"] = {}
-        cache_key = f"{rel_path}:{blob_hash}"
-        self._data["summaries"][cache_key] = summary