thailint 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

src/cli.py

@@ -363,7 +363,7 @@ def config_reset(ctx, yes: bool):
 
 
 @cli.command("file-placement")
-@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
 @click.option("--rules", "-r", help="Inline JSON rules configuration")
 @format_option
@@ -432,6 +432,7 @@ def _execute_file_placement_lint(  # pylint: disable=too-many-arguments,too-many
     path_objs, config_file, rules, format, recursive, verbose
 ):
     """Execute file placement linting."""
+    _validate_paths_exist(path_objs)
     orchestrator = _setup_orchestrator(path_objs, config_file, rules, verbose)
     all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
 
@@ -453,6 +454,28 @@ def _handle_linting_error(error: Exception, verbose: bool) -> None:
     sys.exit(2)
 
 
+def _validate_paths_exist(path_objs: list[Path]) -> None:
+    """Validate that all provided paths exist.
+
+    Args:
+        path_objs: List of Path objects to validate
+
+    Raises:
+        SystemExit: If any path doesn't exist (exit code 2)
+    """
+    for path in path_objs:
+        if not path.exists():
+            click.echo(f"Error: Path does not exist: {path}", err=True)
+            click.echo("", err=True)
+            click.echo(
+                "Hint: When using Docker, ensure paths are inside the mounted volume:", err=True
+            )
+            click.echo(
+                "  docker run -v $(pwd):/data thailint <command> /data/your-file.py", err=True
+            )
+            sys.exit(2)
+
+
 def _find_project_root(start_path: Path) -> Path:
     """Find project root by looking for .git or pyproject.toml.
 
@@ -637,7 +660,7 @@ def _run_nesting_lint(orchestrator, path_objs: list[Path], recursive: bool):
 
 
 @cli.command("nesting")
-@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
 @format_option
 @click.option("--max-depth", type=int, help="Override max nesting depth (default: 4)")
@@ -710,6 +733,7 @@ def _execute_nesting_lint(  # pylint: disable=too-many-arguments,too-many-positi
     path_objs, config_file, format, max_depth, recursive, verbose
 ):
     """Execute nesting lint."""
+    _validate_paths_exist(path_objs)
     orchestrator = _setup_nesting_orchestrator(path_objs, config_file, verbose)
     _apply_nesting_config_override(orchestrator, max_depth, verbose)
     nesting_violations = _run_nesting_lint(orchestrator, path_objs, recursive)
@@ -773,7 +797,7 @@ def _run_srp_lint(orchestrator, path_objs: list[Path], recursive: bool):
 
 
 @cli.command("srp")
-@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
 @format_option
 @click.option("--max-methods", type=int, help="Override max methods per class (default: 7)")
@@ -845,6 +869,7 @@ def _execute_srp_lint(  # pylint: disable=too-many-arguments,too-many-positional
     path_objs, config_file, format, max_methods, max_loc, recursive, verbose
 ):
     """Execute SRP lint."""
+    _validate_paths_exist(path_objs)
     orchestrator = _setup_srp_orchestrator(path_objs, config_file, verbose)
     _apply_srp_config_override(orchestrator, max_methods, max_loc, verbose)
     srp_violations = _run_srp_lint(orchestrator, path_objs, recursive)
@@ -857,7 +882,7 @@ def _execute_srp_lint(  # pylint: disable=too-many-arguments,too-many-positional
 
 
 @cli.command("dry")
-@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
 @format_option
 @click.option("--min-lines", type=int, help="Override min duplicate lines threshold")
@@ -943,6 +968,7 @@ def _execute_dry_lint(  # pylint: disable=too-many-arguments,too-many-positional
     path_objs, config_file, format, min_lines, no_cache, clear_cache, recursive, verbose
 ):
     """Execute DRY linting."""
+    _validate_paths_exist(path_objs)
     orchestrator = _setup_dry_orchestrator(path_objs, config_file, verbose)
     _apply_dry_config_override(orchestrator, min_lines, no_cache, verbose)
 

src/config.py

@@ -34,6 +34,10 @@ class ConfigError(Exception):
     """Configuration-related errors."""
 
 
+# Default configuration constants
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_TIMEOUT_SECONDS = 30
+
 # Default configuration values
 DEFAULT_CONFIG: dict[str, Any] = {
     "app_name": "{{PROJECT_NAME}}",
@@ -41,8 +45,8 @@ DEFAULT_CONFIG: dict[str, Any] = {
     "log_level": "INFO",
     "output_format": "text",
     "greeting": "Hello",
-    "max_retries": 3,
-    "timeout": 30,
+    "max_retries": DEFAULT_MAX_RETRIES,
+    "timeout": DEFAULT_TIMEOUT_SECONDS,
 }
 
 # Configuration file search paths (in priority order)

src/core/base.py

@@ -8,14 +8,17 @@ Overview: Establishes the contract that all linting plugins must follow through
     Defines BaseLintRule which all concrete linting rules inherit from, specifying required
     properties (rule_id, rule_name, description) and the check() method for violation detection.
     Provides BaseLintContext as the interface for accessing file information during analysis,
-    exposing file_path, file_content, and language properties. These abstractions enable the
-    rule registry to discover and instantiate rules dynamically without tight coupling, supporting
-    the extensible plugin system where new rules can be added by simply placing them in the
-    appropriate directory structure.
+    exposing file_path, file_content, and language properties. Includes MultiLanguageLintRule
+    intermediate class implementing template method pattern for language dispatch, eliminating
+    code duplication across multi-language linters (nesting, srp, magic_numbers). These
+    abstractions enable the rule registry to discover and instantiate rules dynamically without
+    tight coupling, supporting the extensible plugin system where new rules can be added by
+    simply placing them in the appropriate directory structure.
 
 Dependencies: abc for abstract base class support, pathlib for Path types, Violation from types
 
-Exports: BaseLintRule (abstract rule interface), BaseLintContext (abstract context interface)
+Exports: BaseLintRule (abstract rule interface), BaseLintContext (abstract context interface),
+    MultiLanguageLintRule (template method base for multi-language linters)
 
 Interfaces: BaseLintRule.check(context) -> list[Violation], BaseLintContext properties
     (file_path, file_content, language), all abstract methods must be implemented by subclasses
@@ -26,6 +29,7 @@ Implementation: ABC-based interface definitions with @abstractmethod decorators,
 
 from abc import ABC, abstractmethod
 from pathlib import Path
+from typing import Any
 
 from .types import Violation
 
@@ -132,3 +136,84 @@ class BaseLintRule(ABC):
             List of violations found during finalization. Empty list by default.
         """
         return []
