codigest 0.3.6__tar.gz → 0.3.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codigest
-Version: 0.3.6
+Version: 0.3.8
 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.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codigest"
-version = "0.3.6"
+version = "0.3.8"
 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.8}/src/codigest/commands/diff.py

@@ -1,14 +1,12 @@
 import typer
-import pyperclip
 from pathlib import Path
-from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
+from ..options import CopyOption, StdoutOption, ResolveOption, MessageOption
 from ..core import prompts, shadow, tags, common
+from ..core.output import OutputHandler
 
 app = typer.Typer()
-console = Console()
-err_console = Console(stderr=True)
 
 @app.callback(invoke_without_command=True)
 def handle(
@@ -20,18 +18,18 @@ def handle(
         dir_okay=True,
         resolve_path=True
     ),
-    copy: bool = typer.Option(True, help="Auto-copy to clipboard"),
+    copy: CopyOption = True,
     save: bool = typer.Option(True, help="Save to .codigest/changes.diff"),
-    stdout: bool = typer.Option(False, "-s", "--stdout", help="Print output to terminal (stdout) instead of file"),
-    message: str = typer.Option("", "--message", "-m", help="Add specific instruction context"),
-    # [추가] resolve 옵션
-    resolve: bool = typer.Option(False, "-r", "--resolve", help="Recursively resolve imports"),
+    stdout: StdoutOption = False,
+    message: MessageOption = "",
+    resolve: ResolveOption = False,
 ):
     """
     [Context Update] Shows changes since the last 'codigest scan'.
     Useful for updating LLM context without re-uploading everything.
     """
-    log_console = err_console if stdout else console
+    handler = OutputHandler(stdout=stdout, copy=copy)
+    log_console = handler.log_console
 
     # [1] Context Setup
     ctx = common.get_context(target)
