docker-diff 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

{docker_diff-0.0.5.dist-info → docker_diff-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docker-diff
-Version: 0.0.5
+Version: 0.0.7
 Summary: Docker Image Comparison Database Manager
 License: This is free and unencumbered software released into the public domain.
         
@@ -30,4 +30,5 @@ License: This is free and unencumbered software released into the public domain.
 Project-URL: Repository, https://github.com/eapolinario/docker-diff
 Requires-Python: >=3.10
 License-File: LICENSE
+Requires-Dist: libsql-client>=0.3
 Dynamic: license-file

docker_diff-0.0.7.dist-info/RECORD

@@ -0,0 +1,10 @@
+docker_diff-0.0.7.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+docker_diff_pkg/__init__.py,sha256=aG5WUO74Z5ax04A5iwh6thCpHcFXBsdH5v-ph-uUJuI,321
+docker_diff_pkg/_version.py,sha256=AV58KqMkBGaCvmPdbd3g9huyNXfIVxjw8QbCMdaeivU,704
+docker_diff_pkg/cli.py,sha256=C6LYpgFGmiZsBZ8MO4TJKmtKMvg1EqB6qYlpilbq6pI,21549
+docker_diff_pkg/schema.sql,sha256=xI3kOohbUEzwFhmIGQs2_abN_tJn1BBdAya7tVbw6n8,5477
+docker_diff-0.0.7.dist-info/METADATA,sha256=na6gAxdT1d2_cZeuQMqfFEu9k7gqUKhPPm-wGGRBr8c,1688
+docker_diff-0.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+docker_diff-0.0.7.dist-info/entry_points.txt,sha256=nEDTWZsgB5fRJgeXHJbXJyaHKMmKyN9Qypf3X78tosw,57
+docker_diff-0.0.7.dist-info/top_level.txt,sha256=GB5Qrc3AH1pk0543cQz9SRNr5Fatrj-c0Cdp3rCvTM8,16
+docker_diff-0.0.7.dist-info/RECORD,,

docker_diff_pkg/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.5'
-__version_tuple__ = version_tuple = (0, 0, 5)
+__version__ = version = '0.0.7'
+__version_tuple__ = version_tuple = (0, 0, 7)
 
 __commit_id__ = commit_id = None

docker_diff_pkg/cli.py

@@ -2,6 +2,7 @@
 """
 Docker Image Comparison Database Manager
 Provides functions to store and query Docker image file comparison results in SQLite
+Supports local SQLite via `sqlite3` and remote Turso via `libsql`.
 """
 
 import sqlite3
@@ -10,72 +11,211 @@ import subprocess
 import sys
 from datetime import datetime
 from pathlib import Path
-from typing import List, Dict, Optional, Tuple
+from typing import List, Dict, Optional, Tuple, Any
+import os
+
+try:
+    # Optional: Turso/libsql client for remote DB (sync wrapper)
+    from libsql_client.sync import create_client_sync  # type: ignore
+except Exception:  # pragma: no cover - optional dependency
+    create_client_sync = None  # type: ignore
 
 class DockerImageDB:
     def __init__(self, db_path: str = "docker_images.db"):
+        """
+        Initialize DB access. If environment variables for Turso/libsql are set,
+        connect to the remote database. Otherwise, use local SQLite file.
+
+        Env vars recognized (first found wins):
+        - TURSO_DATABASE_URL / LIBSQL_URL
+        - TURSO_AUTH_TOKEN   / LIBSQL_AUTH_TOKEN
+        """
         self.db_path = db_path
+
+        # Detect remote libsql configuration via env vars
+        self.libsql_url = os.getenv("TURSO_DATABASE_URL") or os.getenv("LIBSQL_URL")
+        self.libsql_token = os.getenv("TURSO_AUTH_TOKEN") or os.getenv("LIBSQL_AUTH_TOKEN")
+        self.use_libsql = bool(self.libsql_url)
+
+        self.client = None
+        if self.use_libsql:
+            if create_client_sync is None:
+                raise RuntimeError(
+                    "libsql-client is not installed but LIBSQL/TURSO env vars are set. "
+                    "Install dependency or unset the env vars."
+                )
+            # Create libsql client
+            self.client = create_client_sync(url=self.libsql_url, auth_token=self.libsql_token)
+
         self.init_database()
     
+    def close(self) -> None:
+        """Close any remote DB client resources."""
+        try:
+            if self.use_libsql and self.client is not None and hasattr(self.client, "close"):
+                # ClientSync.close() is synchronous
+                self.client.close()  # type: ignore[call-arg]
+        except Exception:
+            # Best-effort shutdown; avoid masking exit with close errors
+            pass
+    
     def init_database(self):
-        """Initialize the database with schema"""
-        with sqlite3.connect(self.db_path) as conn:
-            # Read schema using importlib.resources for proper packaging
-            try:
-                import importlib.resources as pkg_resources
-                with pkg_resources.files('docker_diff_pkg').joinpath('schema.sql').open('r') as f:
-                    schema_content = f.read()
-            except (ImportError, AttributeError):
-                # Fallback for Python < 3.9
-                import importlib_resources as pkg_resources
-                with pkg_resources.files('docker_diff_pkg').joinpath('schema.sql').open('r') as f:
-                    schema_content = f.read()
-            
-            conn.executescript(schema_content)
+        """Initialize the database with schema for either backend"""
+        # Read schema using importlib.resources for proper packaging
+        try:
+            import importlib.resources as pkg_resources
+            with pkg_resources.files('docker_diff_pkg').joinpath('schema.sql').open('r') as f:
+                schema_content = f.read()
+        except (ImportError, AttributeError):
+            # Fallback for Python < 3.9
+            import importlib_resources as pkg_resources
+            with pkg_resources.files('docker_diff_pkg').joinpath('schema.sql').open('r') as f:
+                schema_content = f.read()
+
+        self._executescript(schema_content)
+
+    # ---- Internal helpers to abstract DB backend ----
+    class _Result:
+        def __init__(self, rows: List[Tuple[Any, ...]] | None = None, columns: List[str] | None = None, last_row_id: Optional[int] = None):
+            self.rows = rows or []
+            self.columns = columns or []
+            self.last_row_id = last_row_id
+
+    def _to_tuples(self, rows: Any) -> List[Tuple[Any, ...]]:
+        """Normalize libsql rows (list[list|tuple|dict]) to list of tuples."""
+        if rows is None:
+            return []
+        if not rows:
+            return []
+        first = rows[0]
+        if isinstance(first, dict):
+            # Keep insertion order of dict; assume all rows share keys order
+            return [tuple(r.values()) for r in rows]
+        if isinstance(first, (list, tuple)):
+            return [tuple(r) for r in rows]
+        # Fallback single column scalar rows
+        return [(r,) for r in rows]
+
+    def _exec(self, sql: str, params: Tuple[Any, ...] | List[Any] | None = None) -> "DockerImageDB._Result":
+        if self.use_libsql:
+            res = self.client.execute(sql, params or [])  # type: ignore[attr-defined]
+            # libsql ResultSet rows are Row objects; convert to tuples
+            rs_rows = getattr(res, "rows", [])
+            rows: List[Tuple[Any, ...]] = []
+            for r in rs_rows:
+                if hasattr(r, "astuple"):
+                    rows.append(tuple(r.astuple()))  # type: ignore[attr-defined]
+                elif isinstance(r, (list, tuple)):
+                    rows.append(tuple(r))
+                else:
+                    # Sequence fallback
+                    try:
+                        rows.append(tuple(r))  # type: ignore[arg-type]
+                    except Exception:
+                        rows.append((r,))
+            columns = list(getattr(res, "columns", []) or [])
+            last_row_id = getattr(res, "last_insert_rowid", None)
+            return DockerImageDB._Result(rows, columns, last_row_id)
+        else:
+            with sqlite3.connect(self.db_path) as conn:
+                cur = conn.cursor()
+                if params is None:
+                    cur.execute(sql)
+                else:
+                    cur.execute(sql, params)
+                rows = cur.fetchall() if cur.description else []
+                columns = [d[0] for d in cur.description] if cur.description else []
+                return DockerImageDB._Result(rows, columns, cur.lastrowid)
+
+    def _executemany(self, sql: str, seq_params: List[Tuple[Any, ...]]):
+        if not seq_params:
+            return
+        if self.use_libsql:
+            # Execute sequentially for compatibility
+            for p in seq_params:
+                self.client.execute(sql, list(p))  # type: ignore[attr-defined]
+        else:
+            with sqlite3.connect(self.db_path) as conn:
+                cur = conn.cursor()
+                cur.executemany(sql, seq_params)
+
+    def _executescript(self, script: str):
+        if self.use_libsql:
+            # Split naive on ';' and run statements; ignore empty
+            statements = [s.strip() for s in script.split(';') if s.strip()]
+            for stmt in statements:
+                self.client.execute(stmt)  # type: ignore[attr-defined]
+        else:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.executescript(script)
     
     def add_image(self, name: str, digest: str = None, size_bytes: int = None) -> int:
         """Add an image to the database, return image_id"""
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("""
-                INSERT OR IGNORE INTO images (name, digest, size_bytes) 
-                VALUES (?, ?, ?)
-            """, (name, digest, size_bytes))
-            
-            # Get the image ID
-            cursor.execute("SELECT id FROM images WHERE name = ?", (name,))
-            return cursor.fetchone()[0]
+        self._exec(
+            """
+            INSERT OR IGNORE INTO images (name, digest, size_bytes) 
+            VALUES (?, ?, ?)
+            """,
+            (name, digest, size_bytes),
+        )
+        row = self._exec("SELECT id FROM images WHERE name = ?", (name,)).rows
+        return int(row[0][0]) if row else -1
     
     def add_files_for_image(self, image_id: int, files: List[Dict]):
         """Add file listings for an image"""
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            
-            # Clear existing files for this image
-            cursor.execute("DELETE FROM files WHERE image_id = ?", (image_id,))
-            
-            # Insert new files
-            file_data = []
-            for file_info in files:
-                file_data.append((
-                    image_id,
-                    file_info['path'],
-                    file_info.get('size', 0),
-                    file_info.get('mode'),
-                    file_info.get('mtime'),
-                    file_info.get('type', 'file'),
-                    file_info.get('checksum')
-                ))
-            
-            cursor.executemany("""
-                INSERT INTO files 
-                (image_id, file_path, file_size, file_mode, modified_time, file_type, checksum)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-            """, file_data)
+        # Clear existing files for this image
+        self._exec("DELETE FROM files WHERE image_id = ?", (image_id,))
+
+        # Insert new files
+        file_data: List[Tuple[Any, ...]] = []
+        for file_info in files:
+            file_data.append((
+                image_id,
+                file_info['path'],
+                file_info.get('size', 0),
+                file_info.get('mode'),
+                file_info.get('mtime'),
+                file_info.get('type', 'file'),
+                file_info.get('checksum')
+            ))
+
+        self._executemany(
+            """
+            INSERT INTO files 
+            (image_id, file_path, file_size, file_mode, modified_time, file_type, checksum)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            file_data,
+        )
     
-    def scan_image(self, image_name: str) -> int:
+    def scan_image(self, image_name: str, force: bool = False) -> int:
         """Scan a Docker image and store its files"""
         print(f"Scanning {image_name}...")
+
+        # Helper to parse tag safely: consider last ':' after last '/'
+        def _get_tag(name: str) -> str:
+            slash_idx = name.rfind('/')
+            colon_idx = name.rfind(':')
+            if colon_idx > slash_idx:
+                return name[colon_idx + 1 :]
+            return 'latest'
+
+        # If image already exists with files and tag is not 'latest', skip re-scan
+        tag = _get_tag(image_name).lower() if image_name else 'latest'
+        if not force and tag != 'latest':
+            rows = self._exec(
+                """
+                SELECT i.id, COUNT(f.id) as file_count
+                FROM images i
+                LEFT JOIN files f ON i.id = f.image_id
+                WHERE i.name = ?
+                GROUP BY i.id
+                """,
+                (image_name,),
+            ).rows
+            if rows and rows[0][1] and int(rows[0][1]) > 0:
+                print(f"  Skipping re-scan for {image_name} (already in DB with files)")
+                return int(rows[0][0])
         
         # Add image to database
         image_id = self.add_image(image_name)
@@ -108,25 +248,31 @@ class DockerImageDB:
     
     def create_comparison(self, name: str, description: str = None) -> int:
         """Create a new comparison session"""
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("""
-                INSERT INTO comparisons (name, description) 
-                VALUES (?, ?)
-            """, (name, description))
-            return cursor.lastrowid
+        res = self._exec(
+            """
+            INSERT INTO comparisons (name, description) 
+            VALUES (?, ?)
+            """,
+            (name, description),
+        )
+        if self.use_libsql:
+            # Fetch id via last row if needed
+            row = self._exec("SELECT id FROM comparisons WHERE name = ? ORDER BY id DESC LIMIT 1", (name,)).rows
+            return int(row[0][0]) if row else -1
+        return int(res.last_row_id or -1)
     
     def add_images_to_comparison(self, comparison_id: int, image_ids: List[int]):
         """Add images to a comparison"""
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            for image_id in image_ids:
-                cursor.execute("""
-                    INSERT OR IGNORE INTO comparison_images (comparison_id, image_id)
-                    VALUES (?, ?)
-                """, (comparison_id, image_id))
+        for image_id in image_ids:
+            self._exec(
+                """
+                INSERT OR IGNORE INTO comparison_images (comparison_id, image_id)
+                VALUES (?, ?)
+                """,
+                (comparison_id, image_id),
+            )
     
-    def compare_images(self, image_names: List[str], comparison_name: str = None) -> int:
+    def compare_images(self, image_names: List[str], comparison_name: str = None, *, force: bool = False) -> int:
         """Compare multiple images and store results"""
         if not comparison_name:
             comparison_name = f"Comparison_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
@@ -134,7 +280,7 @@ class DockerImageDB:
         # Scan all images
         image_ids = []
         for image_name in image_names:
-            image_id = self.scan_image(image_name)
+            image_id = self.scan_image(image_name, force=force)
             image_ids.append(image_id)
         
         # Create comparison
@@ -153,86 +299,93 @@ class DockerImageDB:
     
     def _generate_file_differences(self, comparison_id: int):
         """Generate file difference records for a comparison"""
-        with sqlite3.connect(self.db_path) as conn:
-            conn.execute("""
-                INSERT INTO file_differences 
-                (comparison_id, file_path, difference_type, source_image_id, target_image_id, old_size, new_size, size_change)
-                SELECT 
-                    ? as comparison_id,
-                    f1.file_path,
-                    CASE 
-                        WHEN f2.file_path IS NULL THEN 'only_in_first'
-                        WHEN f1.file_size != f2.file_size THEN 'changed'
-                        ELSE 'common'
-                    END as difference_type,
-                    f1.image_id as source_image_id,
-                    f2.image_id as target_image_id,
-                    f1.file_size as old_size,
-                    f2.file_size as new_size,
-                    COALESCE(f2.file_size - f1.file_size, -f1.file_size) as size_change
-                FROM files f1
-                JOIN comparison_images ci1 ON f1.image_id = ci1.image_id
-                LEFT JOIN files f2 ON f1.file_path = f2.file_path 
-                    AND f2.image_id IN (
-                        SELECT ci2.image_id FROM comparison_images ci2 
-                        WHERE ci2.comparison_id = ? AND ci2.image_id != f1.image_id
-                    )
-                WHERE ci1.comparison_id = ?
-            """, (comparison_id, comparison_id, comparison_id))
+        self._exec(
+            """
+            INSERT INTO file_differences 
+            (comparison_id, file_path, difference_type, source_image_id, target_image_id, old_size, new_size, size_change)
+            SELECT 
+                ? as comparison_id,
+                f1.file_path,
+                CASE 
+                    WHEN f2.file_path IS NULL THEN 'only_in_first'
+                    WHEN f1.file_size != f2.file_size THEN 'changed'
+                    ELSE 'common'
+                END as difference_type,
+                f1.image_id as source_image_id,
+                f2.image_id as target_image_id,
+                f1.file_size as old_size,
+                f2.file_size as new_size,
+                COALESCE(f2.file_size - f1.file_size, -f1.file_size) as size_change
+            FROM files f1
+            JOIN comparison_images ci1 ON f1.image_id = ci1.image_id
+            LEFT JOIN files f2 ON f1.file_path = f2.file_path 
+                AND f2.image_id IN (
+                    SELECT ci2.image_id FROM comparison_images ci2 
+                    WHERE ci2.comparison_id = ? AND ci2.image_id != f1.image_id
+                )
+            WHERE ci1.comparison_id = ?
+            """,
+            (comparison_id, comparison_id, comparison_id),
+        )
     
     def get_comparison_summary(self, comparison_id: int) -> Dict:
         """Get summary statistics for a comparison"""
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            
-            # Get basic info
-            cursor.execute("""
-                SELECT c.name, c.description, c.created_at,
-                       GROUP_CONCAT(i.name, ', ') as images
-                FROM comparisons c
-                JOIN comparison_images ci ON c.id = ci.comparison_id
-                JOIN images i ON ci.image_id = i.id
-                WHERE c.id = ?
-                GROUP BY c.id
-            """, (comparison_id,))
-            
-            basic_info = cursor.fetchone()
-            if not basic_info:
-                return {}
-            
-            # Get difference counts
-            cursor.execute("""
-                SELECT difference_type, COUNT(*) as count
-                FROM file_differences
-                WHERE comparison_id = ?
-                GROUP BY difference_type
-            """, (comparison_id,))
-            
-            diff_counts = dict(cursor.fetchall())
-            
-            return {
-                'name': basic_info[0],
-                'description': basic_info[1],
-                'created_at': basic_info[2],
-                'images': basic_info[3].split(', '),
-                'differences': diff_counts,
-                'total_differences': sum(diff_counts.values())
-            }
+        # Get basic info
+        basic_rows = self._exec(
+            """
+            SELECT c.name, c.description, c.created_at,
+                   GROUP_CONCAT(i.name, ', ') as images
+            FROM comparisons c
+            JOIN comparison_images ci ON c.id = ci.comparison_id
+            JOIN images i ON ci.image_id = i.id
+            WHERE c.id = ?
+            GROUP BY c.id
+            """,
+            (comparison_id,),
+        ).rows
+
+        if not basic_rows:
+            return {}
+
+        basic_info = basic_rows[0]
+
+        # Get difference counts
+        diff_rows = self._exec(
+            """
+            SELECT difference_type, COUNT(*) as count
+            FROM file_differences
+            WHERE comparison_id = ?
+            GROUP BY difference_type
+            """,
+            (comparison_id,),
+        ).rows
+
+        diff_counts = {k: v for (k, v) in diff_rows}
+
+        return {
+            'name': basic_info[0],
+            'description': basic_info[1],
+            'created_at': basic_info[2],
+            'images': basic_info[3].split(', '),
+            'differences': diff_counts,
+            'total_differences': sum(diff_counts.values()) if diff_counts else 0,
+        }
     
     def query_unique_files(self, comparison_id: int) -> List[Tuple]:
         """Get files unique to each image in comparison"""
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("""
-                SELECT i.name as image_name, f.file_path, f.file_size
-                FROM unique_files uf
-                JOIN comparisons c ON uf.comparison_name = c.name
-                JOIN images i ON uf.image_name = i.name
-                JOIN files f ON i.id = f.image_id AND uf.file_path = f.file_path
-                WHERE c.id = ?
-                ORDER BY i.name, f.file_size DESC
-            """, (comparison_id,))
-            return cursor.fetchall()
+        rows = self._exec(
+            """
+            SELECT i.name as image_name, f.file_path, f.file_size
+            FROM unique_files uf
+            JOIN comparisons c ON uf.comparison_name = c.name
+            JOIN images i ON uf.image_name = i.name
+            JOIN files f ON i.id = f.image_id AND uf.file_path = f.file_path
+            WHERE c.id = ?
+            ORDER BY i.name, f.file_size DESC
+            """,
+            (comparison_id,),
+        ).rows
+        return rows
 
 
 def print_comparison_summary(db: DockerImageDB, comparison_id: int):
@@ -265,67 +418,63 @@ def print_comparison_summary(db: DockerImageDB, comparison_id: int):
 
 def list_comparisons(db: DockerImageDB):
     """List all comparisons in the database"""
-    with sqlite3.connect(db.db_path) as conn:
-        cursor = conn.cursor()
-        cursor.execute("""
-            SELECT 
-                c.id,
-                c.name,
-                c.created_at,
-                COUNT(DISTINCT ci.image_id) as image_count,
-                GROUP_CONCAT(i.name, ', ') as images
-            FROM comparisons c
-            JOIN comparison_images ci ON c.id = ci.comparison_id
-            JOIN images i ON ci.image_id = i.id
-            GROUP BY c.id
-            ORDER BY c.created_at DESC
-        """)
-        
-        comparisons = cursor.fetchall()
-        
-        if not comparisons:
-            print("No comparisons found in database.")
-            return
-        
-        print(f"\n{'ID':<4} {'Name':<25} {'Images':<8} {'Date':<20} {'Image Names'}")
-        print("-" * 80)
-        
-        for comp_id, name, created, img_count, img_names in comparisons:
-            # Truncate long image names
-            if len(img_names) > 35:
-                img_names = img_names[:32] + "..."
-            print(f"{comp_id:<4} {name[:24]:<25} {img_count:<8} {created[:19]:<20} {img_names}")
+    rows = db._exec(
+        """
+        SELECT 
+            c.id,
+            c.name,
+            c.created_at,
+            COUNT(DISTINCT ci.image_id) as image_count,
+            GROUP_CONCAT(i.name, ', ') as images
+        FROM comparisons c
+        JOIN comparison_images ci ON c.id = ci.comparison_id
+        JOIN images i ON ci.image_id = i.id
+        GROUP BY c.id
+        ORDER BY c.created_at DESC
+        """,
+    ).rows
+
+    if not rows:
+        print("No comparisons found in database.")
+        return
+
+    print(f"\n{'ID':<4} {'Name':<25} {'Images':<8} {'Date':<20} {'Image Names'}")
+    print("-" * 80)
+
+    for comp_id, name, created, img_count, img_names in rows:
+        # Truncate long image names
+        if img_names and len(img_names) > 35:
+            img_names = img_names[:32] + "..."
+        print(f"{comp_id:<4} {name[:24]:<25} {img_count:<8} {created[:19]:<20} {img_names}")
 
 
 def list_images(db: DockerImageDB):
     """List all images in the database"""
-    with sqlite3.connect(db.db_path) as conn:
-        cursor = conn.cursor()
-        cursor.execute("""
-            SELECT 
-                i.id,
-                i.name,
-                i.scanned_at,
-                COUNT(f.id) as file_count,
-                COALESCE(SUM(f.file_size), 0) as total_size
-            FROM images i
-            LEFT JOIN files f ON i.id = f.image_id
-            GROUP BY i.id
-            ORDER BY i.scanned_at DESC
-        """)
-        
-        images = cursor.fetchall()
-        
-        if not images:
-            print("No images found in database.")
-            return
-        
-        print(f"\n{'ID':<4} {'Image Name':<30} {'Files':<8} {'Size (MB)':<12} {'Scanned'}")
-        print("-" * 80)
-        
-        for img_id, name, scanned, file_count, total_size in images:
-            size_mb = total_size / (1024 * 1024) if total_size else 0
-            print(f"{img_id:<4} {name[:29]:<30} {file_count:<8} {size_mb:<12.2f} {scanned[:19] if scanned else 'Never'}")
+    rows = db._exec(
+        """
+        SELECT 
+            i.id,
+            i.name,
+            i.scanned_at,
+            COUNT(f.id) as file_count,
+            COALESCE(SUM(f.file_size), 0) as total_size
+        FROM images i
+        LEFT JOIN files f ON i.id = f.image_id
+        GROUP BY i.id
+        ORDER BY i.scanned_at DESC
+        """,
+    ).rows
+
+    if not rows:
+        print("No images found in database.")
+        return
+
+    print(f"\n{'ID':<4} {'Image Name':<30} {'Files':<8} {'Size (MB)':<12} {'Scanned'}")
+    print("-" * 80)
+
+    for img_id, name, scanned, file_count, total_size in rows:
+        size_mb = total_size / (1024 * 1024) if total_size else 0
+        print(f"{img_id:<4} {name[:29]:<30} {file_count:<8} {size_mb:<12.2f} {scanned[:19] if scanned else 'Never'}")
 
 
 def show_unique_files(db: DockerImageDB, comparison_id: int, limit: int = 20):
@@ -349,10 +498,10 @@ def show_unique_files(db: DockerImageDB, comparison_id: int, limit: int = 20):
 
 def _cmd_scan(db: DockerImageDB, args):
     for image in args.images:
-        db.scan_image(image)
+        db.scan_image(image, force=args.force)
 
 def _cmd_compare(db: DockerImageDB, args):
-    comparison_id = db.compare_images(args.images, args.name)
+    comparison_id = db.compare_images(args.images, args.name, force=args.force)
     print_comparison_summary(db, comparison_id)
 
 def _cmd_list_images(db: DockerImageDB, args):
@@ -377,11 +526,13 @@ def main():
 
     p_scan = sub.add_parser("scan", help="Scan one or more images and store file listings")
     p_scan.add_argument("images", nargs="+", help="Docker image names (e.g., ubuntu:22.04)")
+    p_scan.add_argument("--force", action="store_true", help="Re-scan even if image exists in DB (overrides skip)")
     p_scan.set_defaults(func=_cmd_scan)
 
     p_compare = sub.add_parser("compare", help="Compare images and store results")
     p_compare.add_argument("images", nargs="+", help="Docker image names to compare")
     p_compare.add_argument("--name", help="Optional comparison name")
+    p_compare.add_argument("--force", action="store_true", help="Re-scan images even if they exist in DB")
     p_compare.set_defaults(func=_cmd_compare)
 
     p_list = sub.add_parser("list", help="List images or comparisons")
@@ -404,8 +555,11 @@ def main():
 
     args = parser.parse_args()
     db = DockerImageDB()
-    args.func(db, args)
+    try:
+        args.func(db, args)
+    finally:
+        db.close()
 
 
 if __name__ == "__main__":
-    main()
+    main()

docker_diff-0.0.5.dist-info/RECORD

@@ -1,10 +0,0 @@
-docker_diff-0.0.5.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
-docker_diff_pkg/__init__.py,sha256=aG5WUO74Z5ax04A5iwh6thCpHcFXBsdH5v-ph-uUJuI,321
-docker_diff_pkg/_version.py,sha256=YRV1ohn6CdKEhsUOmFFMmr5UTjMv4Ydw3WJGxF2BHBs,704
-docker_diff_pkg/cli.py,sha256=iXC5GR1jCzhmJpFCSJHSujL3vdAkXQOpeOtBJYGQy_A,15983
-docker_diff_pkg/schema.sql,sha256=xI3kOohbUEzwFhmIGQs2_abN_tJn1BBdAya7tVbw6n8,5477
-docker_diff-0.0.5.dist-info/METADATA,sha256=MXmyyswAGtc-NNGNjoIwWADT2W_a2XKPseLvz__jHj0,1654
-docker_diff-0.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-docker_diff-0.0.5.dist-info/entry_points.txt,sha256=nEDTWZsgB5fRJgeXHJbXJyaHKMmKyN9Qypf3X78tosw,57
-docker_diff-0.0.5.dist-info/top_level.txt,sha256=GB5Qrc3AH1pk0543cQz9SRNr5Fatrj-c0Cdp3rCvTM8,16
-docker_diff-0.0.5.dist-info/RECORD,,