+
+
+class MultiLanguageLintRule(BaseLintRule):
+    """Base class for linting rules that support multiple programming languages.
+
+    Provides language dispatch pattern to eliminate code duplication across multi-language
+    linters. Subclasses implement language-specific checking methods rather than handling
+    dispatch logic themselves.
+
+    Subclasses must implement:
+    - _check_python(context, config) for Python language support
+    - _check_typescript(context, config) for TypeScript/JavaScript support
+    - _load_config(context) for configuration loading
+    """
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check for violations with automatic language dispatch.
+
+        Dispatches to language-specific checking methods based on context.language.
+        Handles common patterns like file content validation and config loading.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            List of violations found
+        """
+        from .linter_utils import has_file_content
+
+        if not has_file_content(context):
+            return []
+
+        config = self._load_config(context)
+        if not config.enabled:
+            return []
+
+        if context.language == "python":
+            return self._check_python(context, config)
+
+        if context.language in ("typescript", "javascript"):
+            return self._check_typescript(context, config)
+
+        return []
+
+    @abstractmethod
+    def _load_config(self, context: BaseLintContext) -> Any:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            Configuration object with at minimum an 'enabled' attribute
+        """
+        raise NotImplementedError("Subclasses must implement _load_config")
+
+    @abstractmethod
+    def _check_python(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Check Python code for violations.
+
+        Args:
+            context: Lint context with Python file information
+            config: Loaded configuration
+
+        Returns:
+            List of violations found in Python code
+        """
+        raise NotImplementedError("Subclasses must implement _check_python")
+
+    @abstractmethod
+    def _check_typescript(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Check TypeScript/JavaScript code for violations.
+
+        Args:
+            context: Lint context with TypeScript/JavaScript file information
+            config: Loaded configuration
+
+        Returns:
+            List of violations found in TypeScript/JavaScript code
+        """
+        raise NotImplementedError("Subclasses must implement _check_typescript")

src/linters/dry/block_filter.py

@@ -23,6 +23,9 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Protocol
 
+# Default filter threshold constants
+DEFAULT_KEYWORD_ARG_THRESHOLD = 0.8
+
 
 class CodeBlock(Protocol):
     """Protocol for code blocks (matches cache.CodeBlock)."""
@@ -67,7 +70,7 @@ class KeywordArgumentFilter(BaseBlockFilter):
     These are common in builder patterns and API calls.
     """
 
-    def __init__(self, threshold: float = 0.8):
+    def __init__(self, threshold: float = DEFAULT_KEYWORD_ARG_THRESHOLD):
         """Initialize filter.
 
         Args:
@@ -256,7 +259,7 @@ def create_default_registry() -> BlockFilterRegistry:
     registry = BlockFilterRegistry()
 
     # Register built-in filters
-    registry.register(KeywordArgumentFilter(threshold=0.8))
+    registry.register(KeywordArgumentFilter(threshold=DEFAULT_KEYWORD_ARG_THRESHOLD))
     registry.register(ImportGroupFilter())
 
     return registry

src/linters/dry/cache.py

@@ -1,26 +1,27 @@
 """
-Purpose: SQLite cache manager for DRY linter with mtime-based invalidation
+Purpose: SQLite storage manager for DRY linter duplicate detection
 
-Scope: Code block storage, cache operations, and duplicate detection queries
+Scope: Code block storage and duplicate detection queries
 
-Overview: Implements persistent caching layer for duplicate code detection using SQLite database.
-    Stores code blocks with hash values, file locations, and metadata. Provides mtime-based cache
-    invalidation to detect stale entries. Serves dual purpose as both cache (avoid re-hashing) and
-    hash table (query duplicates across project). Includes indexes for fast hash lookups enabling
-    cross-file duplicate detection with minimal overhead.
+Overview: Implements in-memory or temporary-file SQLite storage for duplicate code detection.
+    Stores code blocks with hash values, file locations, and metadata during a single linter run.
+    Supports both :memory: mode (fast, RAM-only) and tempfile mode (disk-backed for large projects).
+    No persistence between runs - storage is cleared when linter completes. Includes indexes for
+    fast hash lookups enabling cross-file duplicate detection with minimal overhead.
 
-Dependencies: Python sqlite3 module (stdlib), pathlib.Path, dataclasses
+Dependencies: Python sqlite3 module (stdlib), tempfile module (stdlib), pathlib.Path, dataclasses
 
 Exports: CodeBlock dataclass, DRYCache class
 
-Interfaces: DRYCache.__init__, is_fresh, load, save, find_duplicates_by_hash, get_blocks_for_file,
-    add_blocks, cleanup_stale, close
+Interfaces: DRYCache.__init__(storage_mode), add_blocks(file_path, blocks),
+    find_duplicates_by_hash(hash_value), get_duplicate_hashes(), close()
 
 Implementation: SQLite with two tables (files, code_blocks), indexed on hash_value for performance,
-    ACID transactions for reliability, foreign key constraints for data integrity
+    storage_mode determines :memory: vs tempfile location, ACID transactions for reliability
 """
 
 import sqlite3
+import tempfile
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -39,20 +40,32 @@ class CodeBlock:
 
 
 class DRYCache:
-    """SQLite-backed cache for duplicate detection."""
+    """SQLite-backed storage for duplicate detection."""
 
     SCHEMA_VERSION = 1
 
-    def __init__(self, cache_path: Path) -> None:
-        """Initialize cache with SQLite database.
+    def __init__(self, storage_mode: str = "memory") -> None:
+        """Initialize storage with SQLite database.
 
         Args:
-            cache_path: Path to SQLite database file
+            storage_mode: Storage mode - "memory" (default) or "tempfile"
         """
-        # Ensure parent directory exists
-        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        self._storage_mode = storage_mode
+        self._tempfile = None
+
+        # Create SQLite connection based on storage mode
+        if storage_mode == "memory":
+            self.db = sqlite3.connect(":memory:")
+        elif storage_mode == "tempfile":
+            # Create temporary file that auto-deletes on close
+            # pylint: disable=consider-using-with
+            # Justification: tempfile must remain open for SQLite connection lifetime.
+            # It is explicitly closed in close() method when cache is finalized.
+            self._tempfile = tempfile.NamedTemporaryFile(suffix=".db", delete=True)
+            self.db = sqlite3.connect(self._tempfile.name)
+        else:
+            raise ValueError(f"Invalid storage_mode: {storage_mode}")
 
-        self.db = sqlite3.connect(str(cache_path))
         self._query_service = CacheQueryService()
 
         # Create schema
@@ -82,68 +95,24 @@ class DRYCache:
 
         self.db.commit()
 
-    def is_fresh(self, file_path: Path, current_mtime: float) -> bool:
-        """Check if cached data is fresh (mtime matches).
+    def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
+        """Add code blocks to storage.
 
         Args:
-            file_path: Path to file
-            current_mtime: Current modification time
-
-        Returns:
-            True if cache is fresh, False if stale or missing
-        """
-        cursor = self.db.execute("SELECT mtime FROM files WHERE file_path = ?", (str(file_path),))
-        row = cursor.fetchone()
-
-        if not row:
-            return False  # Not in cache
-
-        cached_mtime = row[0]
-        return cached_mtime == current_mtime
-
-    def load(self, file_path: Path) -> list[CodeBlock]:
-        """Load cached code blocks for file.
-
-        Args:
-            file_path: Path to file
-
-        Returns:
-            List of CodeBlock instances from cache
+            file_path: Path to source file
+            blocks: List of CodeBlock instances to store
         """
-        cursor = self.db.execute(
-            """SELECT hash_value, start_line, end_line, snippet
-               FROM code_blocks
-               WHERE file_path = ?""",
-            (str(file_path),),
-        )
-
-        blocks = []
-        for hash_val, start, end, snippet in cursor:
-            block = CodeBlock(
-                file_path=file_path,
-                start_line=start,
-                end_line=end,
-                snippet=snippet,
-                hash_value=hash_val,
-            )
-            blocks.append(block)
-
-        return blocks
-
-    def save(self, file_path: Path, mtime: float, blocks: list[CodeBlock]) -> None:
-        """Save code blocks to cache.
-
-        Args:
-            file_path: Path to file
-            mtime: File modification time
-            blocks: List of CodeBlock instances to cache
-        """
-        # Delete old data for this file
-        self.db.execute("DELETE FROM files WHERE file_path = ?", (str(file_path),))
+        if not blocks:
+            return
 
         # Insert file metadata
+        try:
+            mtime = file_path.stat().st_mtime
+        except OSError:
+            mtime = 0.0  # File doesn't exist, use placeholder
+
         self.db.execute(
-            "INSERT INTO files (file_path, mtime, hash_count) VALUES (?, ?, ?)",
+            "INSERT OR REPLACE INTO files (file_path, mtime, hash_count) VALUES (?, ?, ?)",
             (str(file_path), mtime, len(blocks)),
         )
 
@@ -164,23 +133,6 @@ class DRYCache:
 
         self.db.commit()
 
-    def cleanup_stale(self, max_age_days: int) -> None:
-        """Remove cache entries older than max_age_days.
-
-        Args:
-            max_age_days: Maximum age in days for cache entries
-        """
-        # Use parameterized query to prevent SQL injection
-        self.db.execute(
-            """DELETE FROM files
-               WHERE last_scanned < datetime('now', ? || ' days')""",
-            (f"-{max_age_days}",),
-        )
-
-        # Vacuum to reclaim space
-        self.db.execute("VACUUM")
-        self.db.commit()
-
     def find_duplicates_by_hash(self, hash_value: int) -> list[CodeBlock]:
         """Find all code blocks with the given hash value.
 
@@ -214,5 +166,7 @@ class DRYCache:
         return self._query_service.get_duplicate_hashes(self.db)
 
     def close(self) -> None:
-        """Close database connection."""
+        """Close database connection and cleanup tempfile if used."""
         self.db.close()
+        if self._tempfile:
+            self._tempfile.close()

src/linters/dry/config.py

@@ -20,6 +20,10 @@ Implementation: Dataclass with field defaults, __post_init__ validation, and dic
 from dataclasses import dataclass, field
 from typing import Any
 
+# Default configuration constants
+DEFAULT_MIN_DUPLICATE_LINES = 3
+DEFAULT_MIN_DUPLICATE_TOKENS = 30
+
 
 @dataclass
 class DRYConfig:  # pylint: disable=too-many-instance-attributes
@@ -27,14 +31,14 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
 
     Note: Pylint too-many-instance-attributes disabled. This is a configuration
     dataclass serving as a data container for related DRY linter settings.
-    All 12 attributes are cohesively related (detection thresholds, language
-    overrides, caching, filtering). Splitting would reduce cohesion and make
+    All attributes are cohesively related (detection thresholds, language
+    overrides, storage mode, filtering). Splitting would reduce cohesion and make
     configuration loading more complex without meaningful benefit.
     """
 
     enabled: bool = False  # Must be explicitly enabled
-    min_duplicate_lines: int = 3
-    min_duplicate_tokens: int = 30
+    min_duplicate_lines: int = DEFAULT_MIN_DUPLICATE_LINES
+    min_duplicate_tokens: int = DEFAULT_MIN_DUPLICATE_TOKENS
     min_occurrences: int = 2  # Minimum occurrences to report (default: 2)
 
     # Language-specific overrides
@@ -42,10 +46,8 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
     typescript_min_occurrences: int | None = None
     javascript_min_occurrences: int | None = None
 
-    # Cache settings
-    cache_enabled: bool = True  # ON by default for performance
-    cache_path: str = ".thailint-cache/dry.db"
-    cache_max_age_days: int = 30
+    # Storage settings
+    storage_mode: str = "memory"  # Options: "memory" (default) or "tempfile"
 
     # Ignore patterns
     ignore_patterns: list[str] = field(default_factory=lambda: ["tests/", "__init__.py"])
@@ -70,6 +72,10 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
             )
         if self.min_occurrences <= 0:
             raise ValueError(f"min_occurrences must be positive, got {self.min_occurrences}")