@@ -87,17 +85,11 @@ def handle(
     # [4] Output
     log_console.print(f"[bold green]Changes Detected![/bold green] ({len(formatted_diff)} chars)")
     
-    if copy:
-        try:
-            pyperclip.copy(formatted_diff)
-            log_console.print("[dim]Clipboard copied[/dim]")
-        except Exception:
-            log_console.print("[dim]⚠️ Clipboard unavailable (skipped copy)[/dim]")
+    def _save():
+        if save:
+            out_path = root_path / ".codigest" / "changes.diff"
+            out_path.parent.mkdir(exist_ok=True)
+            out_path.write_text(formatted_diff, encoding="utf-8")
+            log_console.print(f"[dim]Saved to {out_path}[/dim]")
 
-    if stdout:
-        print(formatted_diff)
-    elif save:
-        out_path = root_path / ".codigest" / "changes.diff"
-        out_path.parent.mkdir(exist_ok=True)
-        out_path.write_text(formatted_diff, encoding="utf-8")
-        log_console.print(f"[dim]Saved to {out_path}[/dim]")
+    handler.handle_output(formatted_diff, save_action=_save, item_name="diff")

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

@@ -1,29 +1,27 @@
 import typer
-import pyperclip
 from pathlib import Path
-from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
+from ..options import CopyOption, StdoutOption, ResolveOption, MessageOption
 from ..core import structure, prompts, semdiff, tags, tokenizer, common, cache
+from ..core.output import OutputHandler
 
 app = typer.Typer()
-console = Console()
-err_console = Console(stderr=True)
 
 @app.callback(invoke_without_command=True)
 def handle(
     target: Path = typer.Argument(Path.cwd(), help="Target directory"),
-    copy: bool = typer.Option(True, help="Auto-copy to clipboard"),
+    copy: CopyOption = True,
     save: bool = typer.Option(True, help="Save to .codigest/digest.txt"),
-    stdout: bool = typer.Option(False, "-s", "--stdout", help="Print output to terminal (stdout) instead of file"),
-    message: str = typer.Option("", "--message", "-m", help="Add specific instruction"),
-    # [추가]
-    resolve: bool = typer.Option(False, "-r", "--resolve", help="Recursively resolve imports"),
+    stdout: StdoutOption = False,
+    message: MessageOption = "",
+    resolve: ResolveOption = False,
 ):
     """
     [Architectural View] Summarizes the codebase structure (Classes/Functions only).
     """
-    log_console = err_console if stdout else console
+    handler = OutputHandler(stdout=stdout, copy=copy)
+    log_console = handler.log_console
 
     # [1] Context Setup
     ctx = common.get_context(target)
@@ -55,17 +53,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
 
@@ -94,17 +90,11 @@ def handle(
     token_count = tokenizer.estimate_tokens(digest_content)
     log_console.print(f"[bold green]Digest Generated![/bold green] ([bold cyan]~{token_count:,} Tokens[/bold cyan])")
     
-    if copy:
-        try:
-            pyperclip.copy(digest_content)
-            log_console.print("[dim]📋 Copied to clipboard[/dim]")
-        except Exception:
-            log_console.print("[dim]⚠️ Clipboard unavailable (skipped copy)[/dim]")
-    
-    if stdout:
-        print(digest_content)
-    elif save:
-        out_path = root_path / ".codigest" / "digest.txt"
-        out_path.parent.mkdir(exist_ok=True)
-        out_path.write_text(digest_content, encoding="utf-8")
-        log_console.print(f"[dim]💾 Saved to {out_path}[/dim]")
+    def _save():
+        if save:
+            out_path = root_path / ".codigest" / "digest.txt"
+            out_path.parent.mkdir(exist_ok=True)
+            out_path.write_text(digest_content, encoding="utf-8")
+            log_console.print(f"[dim]💾 Saved to {out_path}[/dim]")
+
+    handler.handle_output(digest_content, save_action=_save, item_name="digest")

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

@@ -1,16 +1,15 @@
 import sys
 import typer
 from pathlib import Path
-from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.panel import Panel
 from rich.filesize import decimal
 
+from ..options import CopyOption, StdoutOption, ResolveOption, MessageOption, AllOption
 from ..core import structure, tags, prompts, processor, shadow, tokenizer, common, cache
+from ..core.output import OutputHandler
 
 app = typer.Typer()
-console = Console()
-err_console = Console(stderr=True)
 
 @app.callback(invoke_without_command=True)
 def handle(
@@ -21,18 +20,20 @@ def handle(
         resolve_path=True
     ),
     output: str = typer.Option("snapshot.txt", "-o", "--output", help="Output filename inside .codigest/"),
-    stdout: bool = typer.Option(False, "-s", "--stdout", help="Print output to terminal (stdout) instead of file"),
-    all: bool = typer.Option(False, "--all", "-a", help="Ignore config filters"),
-    message: str = typer.Option("", "--message", "-m", help="Add specific instruction"),
+    copy: CopyOption = True,
+    stdout: StdoutOption = False,
+    all: AllOption = False,
+    message: MessageOption = "",
     line_numbers: bool = typer.Option(False, "--lines", "-l", help="Add line numbers to code blocks"),
     yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompt"),
-    resolve: bool = typer.Option(False, "-r", "--resolve", help="Recursively resolve imports for local files"),
+    resolve: ResolveOption = False,
 ):
     """
     Scans the codebase. 
     If TARGETS provided, only scans those paths within the project.
     """
-    log_console = err_console if stdout else console
+    handler = OutputHandler(stdout=stdout, copy=copy)
+    log_console = handler.log_console
 
     # [1] Context Setup (Centralized)
     ctx = common.get_context(targets)
@@ -123,20 +124,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
 
@@ -161,9 +169,7 @@ def handle(
     except Exception as e:
         log_console.print(f"[yellow][Warning] Failed to update context anchor: {e}[/yellow]")
 
-    if stdout:
-        print(snapshot_content)
-    else:
+    def _save():
         try:
             output_path.write_text(snapshot_content, encoding="utf-8")
             final_token_count = tokenizer.estimate_tokens(snapshot_content)
@@ -179,4 +185,6 @@ def handle(
 
         except Exception as e:
             log_console.print(f"[bold red][Error] Save Failed:[/bold red] {e}")
-            raise typer.Exit(1)
+            raise typer.Exit(1)
+
+    handler.handle_output(snapshot_content, save_action=_save)

{codigest-0.3.6 → codigest-0.3.8}/src/codigest/commands/semdiff.py

@@ -1,30 +1,28 @@
 import typer
-import pyperclip
 from pathlib import Path
-from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
+from ..options import CopyOption, StdoutOption, ResolveOption, MessageOption
 from ..core import prompts, shadow, semdiff, tags, tokenizer, common
+from ..core.output import OutputHandler
 
 app = typer.Typer()
-console = Console()
-err_console = Console(stderr=True)
 
 @app.callback(invoke_without_command=True)
 def handle(
     target: Path = typer.Argument(Path.cwd(), help="Target directory"),
-    copy: bool = typer.Option(True, help="Auto-copy to clipboard"),
+    copy: CopyOption = True,
     save: bool = typer.Option(True, help="Save to .codigest/semdiff.txt"),
-    stdout: bool = typer.Option(False, "-s", "--stdout", help="Print output to terminal (stdout) instead of file"),
-    message: str = typer.Option("", "--message", "-m", help="Add specific instruction"),
-    # [추가] resolve 옵션
-    resolve: bool = typer.Option(False, "-r", "--resolve", help="Recursively resolve imports"),
+    stdout: StdoutOption = False,
+    message: MessageOption = "",
+    resolve: ResolveOption = False,
 ):
     """
     [Advanced] Generates a Semantic Diff (AST-based) report.
     Shows ADDED/REMOVED/MODIFIED functions & classes instead of raw text lines.
     """
-    log_console = err_console if stdout else console
+    handler = OutputHandler(stdout=stdout, copy=copy)
+    log_console = handler.log_console
 
     # [1] Context Setup
     ctx = common.get_context(target)
@@ -134,17 +132,11 @@ def handle(
     token_count = tokenizer.estimate_tokens(final_output)
     log_console.print(f"[bold green]SemDiff Generated![/bold green] ([bold cyan]~{token_count:,} Tokens[/bold cyan])")
     
-    if copy:
-        try:
-            pyperclip.copy(final_output)
-            log_console.print("[dim]Clipboard copied[/dim]")
-        except Exception:
-            log_console.print("[dim]⚠️ Clipboard unavailable (skipped copy)[/dim]")
-    
-    if stdout:
-        print(final_output)
-    elif save:
-        out_path = root_path / ".codigest" / "semdiff.txt"
-        out_path.parent.mkdir(exist_ok=True)
-        out_path.write_text(final_output, encoding="utf-8")
-        log_console.print(f"[dim]Saved to {out_path}[/dim]")
+    def _save():
+        if save:
+            out_path = root_path / ".codigest" / "semdiff.txt"
+            out_path.parent.mkdir(exist_ok=True)
+            out_path.write_text(final_output, encoding="utf-8")
+            log_console.print(f"[dim]Saved to {out_path}[/dim]")
+
+    handler.handle_output(final_output, save_action=_save, item_name="semdiff")

{codigest-0.3.6 → codigest-0.3.8}/src/codigest/commands/tree.py

@@ -1,14 +1,14 @@
 import typer
 from pathlib import Path
-from rich.console import Console
 from rich.tree import Tree
 from rich.text import Text
 from rich.filesize import decimal
 
-from ..core import common
+from ..options import CopyOption, StdoutOption, ResolveOption, AllOption
+from ..core import common, structure
+from ..core.output import OutputHandler
 
 app = typer.Typer()
-console = Console()
 
 def _build_rich_tree(root_path: Path, files: list[Path]) -> Tree:
     # (기존의 이모티콘 없는 버전 로직 유지)
@@ -16,7 +16,6 @@ def _build_rich_tree(root_path: Path, files: list[Path]) -> Tree:
     dir_nodes = {root_path: tree}
 
     for path in files:
-        # (중략: 기존 트리 생성 로직)
         # External path 처리 (루트 밖의 파일)
         try:
             relative = path.relative_to(root_path)
@@ -54,12 +53,17 @@ def _build_rich_tree(root_path: Path, files: list[Path]) -> Tree:
 @app.callback(invoke_without_command=True)
 def handle(
     target: Path = typer.Argument(Path.cwd(), help="Target directory"),
-    all: bool = typer.Option(False, "--all", "-a", help="Ignore config filters"),
-    resolve: bool = typer.Option(False, "-r", "--resolve", help="Recursively resolve imports"),
+    copy: CopyOption = False,
+    stdout: StdoutOption = False,
+    all: AllOption = False,
+    resolve: ResolveOption = False,
 ):
     """
     [Visual] Print the project directory tree.
     """
+    handler = OutputHandler(stdout=stdout, copy=copy)
+    log_console = handler.log_console
+
     # 1. Context 생성 (루트 찾기용)
     ctx = common.get_context(target)
     root_path = ctx.root_path
@@ -69,14 +73,19 @@ def handle(
         # [수정] targets=[target]을 명시적으로 전달해야 해당 폴더만 스캔함
         files = ctx.get_target_files(targets=[target], ignore_config=all, resolve_deps=resolve)
     except Exception as e:
-        console.print(f"[red][Error] Scan failed:[/red] {e}")
+        log_console.print(f"[red][Error] Scan failed:[/red] {e}")
         raise typer.Exit(code=1)
 
     if not files:
-        console.print("[yellow][Warning] No matching files found.[/yellow]")
+        log_console.print("[yellow][Warning] No matching files found.[/yellow]")
         return
 
     # 3. Visualize
-    tree_viz = _build_rich_tree(root_path, files)
-    console.print(tree_viz)
-    console.print(f"\n[dim]Found {len(files)} files.[/dim]")
+    ascii_tree = structure.generate_ascii_tree(files, root_path)
+    
+    def _print_tree_viz():
+        tree_viz = _build_rich_tree(root_path, files)
+        log_console.print(tree_viz)
+        log_console.print(f"\n[dim]Found {len(files)} files.[/dim]")
+
+    handler.handle_output(ascii_tree, save_action=_print_tree_viz, item_name="tree")

codigest-0.3.8/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.8/src/codigest/core/output.py

@@ -0,0 +1,50 @@
+"""
+Unified Output Handler for CLI commands.
+Manages stderr log console, clipboard copying, and file vs stdout output.
+"""
+from dataclasses import dataclass
+from typing import Callable, Optional
+import pyperclip
+from rich.console import Console
+
+console = Console()
+err_console = Console(stderr=True)
+
+@dataclass
+class OutputHandler:
+    stdout: bool = False
+    copy: bool = True
+
+    @property
+    def log_console(self) -> Console:
+        """
+        Returns err_console (stderr) when output is directed to stdout,
+        ensuring progress/logs do not pollute stdout pipelines.
+        """
+        return err_console if self.stdout else console
+
+    def copy_to_clipboard(self, content: str, item_name: str = "output"):
+        """Copies content to clipboard safely."""
+        if not self.copy:
+            return
+        try:
+            pyperclip.copy(content)
+            self.log_console.print(f"[dim]📋 Copied {item_name} to clipboard[/dim]")
+        except Exception:
+            self.log_console.print("[dim]⚠️ Clipboard unavailable (skipped copy)[/dim]")
+
+    def handle_output(
+        self, 
+        content: str, 
+        save_action: Optional[Callable[[], None]] = None,
+        item_name: str = "output"
+    ):
+        """
+        Executes clipboard copy, stdout print, or file save action cleanly.
+        """
+        self.copy_to_clipboard(content, item_name=item_name)
+
+        if self.stdout:
+            print(content)
+        elif save_action:
+            save_action()

{codigest-0.3.6 → codigest-0.3.8}/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.8/src/codigest/options.py

@@ -0,0 +1,31 @@
+"""
+Centralized CLI Options & Common Annotated Types.
+"""
+from typing import Annotated
+import typer
+
+# Common CLI Option Types using typing.Annotated
+CopyOption = Annotated[
+    bool, 
+    typer.Option("-c", "--copy/--no-copy", help="Auto-copy output to clipboard")
+]
+
+StdoutOption = Annotated[
+    bool, 
+    typer.Option("-s", "--stdout", help="Print output to terminal (stdout) instead of file")
+]
+
+ResolveOption = Annotated[
+    bool, 
+    typer.Option("-r", "--resolve", help="Recursively resolve imports")
+]
+
+MessageOption = Annotated[
+    str, 
+    typer.Option("-m", "--message", help="Add specific instruction context")
+]
+
+AllOption = Annotated[
+    bool,
+    typer.Option("-a", "--all", help="Ignore config filters")
+]

{codigest-0.3.6 → codigest-0.3.8}/uv.lock

@@ -16,7 +16,7 @@ wheels = [
 
 [[package]]
 name = "codigest"
-version = "0.3.6"
+version = "0.3.8"
 source = { editable = "." }
 dependencies = [
     { name = "loguru" },

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