+        if self.storage_mode not in ("memory", "tempfile"):
+            raise ValueError(
+                f"storage_mode must be 'memory' or 'tempfile', got '{self.storage_mode}'"
+            )
 
     def get_min_occurrences_for_language(self, language: str) -> int:
         """Get minimum occurrences threshold for a specific language.
@@ -116,15 +122,13 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
 
         return cls(
             enabled=config.get("enabled", False),
-            min_duplicate_lines=config.get("min_duplicate_lines", 3),
-            min_duplicate_tokens=config.get("min_duplicate_tokens", 30),
+            min_duplicate_lines=config.get("min_duplicate_lines", DEFAULT_MIN_DUPLICATE_LINES),
+            min_duplicate_tokens=config.get("min_duplicate_tokens", DEFAULT_MIN_DUPLICATE_TOKENS),
             min_occurrences=config.get("min_occurrences", 2),
             python_min_occurrences=python_config.get("min_occurrences"),
             typescript_min_occurrences=typescript_config.get("min_occurrences"),
             javascript_min_occurrences=javascript_config.get("min_occurrences"),
-            cache_enabled=config.get("cache_enabled", True),
-            cache_path=config.get("cache_path", ".thailint-cache/dry.db"),
-            cache_max_age_days=config.get("cache_max_age_days", 30),
+            storage_mode=config.get("storage_mode", "memory"),
             ignore_patterns=config.get("ignore", []),
             filters=filters,
         )

src/linters/dry/duplicate_storage.py

@@ -1,12 +1,11 @@
 """
-Purpose: Storage management for duplicate code blocks with cache and memory fallback
+Purpose: Storage management for duplicate code blocks in SQLite
 
-Scope: Manages storage of code blocks in SQLite cache or in-memory dict
+Scope: Manages storage of code blocks in SQLite for duplicate detection
 
-Overview: Provides unified storage interface for code blocks supporting both SQLite-backed caching
-    and in-memory fallback when cache disabled. Handles block insertion, retrieval, and duplicate
-    hash queries. Encapsulates Decision 6 (in-memory fallback) implementation. Separates storage
-    concerns from linting logic to maintain SRP compliance.
+Overview: Provides storage interface for code blocks using SQLite (in-memory or tempfile mode).
+    Handles block insertion and duplicate hash queries. Delegates all storage operations to
+    DRYCache SQLite layer. Separates storage concerns from linting logic to maintain SRP compliance.
 
 Dependencies: DRYCache, CodeBlock, Path
 
@@ -15,7 +14,7 @@ Exports: DuplicateStorage class
 Interfaces: DuplicateStorage.add_blocks(file_path, blocks), get_duplicate_hashes(),
     get_blocks_for_hash(hash_value)
 
-Implementation: Delegates to either SQLite cache or in-memory dict based on cache_enabled setting
+Implementation: Delegates to SQLite cache for all storage operations
 """
 
 from pathlib import Path
@@ -24,82 +23,36 @@ from .cache import CodeBlock, DRYCache
 
 
 class DuplicateStorage:
-    """Manages storage of code blocks in cache or memory."""
+    """Manages storage of code blocks in SQLite."""
 
-    def __init__(self, cache: DRYCache | None) -> None:
-        """Initialize storage with optional cache.
+    def __init__(self, cache: DRYCache) -> None:
+        """Initialize storage with SQLite cache.
 
         Args:
-            cache: SQLite cache instance (None for in-memory mode)
+            cache: SQLite cache instance (in-memory or tempfile mode)
         """
         self._cache = cache
-        self._memory_store: dict[int, list[CodeBlock]] = {}
 
     def add_blocks(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Add code blocks to storage and cache.
+        """Add code blocks to SQLite storage.
 
         Args:
             file_path: Path to source file
             blocks: List of code blocks to store
         """
-        # Always add to memory for duplicate detection
-        self._add_to_memory(blocks)
-
-        # Also persist to cache if available
-        if self._cache:
-            self._add_to_cache(file_path, blocks)
-
-    def add_blocks_to_memory(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Add code blocks to in-memory storage only (for cache hits).
-
-        Args:
-            file_path: Path to source file (used for cache persistence check)
-            blocks: List of code blocks to store
-        """
-        # Add to memory for duplicate detection this run
-        self._add_to_memory(blocks)
-
-        # Guard clauses - early returns for skip conditions
-        if not self._cache:
-            return
-
-        if not blocks:
-            return
-
-        # Update cache with new blocks if needed (for fresh analysis)
-        self._update_cache_if_fresh(file_path, blocks)
-
-    def _update_cache_if_fresh(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Update cache if file analysis is fresh (not from cache).
-
-        Args:
-            file_path: Path to source file
-            blocks: List of code blocks to store
-        """
-        if not self._cache:
-            return
-
-        try:
-            mtime = file_path.stat().st_mtime
-        except OSError:
-            # File doesn't exist, skip cache
-            return
-
-        # File was analyzed (not cached), so persist if not fresh
-        if not self._cache.is_fresh(file_path, mtime):
-            self._add_to_cache(file_path, blocks)
+        if blocks:
+            self._cache.add_blocks(file_path, blocks)
 
     def get_duplicate_hashes(self) -> list[int]:
-        """Get all hash values with 2+ occurrences from memory.
+        """Get all hash values with 2+ occurrences from SQLite.
 
         Returns:
             List of hash values that appear in multiple blocks
         """
-        # Always query from in-memory store for this run's files
-        return [h for h, blocks in self._memory_store.items() if len(blocks) >= 2]
+        return self._cache.get_duplicate_hashes()
 
     def get_blocks_for_hash(self, hash_value: int) -> list[CodeBlock]:
-        """Get all blocks with given hash value from memory.
+        """Get all blocks with given hash value from SQLite.
 
         Args:
             hash_value: Hash to search for
@@ -107,20 +60,4 @@ class DuplicateStorage:
         Returns:
             List of code blocks with this hash
         """
-        # Always query from in-memory store for this run's files
-        return self._memory_store.get(hash_value, [])
-
-    def _add_to_cache(self, file_path: Path, blocks: list[CodeBlock]) -> None:
-        """Add blocks to SQLite cache."""
-        if not self._cache or not blocks:
-            return
-
-        mtime = file_path.stat().st_mtime
-        self._cache.save(file_path, mtime, blocks)
-
-    def _add_to_memory(self, blocks: list[CodeBlock]) -> None:
-        """Add blocks to in-memory store."""
-        for block in blocks:
-            if block.hash_value not in self._memory_store:
-                self._memory_store[block.hash_value] = []
-            self._memory_store[block.hash_value].append(block)
+        return self._cache.find_duplicates_by_hash(hash_value)