diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..fe278c4
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,40 @@
+repos:
+  # Ruff formatter
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.6
+    hooks:
+      - id: ruff-format
+        name: ruff format
+        description: Format Python code with ruff
+
+  # Ruff linter
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.6
+    hooks:
+      - id: ruff
+        name: ruff check --fix
+        description: Lint Python code with ruff and auto-fix issues
+        args: [--fix]
+
+  # Pyrefly type checker
+  - repo: local
+    hooks:
+      - id: pyrefly
+        name: pyrefly check
+        description: Type check Python code with pyrefly
+        entry: .venv/bin/pyrefly
+        args: [check]
+        language: system
+        types: [python]
+
+  # Pytest tests
+  - repo: local
+    hooks:
+      - id: pytest
+        name: pytest
+        description: Run tests with pytest
+        entry: .venv/bin/pytest
+        language: system
+        types: [python]
+        pass_filenames: false
+        always_run: true
diff --git a/docs/astro.config.mjs b/docs/astro.config.mjs
index 7ce8c94..95fc346 100644
--- a/docs/astro.config.mjs
+++ b/docs/astro.config.mjs
@@ -60,6 +60,7 @@ export default defineConfig({
             { label: "template", link: "/reference/cli/template/" },
             { label: "list", link: "/reference/cli/list/" },
             { label: "status", link: "/reference/cli/status/" },
+            { label: "sync", link: "/reference/cli/sync/" },
             { label: "update", link: "/reference/cli/update/" },
             { label: "add-hook", link: "/reference/cli/add-hook/" },
           ],
diff --git a/docs/src/content/docs/guides/automatic-updates.mdx b/docs/src/content/docs/guides/automatic-updates.mdx
index 73a7dd1..bff74f6 100644
--- a/docs/src/content/docs/guides/automatic-updates.mdx
+++ b/docs/src/content/docs/guides/automatic-updates.mdx
@@ -7,7 +7,7 @@ import { Aside } from "@astrojs/starlight/components";
 
 > **Note:** This guide primarily describes features beneficial for **Consumers** – those using libraries managed by a Creator. The setup of the hook itself might be done by a Creator or an advanced Consumer.
 
-KiLM provides a helper command [`kilm add-hook`](/reference/cli/add-hook/) to easily create a basic `post-merge` Git hook that runs `kilm update`.
+KiLM provides a helper command [`kilm add-hook`](/reference/cli/add-hook/) to easily create a basic `post-merge` Git hook that runs `kilm sync`.
 
 ## Using `kilm add-hook` (Recommended)
 
@@ -17,7 +17,7 @@ Navigate to the root of your Git repository containing your KiCad libraries and
 kilm add-hook
 ```
 
-This creates a `.git/hooks/post-merge` script that automatically executes `kilm update` every time you successfully run `git pull` or `git merge` in that repository.
+This creates a `.git/hooks/post-merge` script that automatically executes `kilm sync` every time you successfully run `git pull` or `git merge` in that repository.
 
 <Aside type="tip" title="Enhanced Hook Management">
   The `kilm add-hook` command now includes advanced features: - **Smart
@@ -51,13 +51,13 @@ If you prefer manual setup or want to customize the hook script further, you can
     # KiCad Library Manager auto-update hook
     # Added manually
 
-    echo "Running KiCad Library Manager update..."
-    kilm update
+    echo "Running KiCad Library Manager sync..."
+    kilm sync
 
     # Uncomment to set up libraries automatically (use with caution)
     # kilm setup
 
-    echo "KiCad libraries update complete."
+    echo "KiCad libraries sync complete."
     # END KiLM-managed section
     ```
 
@@ -72,7 +72,7 @@ If you prefer manual setup or want to customize the hook script further, you can
 When you run `git pull` or `git merge`:
 
 1.  Git executes the `post-merge` hook automatically
-2.  The hook runs `kilm update` to check for library updates
+2.  The hook runs `kilm sync` to check for library updates
 3.  If new versions are available, they are pulled from remote repositories
 4.  Your local KiCad libraries stay synchronized with the latest versions
 
diff --git a/docs/src/content/docs/guides/troubleshooting.mdx b/docs/src/content/docs/guides/troubleshooting.mdx
index e703c26..06848d3 100644
--- a/docs/src/content/docs/guides/troubleshooting.mdx
+++ b/docs/src/content/docs/guides/troubleshooting.mdx
@@ -50,6 +50,6 @@ Here are some common problems you might encounter when using KiLM and how to res
 
 ## Getting More Help
 
-- Use the `--verbose` flag with commands like `kilm setup` or `kilm update` to get more detailed output.
+- Use the `--verbose` flag with commands like `kilm setup` or `kilm sync` to get more detailed output.
 - Use `kilm status` to check the current configuration state.
 - Check the KiLM issue tracker on GitHub: [https://github.com/barisgit/kilm/issues](https://github.com/barisgit/kilm/issues) or submit a request here: [https://aristovnik.me/contact](https://aristovnik.me/contact)
diff --git a/docs/src/content/docs/reference/cli/index.mdx b/docs/src/content/docs/reference/cli/index.mdx
index dbf712c..b067da4 100644
--- a/docs/src/content/docs/reference/cli/index.mdx
+++ b/docs/src/content/docs/reference/cli/index.mdx
@@ -18,7 +18,8 @@ Each command focuses on a specific task. Below is a list of available commands.
 - [`template`](/reference/cli/template/): Create and manage KiCad project templates.
 - [`list`](/reference/cli/list/): List symbol and footprint libraries found within a specified directory.
 - [`status`](/reference/cli/status/): Check the current KiLM and KiCad configuration status.
-- [`update`](/reference/cli/update/): Update Git-based libraries using `git pull`.
-- [`add-hook`](/reference/cli/add-hook/): Add a Git post-merge hook to automatically run `kilm update`.
+- [`sync`](/reference/cli/sync/): Update Git-based libraries using `git pull`.
+- [`update`](/reference/cli/update/): Update KiLM itself to the latest version from PyPI.
+- [`add-hook`](/reference/cli/add-hook/): Add a Git post-merge hook to automatically run `kilm sync`.
 
 Use the sidebar navigation or the links above to explore each command in detail.
diff --git a/kicad_lib_manager/__init__.py b/kicad_lib_manager/__init__.py
index 0198006..b3c640c 100644
--- a/kicad_lib_manager/__init__.py
+++ b/kicad_lib_manager/__init__.py
@@ -1,3 +1,5 @@
 """
 KiCad Library Manager - Library management utilities for KiCad
 """
+
+__version__ = "0.4.0"
diff --git a/kicad_lib_manager/auto_update.py b/kicad_lib_manager/auto_update.py
new file mode 100644
index 0000000..87ef5d5
--- /dev/null
+++ b/kicad_lib_manager/auto_update.py
@@ -0,0 +1,230 @@
+"""
+Auto-update functionality for KiLM.
+Handles installation method detection, PyPI integration, and update execution.
+"""
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+import requests
+from packaging.version import InvalidVersion, Version
+
+
+def detect_installation_method() -> str:
+    """
+    Detect how KiLM was installed to determine appropriate update strategy.
+    Returns: 'pipx' | 'pip' | 'pip-venv' | 'uv' | 'conda'
+    """
+    executable_path = Path(sys.executable)
+
+    # Check for pipx installation
+    if any(
+        part in str(executable_path) for part in [".local/share/pipx", "pipx/venvs"]
+    ):
+        return "pipx"
+
+    if os.environ.get("PIPX_HOME") and "pipx" in str(executable_path):
+        return "pipx"
+
+    # Check for conda installation
+    if os.environ.get("CONDA_DEFAULT_ENV") or "conda" in str(executable_path):
+        return "conda"
+
+    # Check for uv installation (only via official environment variables)
+    if os.environ.get("UV_TOOL_DIR") or os.environ.get("UV_TOOL_BIN_DIR"):
+        return "uv"
+
+    # Check for virtual environment (pip in venv)
+    if os.environ.get("VIRTUAL_ENV") or sys.prefix != getattr(
+        sys, "base_prefix", sys.prefix
+    ):
+        return "pip-venv"
+
+    # Check for homebrew installation (strict path check)
+    if str(executable_path).startswith(("/opt/homebrew/", "/usr/local/Cellar/")):
+        return "homebrew"
+
+    # Default to system pip
+    return "pip"
+
+
+class PyPIVersionChecker:
+    """Responsible PyPI API client with caching and proper headers."""
+
+    def __init__(self, package_name: str, version: str = "unknown"):
+        self.package_name = package_name
+        self.base_url = f"https://pypi.org/pypi/{package_name}/json"
+        self.cache_file = Path.home() / ".cache" / "kilm" / "version_check.json"
+        self.user_agent = f"KiLM/{version} (+https://github.com/barisgit/KiLM)"
+
+    def check_latest_version(self) -> Optional[str]:
+        """
+        Check latest version from PyPI with caching and rate limiting.
+        Returns None if check fails or is rate limited.
+        """
+        try:
+            headers = {"User-Agent": self.user_agent}
+
+            # Use cached ETag if available
+            cached_data = self._load_cache()
+            if cached_data is not None and "etag" in cached_data:
+                headers["If-None-Match"] = cached_data["etag"]
+
+            response = requests.get(self.base_url, headers=headers, timeout=10)
+
+            if response.status_code == 304:  # Not Modified
+                return cached_data.get("version") if cached_data else None
+
+            if response.status_code == 200:
+                data = response.json()
+                latest_version = data["info"]["version"]
+
+                # Cache response with ETag
+                self._save_cache(
+                    {
+                        "version": latest_version,
+                        "etag": response.headers.get("ETag"),
+                        "timestamp": time.time(),
+                    }
+                )
+
+                return latest_version
+
+        except (requests.RequestException, KeyError, json.JSONDecodeError):
+            # Fail silently - don't block CLI functionality
+            pass
+
+        return None
+
+    def _load_cache(self) -> Optional[Dict]:
+        """Load cached version data."""
+        if self.cache_file.exists():
+            try:
+                with Path(self.cache_file).open() as f:
+                    data = json.load(f)
+                    # Cache valid for 24 hours
+                    if time.time() - data.get("timestamp", 0) < 86400:
+                        return data
+            except (json.JSONDecodeError, KeyError):
+                pass
+        return None
+
+    def _save_cache(self, data: Dict):
+        """Save version data to cache."""
+        self.cache_file.parent.mkdir(parents=True, exist_ok=True)
+        with Path(self.cache_file).open("w") as f:
+            json.dump(data, f)
+
+
+def update_via_pipx() -> bool:
+    """Update KiLM via pipx. Most reliable method for CLI tools."""
+    try:
+        result = subprocess.run(
+            ["pipx", "upgrade", "kilm"], capture_output=True, text=True, timeout=300
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False
+
+
+def update_via_pip() -> bool:
+    """Update KiLM via pip."""
+    try:
+        # Use same Python interpreter that's running KiLM
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "kilm"],
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False
+
+
+def update_via_uv() -> bool:
+    """Update KiLM via uv."""
+    try:
+        result = subprocess.run(
+            ["uv", "tool", "upgrade", "kilm"],
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False
+
+
+class UpdateManager:
+    """Manages update checking and execution for KiLM."""
+
+    def __init__(self, current_version: str):
+        self.version_checker = PyPIVersionChecker("kilm")
+        self.current_version = current_version
+        self.installation_method = detect_installation_method()
+
+    def check_latest_version(self) -> Optional[str]:
+        """Check for latest version available on PyPI."""
+        return self.version_checker.check_latest_version()
+
+    def is_newer_version_available(self, latest_version: str) -> bool:
+        """Compare versions to determine if update is available."""
+        try:
+            current_ver = Version(self.current_version)
+            latest_ver = Version(latest_version)
+            return latest_ver > current_ver
+        except (InvalidVersion, AttributeError):
+            return False
+
+    def get_update_instruction(self) -> str:
+        """Get update instruction for the detected installation method."""
+        instructions = {
+            "pipx": "pipx upgrade kilm",
+            "pip": "pip install --upgrade kilm",
+            "pip-venv": "pip install --upgrade kilm",
+            "uv": "uv tool upgrade kilm",
+            "conda": "Conda package not yet available (planned for future)",
+            "homebrew": "Homebrew package not yet available (planned for future)",
+        }
+        return instructions.get(self.installation_method, "Check your package manager")
+
+    def can_auto_update(self) -> bool:
+        """Check if automatic update is possible for this installation method."""
+        return self.installation_method in ["pipx", "pip", "pip-venv", "uv"]
+
+    def perform_update(self) -> Tuple[bool, str]:
+        """
+        Execute update using detected installation method.
+        Returns: (success: bool, message: str)
+        """
+        if not self.can_auto_update():
+            instruction = self.get_update_instruction()
+            return False, f"Manual update required. Run: {instruction}"
+
+        update_functions = {
+            "pipx": update_via_pipx,
+            "pip": update_via_pip,
+            "pip-venv": update_via_pip,
+            "uv": update_via_uv,
+        }
+
+        update_func = update_functions.get(self.installation_method)
+        if update_func:
+            try:
+                success = update_func()
+                if success:
+                    return True, "KiLM updated successfully!"
+                else:
+                    instruction = self.get_update_instruction()
+                    return False, f"Auto-update failed. Try manually: {instruction}"
+            except Exception as e:
+                return False, f"Update error: {str(e)}"
+        else:
+            instruction = self.get_update_instruction()
+            return False, f"Unsupported installation method. Run: {instruction}"
diff --git a/kicad_lib_manager/cli.py b/kicad_lib_manager/cli.py
index 6c88d6a..90d95d7 100644
--- a/kicad_lib_manager/cli.py
+++ b/kicad_lib_manager/cli.py
@@ -15,6 +15,7 @@
 from .commands.pin import pin
 from .commands.setup import setup
 from .commands.status import status
+from .commands.sync import sync
 from .commands.template import template
 from .commands.unpin import unpin
 from .commands.update import update
@@ -39,6 +40,7 @@ def main():
 main.add_command(init)
 main.add_command(add_3d)
 main.add_command(config)
+main.add_command(sync)
 main.add_command(update)
 main.add_command(add_hook)
 main.add_command(template)
diff --git a/kicad_lib_manager/commands/add_hook/command.py b/kicad_lib_manager/commands/add_hook/command.py
index ed65d89..d7194ef 100644
--- a/kicad_lib_manager/commands/add_hook/command.py
+++ b/kicad_lib_manager/commands/add_hook/command.py
@@ -30,11 +30,11 @@
     show_default=True,
 )
 def add_hook(directory, force):
-    """Add a Git post-merge hook to automatically update KiCad libraries.
+    """Add a Git post-merge hook to automatically sync KiCad libraries.
 
     This command adds a Git post-merge hook to the specified repository
     (or the current directory if none specified) that automatically runs
-    'kilm update' after a 'git pull' or 'git merge' operation.
+    'kilm sync' after a 'git pull' or 'git merge' operation.
 
     This ensures your KiCad libraries are always up-to-date after pulling
     changes from remote repositories.
@@ -98,7 +98,7 @@ def add_hook(directory, force):
 
         click.echo(f"Successfully installed post-merge hook at {post_merge_hook}")
         click.echo(
-            "The hook will run 'kilm update' after every 'git pull' or 'git merge' operation."
+            "The hook will run 'kilm sync' after every 'git pull' or 'git merge' operation."
         )
 
         if post_merge_hook.exists() and "KiLM-managed section" in new_content:
diff --git a/kicad_lib_manager/commands/add_hook/docs.mdx b/kicad_lib_manager/commands/add_hook/docs.mdx
index 0a10c7a..2f811fb 100644
--- a/kicad_lib_manager/commands/add_hook/docs.mdx
+++ b/kicad_lib_manager/commands/add_hook/docs.mdx
@@ -5,7 +5,7 @@ description: Add a Git post-merge hook to automatically update KiLM-managed libr
 
 import { LinkCard, Card, CardGrid } from "@astrojs/starlight/components";
 
-The `kilm add-hook` command creates or modifies a Git `post-merge` hook script in a specified repository. This hook is designed to automatically run `kilm update` after successful `git pull` or `git merge` operations, helping keep your KiLM-managed libraries synchronized.
+The `kilm add-hook` command creates or modifies a Git `post-merge` hook script in a specified repository. This hook is designed to automatically run `kilm sync` after successful `git pull` or `git merge` operations, helping keep your KiLM-managed libraries synchronized.
 
 ## Usage
 
@@ -81,8 +81,8 @@ The command creates a `post-merge` hook with the following structure:
 # KiCad Library Manager auto-update hook
 # Added by kilm add-hook command
 
-echo "Running KiCad Library Manager update..."
-kilm update
+echo "Running KiCad Library Manager sync..."
+kilm sync
 
 # Uncomment to set up libraries automatically (use with caution)
 # kilm setup
@@ -124,8 +124,8 @@ You can manually edit the generated hook script to add more functionality. For e
 # KiCad Library Manager auto-update hook
 # Added by kilm add-hook command
 
-echo "Running KiCad Library Manager update..."
-kilm update
+echo "Running KiCad Library Manager sync..."
+kilm sync
 
 # Uncomment to set up libraries automatically (use with caution)
 kilm setup
@@ -158,8 +158,8 @@ kilm add-hook --directory /readonly/repo
 
 <CardGrid>
   <LinkCard
-    title="update"
-    href="/reference/cli/update/"
+    title="sync"
+    href="/reference/cli/sync/"
     description="The command that gets executed by the post-merge hook"
   />
   <LinkCard
diff --git a/kicad_lib_manager/commands/sync/__init__.py b/kicad_lib_manager/commands/sync/__init__.py
new file mode 100644
index 0000000..4f15a3d
--- /dev/null
+++ b/kicad_lib_manager/commands/sync/__init__.py
@@ -0,0 +1,7 @@
+"""
+Sync command - Update/sync library content from git repositories
+"""
+
+from .command import sync
+
+__all__ = ["sync", "check_for_library_changes"]
diff --git a/kicad_lib_manager/commands/sync/command.py b/kicad_lib_manager/commands/sync/command.py
new file mode 100644
index 0000000..b5ad7d9
--- /dev/null
+++ b/kicad_lib_manager/commands/sync/command.py
@@ -0,0 +1,318 @@
+"""
+Sync command implementation for KiCad Library Manager.
+Performs 'git pull' on all configured GitHub libraries (symbols/footprints).
+"""
+
+import subprocess
+from pathlib import Path
+
+import click
+
+from ...config import Config
+
+
+@click.command()
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    help="Show what would be synced without making changes",
+    show_default=True,
+)
+@click.option(
+    "--verbose",
+    is_flag=True,
+    default=False,
+    help="Show detailed output",
+    show_default=True,
+)
+@click.option(
+    "--auto-setup",
+    is_flag=True,
+    default=False,
+    help="Run 'kilm setup' automatically if new libraries are detected",
+    show_default=True,
+)
+def sync(dry_run, verbose, auto_setup):
+    """Sync all configured GitHub libraries with git pull.
+
+    This command syncs all configured GitHub libraries (symbols/footprints)
+    by performing a 'git pull' operation in each library directory.
+    It will only attempt to sync directories that are valid git repositories.
+
+    After syncing, the command will check if new libraries have been added
+    and recommend running 'kilm setup' if needed. Use --auto-setup to run
+    setup automatically when new libraries are detected.
+    """
+    config = Config()
+
+    # Get GitHub libraries from config (symbols/footprints)
+    libraries = config.get_libraries(library_type="github")
+
+    if not libraries:
+        click.echo("No GitHub libraries configured. Use 'kilm init' to add a library.")
+        return
+
+    click.echo(f"Syncing {len(libraries)} KiCad GitHub libraries...")
+
+    updated_count = 0  # Actually changed
+    up_to_date_count = 0  # Already at latest version
+    skipped_count = 0  # Could not sync (not git, etc.)
+    failed_count = 0  # Git pull failed
+
+    # Track libraries that have changes that might require setup
+    libraries_with_changes = []
+
+    for lib in libraries:
+        lib_name = lib.get("name", "unnamed")
+        lib_path = lib.get("path")
+
+        if not lib_path:
+            click.echo(f"  Skipping {lib_name}: No path defined")
+            skipped_count += 1
+            continue
+
+        lib_path = Path(lib_path)
+        if not lib_path.exists():
+            click.echo(f"  Skipping {lib_name}: Path does not exist: {lib_path}")
+            skipped_count += 1
+            continue
+
+        git_dir = lib_path / ".git"
+        if not git_dir.exists() or not git_dir.is_dir():
+            click.echo(f"  Skipping {lib_name}: Not a git repository: {lib_path}")
+            skipped_count += 1
+            continue
+
+        # Prepare to run git pull
+        click.echo(f"  Syncing {lib_name} at {lib_path}...")
+
+        if dry_run:
+            click.echo(f"    Dry run: would execute 'git pull' in {lib_path}")
+            updated_count += 1
+            continue
+
+        try:
+            # Run git pull
+            result = subprocess.run(
+                ["git", "pull"],
+                cwd=lib_path,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                output = result.stdout.strip() or "Already up to date."
+                is_updated = "Already up to date" not in output
+
+                if verbose:
+                    click.echo(f"    Success: {output}")
+                    # Also show the short status for consistency
+                    if is_updated:
+                        click.echo("    Updated")
+                    else:
+                        click.echo("    Up to date")
+                else:
+                    if is_updated:
+                        click.echo("    Updated")
+                    else:
+                        click.echo("    Up to date")
+
+                # Update counters regardless of verbose flag
+                if is_updated:
+                    updated_count += 1
+                else:
+                    up_to_date_count += 1
+
+                # Check if there are new library files that would require setup
+                if is_updated:
+                    changes_require_setup = check_for_library_changes(lib_path)
+                    if changes_require_setup:
+                        libraries_with_changes.append(
+                            (lib_name, lib_path, changes_require_setup)
+                        )
+                        if verbose:
+                            click.echo(
+                                f"    Detected new library content: {', '.join(changes_require_setup)}"
+                            )
+            else:
+                click.echo(f"    Failed: {result.stderr.strip()}")
+                failed_count += 1
+
+        except Exception as e:
+            click.echo(f"    Error: {str(e)}")
+            failed_count += 1
+
+    # Summary
+    click.echo("\nSync Summary:")
+    click.echo(f"  {updated_count} libraries synced")
+    click.echo(f"  {up_to_date_count} libraries up to date")
+    click.echo(f"  {skipped_count} libraries skipped")
+    click.echo(f"  {failed_count} libraries failed")
+
+    # If libraries with changes were detected, suggest running setup
+    if libraries_with_changes:
+        click.echo("\nNew library content detected in:")
+        for lib_name, _lib_path, changes in libraries_with_changes:
+            click.echo(f"  - {lib_name}: {', '.join(changes)}")
+
+        if auto_setup:
+            click.echo("\nRunning 'kilm setup' to configure new libraries...")
+            # Import at runtime to avoid circular imports
+            try:
+                from ...commands.setup import setup as setup_cmd
+
+                # Create context using the command's built-in context factory
+                ctx = setup_cmd.make_context(
+                    "setup", args=[], parent=click.get_current_context()
+                )
+                setup_cmd.invoke(ctx)
+            except ImportError:
+                click.echo(
+                    "Error: Could not import setup command. Please run 'kilm setup' manually."
+                )
+        else:
+            click.echo(
+                "\nYou should run 'kilm setup' to configure the new libraries in KiCad."
+            )
+            click.echo(
+                "Run 'kilm sync --auto-setup' next time to automatically run setup after sync."
+            )
+    else:
+        click.echo(
+            "\nNo new libraries detected that would require running 'kilm setup'."
+        )
+        click.echo("Use 'kilm status' to check your current configuration.")
+
+
+# TODO: Should be in services or utils
+def check_for_library_changes(lib_path):
+    """
+    Check if git pull changes indicate new libraries that would require setup.
+    Uses git diff to analyze what files were added/changed in the pull.
+
+    Args:
+        lib_path: Path to the library directory
+
+    Returns:
+        List of change types found ('symbols', 'footprints', 'templates') or empty list if none
+    """
+    changes = []
+
+    try:
+        # Get the diff between HEAD~1 and HEAD to see what changed in the pull
+        result = subprocess.run(
+            ["git", "diff", "--name-status", "HEAD~1", "HEAD"],
+            cwd=lib_path,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        if result.returncode != 0:
+            # If we can't get the diff (e.g., first commit), fall back to checking current state
+            return _check_current_library_state(lib_path)
+
+        diff_output = result.stdout.strip()
+        if not diff_output:
+            return changes
+
+        # Parse the diff output to find relevant changes
+        for line in diff_output.split("\n"):
+            if not line.strip():
+                continue
+
+            # Parse git diff --name-status format: STATUS\tPATH
+            parts = line.split("\t", 1)
+            if len(parts) != 2:
+                continue
+
+            status, path = parts
+            # Only consider added (A) or modified (M) files, ignore deletions
+            if status not in ["A", "M", "R"]:
+                continue
+
+            # Check for symbol library changes
+            if _is_symbol_library_change(path) and "symbols" not in changes:
+                changes.append("symbols")
+
+            # Check for footprint library changes
+            if _is_footprint_library_change(path) and "footprints" not in changes:
+                changes.append("footprints")
+
+            # Check for template changes
+            if _is_template_change(path) and "templates" not in changes:
+                changes.append("templates")
+
+    except Exception:
+        # If git diff fails, fall back to checking current state
+        return _check_current_library_state(lib_path)
+
+    return changes
+
+
+def _is_symbol_library_change(path):
+    """Check if a path change indicates a symbol library change."""
+    # Look for .kicad_sym files in symbols directory
+    return path.startswith("symbols/") and path.endswith(".kicad_sym")
+
+
+def _is_footprint_library_change(path):
+    """Check if a path change indicates a footprint library change."""
+    # Look for .pretty directories or files within them
+    return (path.startswith("footprints/") and path.endswith(".pretty")) or (
+        path.startswith("footprints/") and ".pretty/" in path
+    )
+
+
+def _is_template_change(path):
+    """Check if a path change indicates a template change."""
+    # Look for metadata.yaml files in template directories
+    return path.startswith("templates/") and path.endswith("metadata.yaml")
+
+
+def _check_current_library_state(lib_path):
+    """
+    Fallback method to check current library state when git diff is not available.
+    This is used when we can't determine what changed in the pull.
+    """
+    changes = []
+
+    # Check for symbol libraries (.kicad_sym files)
+    symbols_path = lib_path / "symbols"
+    if (
+        symbols_path.exists()
+        and symbols_path.is_dir()
+        and any(
+            f.name.endswith(".kicad_sym") for f in symbols_path.glob("**/*.kicad_sym")
+        )
+    ):
+        changes.append("symbols")
+
+    # Check for footprint libraries (.pretty directories)
+    footprints_path = lib_path / "footprints"
+    if (
+        footprints_path.exists()
+        and footprints_path.is_dir()
+        and any(
+            f.is_dir() and f.name.endswith(".pretty")
+            for f in footprints_path.glob("**/*.pretty")
+        )
+    ):
+        changes.append("footprints")
+
+    # Check for project templates (directories with metadata.yaml)
+    templates_path = lib_path / "templates"
+    if (
+        templates_path.exists()
+        and templates_path.is_dir()
+        and any(
+            (f / "metadata.yaml").exists()
+            for f in templates_path.glob("*")
+            if f.is_dir()
+        )
+    ):
+        changes.append("templates")
+
+    return changes
diff --git a/kicad_lib_manager/commands/sync/docs.mdx b/kicad_lib_manager/commands/sync/docs.mdx
new file mode 100644
index 0000000..33359dd
--- /dev/null
+++ b/kicad_lib_manager/commands/sync/docs.mdx
@@ -0,0 +1,92 @@
+---
+title: sync
+description: Update configured Git-based libraries using git pull.
+---
+
+import { LinkCard, Card, CardGrid } from "@astrojs/starlight/components";
+
+The `kilm sync` command attempts to update all configured symbol, footprint, and template libraries (type `github`) that are identified as Git repositories by running `git pull` within their directories.
+
+This command helps keep your local copies of shared libraries synchronized with their remote Git repositories.
+
+:::note[Command History]
+In KiLM v0.4.0, library synchronization was moved from `kilm update` to `kilm sync` to make room for self-update functionality.
+:::
+
+## Usage
+
+```bash
+kilm sync [OPTIONS]
+```
+
+## Options
+
+- `--dry-run`:
+  Show which libraries are detected as Git repositories and would be updated, but do not actually run `git pull`.
+  _Example:_ `kilm sync --dry-run`
+
+- `--verbose`:
+  Show detailed output during the update process, including the full output from the `git pull` commands.
+  _Example:_ `kilm sync --verbose`
+
+- `--auto-setup`:
+  If the `git pull` operation results in changes that likely require updating KiCad's configuration (e.g., new symbol or footprint libraries detected), automatically run `kilm setup` after the updates are complete. Default: `False`.
+  _Example:_ `kilm sync --auto-setup`
+
+- `--help`:
+  Show the help message and exit.
+
+## Behavior
+
+1.  **Reads KiLM Config:** Loads library information from `config.yaml`.
+2.  **Identifies `github` Libraries:** Filters for libraries with type `github`.
+3.  **Checks for `.git`:** For each library path, checks if it exists and contains a `.git` directory.
+4.  **Runs `git pull`:** If it's a valid Git repository, navigates into the directory and executes `git pull` (unless `--dry-run`).
+5.  **Checks for Changes:** After a successful pull, analyzes the output and file system to detect if new symbol libraries (`.kicad_sym`), footprint libraries (`.pretty`), or templates (`templates/*/metadata.yaml`) were added.
+6.  **Reports & Optional Setup:** Summarizes the update results. If changes requiring configuration updates were detected, it recommends running `kilm setup` or runs it automatically if `--auto-setup` was specified.
+
+## Examples
+
+**Sync all Git-based libraries:**
+
+```bash
+kilm sync
+```
+
+**Preview which libraries would be synced:**
+
+```bash
+kilm sync --dry-run
+```
+
+**Sync libraries with detailed output:**
+
+```bash
+kilm sync --verbose
+```
+
+**Sync libraries and automatically run setup if needed:**
+
+```bash
+kilm sync --auto-setup
+```
+
+## Troubleshooting
+
+**Git pull fails with merge conflicts:**
+Navigate to the library directory and resolve conflicts manually using standard Git commands:
+
+```bash
+cd /path/to/library
+git status
+git merge --continue  # after resolving conflicts
+```
+
+**Library not found or not a Git repository:**
+- Ensure the library path is correct in your KiLM configuration
+- Verify the directory contains a `.git` folder
+- Use `kilm list` to check available libraries
+
+**Permission denied errors:**
+- Check file permissions in the library directory
+- Ensure you have write access to the library path
\ No newline at end of file
diff --git a/kicad_lib_manager/commands/update/__init__.py b/kicad_lib_manager/commands/update/__init__.py
index 8a0a7f6..1ed481f 100644
--- a/kicad_lib_manager/commands/update/__init__.py
+++ b/kicad_lib_manager/commands/update/__init__.py
@@ -1,3 +1,3 @@
-from .command import check_for_library_changes, update
+from .command import update
 
-__all__ = ["check_for_library_changes", "update"]
+__all__ = ["update"]
diff --git a/kicad_lib_manager/commands/update/command.py b/kicad_lib_manager/commands/update/command.py
index 2a6a47f..4a4a89e 100644
--- a/kicad_lib_manager/commands/update/command.py
+++ b/kicad_lib_manager/commands/update/command.py
@@ -1,238 +1,94 @@
 """
 Update command implementation for KiCad Library Manager.
-Performs 'git pull' on all configured GitHub libraries (symbols/footprints).
+Updates KiLM itself to the latest version.
 """
 
-import re
-import subprocess
-from pathlib import Path
-
 import click
 
-from ...config import Config
+from ... import __version__
+from ...auto_update import UpdateManager
 
 
 @click.command()
 @click.option(
-    "--dry-run",
-    is_flag=True,
-    default=False,
-    help="Show what would be updated without making changes",
-    show_default=True,
-)
-@click.option(
-    "--verbose",
+    "--check",
     is_flag=True,
     default=False,
-    help="Show detailed output",
+    help="Check for updates without installing",
     show_default=True,
 )
 @click.option(
-    "--auto-setup",
+    "--force",
     is_flag=True,
     default=False,
-    help="Run 'kilm setup' automatically if new libraries are detected",
+    help="Force update even if already up to date",
     show_default=True,
 )
-def update(dry_run, verbose, auto_setup):
-    """Update all configured GitHub libraries with git pull.
-
-    This command updates all configured GitHub libraries (symbols/footprints)
-    by performing a 'git pull' operation in each library directory.
-    It will only attempt to update directories that are valid git repositories.
-
-    After updating, the command will check if new libraries have been added
-    and recommend running 'kilm setup' if needed. Use --auto-setup to run
-    setup automatically when new libraries are detected.
-    """
-    config = Config()
-
-    # Get GitHub libraries from config (symbols/footprints)
-    libraries = config.get_libraries(library_type="github")
+def update(check, force):
+    """Update KiLM to the latest version.
 
-    if not libraries:
-        click.echo("No GitHub libraries configured. Use 'kilm init' to add a library.")
-        return
-
-    click.echo(f"Updating {len(libraries)} KiCad GitHub libraries...")
-
-    updated_count = 0  # Actually changed
-    up_to_date_count = 0  # Already at latest version
-    skipped_count = 0  # Could not update (not git, etc.)
-    failed_count = 0  # Git pull failed
-
-    # Track libraries that have changes that might require setup
-    libraries_with_changes = []
-
-    for lib in libraries:
-        lib_name = lib.get("name", "unnamed")
-        lib_path = lib.get("path")
+    This command updates KiLM itself by downloading and installing the latest
+    version from PyPI. The update method depends on how KiLM was installed
+    (pip, pipx, conda, etc.).
 
-        if not lib_path:
-            click.echo(f"  Skipping {lib_name}: No path defined")
-            skipped_count += 1
-            continue
+    ⚠️  DEPRECATION NOTICE:
+    In KiLM 0.4.0, the 'update' command now updates KiLM itself.
+    To update library content, use 'kilm sync' instead.
+    This banner will be removed in a future version.
 
-        lib_path = Path(lib_path)
-        if not lib_path.exists():
-            click.echo(f"  Skipping {lib_name}: Path does not exist: {lib_path}")
-            skipped_count += 1
-            continue
-
-        git_dir = lib_path / ".git"
-        if not git_dir.exists() or not git_dir.is_dir():
-            click.echo(f"  Skipping {lib_name}: Not a git repository: {lib_path}")
-            skipped_count += 1
-            continue
-
-        # Prepare to run git pull
-        click.echo(f"  Updating {lib_name} at {lib_path}...")
-
-        if dry_run:
-            click.echo(f"    Dry run: would execute 'git pull' in {lib_path}")
-            updated_count += 1
-            continue
+    Use --check to see if updates are available without installing.
+    """
+    # Display deprecation notice prominently
+    click.echo("\n" + "=" * 70)
+    click.echo("⚠️  BREAKING CHANGE NOTICE (KiLM 0.4.0)")
+    click.echo("=" * 70)
+    click.echo("The 'kilm update' command now updates KiLM itself.")
+    click.echo("To update library content, use 'kilm sync' instead.")
+    click.echo("This notice will be removed in a future version.")
+    click.echo("=" * 70 + "\n")
 
-        try:
-            # Run git pull
-            result = subprocess.run(
-                ["git", "pull"],
-                cwd=lib_path,
-                capture_output=True,
-                text=True,
-                check=False,
-            )
+    update_manager = UpdateManager(__version__)
 
-            if result.returncode == 0:
-                output = result.stdout.strip() or "Already up to date."
-                if verbose:
-                    click.echo(f"    Success: {output}")
-                else:
-                    is_updated = "Already up to date" not in output
-                    if is_updated:
-                        click.echo("    Updated")
-                        updated_count += 1
-                    else:
-                        click.echo("    Up to date")
-                        up_to_date_count += 1
+    click.echo(f"Current KiLM version: {__version__}")
+    click.echo(f"Installation method: {update_manager.installation_method}")
+    click.echo("\nChecking for updates...")
 
-                # Check if there are new library files that would require setup
-                if "Already up to date" not in output:
-                    changes_require_setup = check_for_library_changes(
-                        result.stdout, lib_path
-                    )
-                    if changes_require_setup:
-                        libraries_with_changes.append(
-                            (lib_name, lib_path, changes_require_setup)
-                        )
-                        if verbose:
-                            click.echo(
-                                f"    Detected new library content: {', '.join(changes_require_setup)}"
-                            )
-            else:
-                click.echo(f"    Failed: {result.stderr.strip()}")
-                failed_count += 1
+    latest_version = update_manager.check_latest_version()
 
-        except Exception as e:
-            click.echo(f"    Error: {str(e)}")
-            failed_count += 1
+    if latest_version is None:
+        click.echo("Could not check for updates. Please try again later.")
+        return
 
-    # Summary
-    click.echo("\nUpdate Summary:")
-    click.echo(f"  {updated_count} libraries updated")
-    click.echo(f"  {up_to_date_count} libraries up to date")
-    click.echo(f"  {skipped_count} libraries skipped")
-    click.echo(f"  {failed_count} libraries failed")
+    if not update_manager.is_newer_version_available(latest_version):
+        if not force:
+            click.echo(f"KiLM is up to date (v{__version__})")
+            return
+        else:
+            click.echo(f"Forcing update to v{latest_version} (current: v{__version__})")
+    else:
+        click.echo(f"New version available: {latest_version}")
 
-    # If libraries with changes were detected, suggest running setup
-    if libraries_with_changes:
-        click.echo("\nNew library content detected in:")
-        for lib_name, _lib_path, changes in libraries_with_changes:
-            click.echo(f"  - {lib_name}: {', '.join(changes)}")
+    if check:
+        if update_manager.is_newer_version_available(latest_version):
+            click.echo(f"\nUpdate available: {latest_version}")
+            click.echo(f"To update, run: {update_manager.get_update_instruction()}")
+        else:
+            click.echo("No updates available.")
+        return
 
-        if auto_setup:
-            click.echo("\nRunning 'kilm setup' to configure new libraries...")
-            # Import at runtime to avoid circular imports
-            try:
-                from ...commands.setup import setup as setup_cmd
+    # Perform the update
+    if update_manager.can_auto_update():
+        click.echo(f"\nUpdating KiLM to version {latest_version}...")
+        success, message = update_manager.perform_update()
 
-                ctx = click.Context(setup_cmd)
-                setup_cmd.invoke(ctx)
-            except ImportError:
-                click.echo(
-                    "Error: Could not import setup command. Please run 'kilm setup' manually."
-                )
+        if success:
+            click.echo(f"✅ {message}")
+            click.echo(f"KiLM has been updated to version {latest_version}")
         else:
-            click.echo(
-                "\nYou should run 'kilm setup' to configure the new libraries in KiCad."
-            )
-            click.echo(
-                "Run 'kilm update --auto-setup' next time to automatically run setup after updates."
-            )
+            click.echo(f"❌ {message}")
     else:
+        instruction = update_manager.get_update_instruction()
         click.echo(
-            "\nNo new libraries detected that would require running 'kilm setup'."
+            f"\nManual update required for {update_manager.installation_method} installation."
         )
-        click.echo("Use 'kilm status' to check your current configuration.")
-
-
-# TODO: Should be in services or utils
-def check_for_library_changes(git_output, lib_path):
-    """
-    Check if git pull output and filesystem changes indicate new libraries that would require setup.
-
-    Args:
-        git_output: Output from git pull command
-        lib_path: Path to the library directory
-
-    Returns:
-        List of change types found ('symbols', 'footprints', 'templates') or empty list if none
-    """
-    changes = []
-
-    # Check git output for new files in key directories
-    pattern = r"[^\s]+\s+\|\s+\d+ [+]+(?:-+)?\s+(?:symbols|footprints|templates|3d)"
-    if re.search(pattern, git_output, re.IGNORECASE):
-        # This is a basic heuristic that indicates changes in library directories
-        # For more accuracy, we'll check the actual directories
-        pass
-
-    # Check for specific library file types
-    symbols_path = lib_path / "symbols"
-    footprints_path = lib_path / "footprints"
-    templates_path = lib_path / "templates"
-
-    # Look for symbol libraries (.kicad_sym files)
-    if (
-        symbols_path.exists()
-        and symbols_path.is_dir()
-        and any(
-            f.name.endswith(".kicad_sym") for f in symbols_path.glob("**/*.kicad_sym")
-        )
-    ):
-        changes.append("symbols")
-
-    # Look for footprint libraries (.pretty directories)
-    if (
-        footprints_path.exists()
-        and footprints_path.is_dir()
-        and any(
-            f.is_dir() and f.name.endswith(".pretty")
-            for f in footprints_path.glob("**/*.pretty")
-        )
-    ):
-        changes.append("footprints")
-
-    # Look for project templates (directories with metadata.yaml)
-    if (
-        templates_path.exists()
-        and templates_path.is_dir()
-        and any(
-            (f / "metadata.yaml").exists()
-            for f in templates_path.glob("*")
-            if f.is_dir()
-        )
-    ):
-        changes.append("templates")
-
-    return changes
+        click.echo(f"Please run: {instruction}")
diff --git a/kicad_lib_manager/commands/update/docs.mdx b/kicad_lib_manager/commands/update/docs.mdx
index 3e772bd..186d0de 100644
--- a/kicad_lib_manager/commands/update/docs.mdx
+++ b/kicad_lib_manager/commands/update/docs.mdx
@@ -1,13 +1,19 @@
 ---
 title: update
-description: Update configured Git-based libraries using git pull.
+description: Update KiLM to the latest version from PyPI.
 ---
 
 import { LinkCard, Card, CardGrid } from "@astrojs/starlight/components";
 
-The `kilm update` command attempts to update all configured symbol, footprint, and template libraries (type `github`) that are identified as Git repositories by running `git pull` within their directories.
+The `kilm update` command updates KiLM itself to the latest version available on PyPI. It automatically detects your installation method and uses the appropriate update mechanism.
 
-This command helps keep your local copies of shared libraries synchronized with their remote Git repositories.
+:::caution[Breaking Change in v0.4.0]
+The `kilm update` command behavior changed in KiLM v0.4.0:
+- **Now:** Updates KiLM itself (self-update)
+- **Previously:** Updated library content (now use `kilm sync`)
+
+A deprecation banner will guide users during the transition period.
+:::
 
 ## Usage
 
@@ -17,54 +23,76 @@ kilm update [OPTIONS]
 
 ## Options
 
-- `--dry-run`:
-  Show which libraries are detected as Git repositories and would be updated, but do not actually run `git pull`.
-  _Example:_ `kilm update --dry-run`
-
-- `--verbose`:
-  Show detailed output during the update process, including the full output from the `git pull` commands.
-  _Example:_ `kilm update --verbose`
+- `--check`:
+  Check for available updates without installing them. Shows current version, latest version, and update instructions.
+  _Example:_ `kilm update --check`
 
-- `--auto-setup`:
-  If the `git pull` operation results in changes that likely require updating KiCad's configuration (e.g., new symbol or footprint libraries detected), automatically run `kilm setup` after the updates are complete. Default: `False`.
-  _Example:_ `kilm update --auto-setup`
+- `--force`:
+  Force update even if already up to date. Useful for reinstalling the current version.
+  _Example:_ `kilm update --force`
 
 - `--help`:
   Show the help message and exit.
 
 ## Behavior
 
-1.  **Reads KiLM Config:** Loads library information from `config.yaml`.
-2.  **Identifies `github` Libraries:** Filters for libraries with type `github`.
-3.  **Checks for `.git`:** For each library path, checks if it exists and contains a `.git` directory.
-4.  **Runs `git pull`:** If it's a valid Git repository, navigates into the directory and executes `git pull` (unless `--dry-run`).
-5.  **Checks for Changes:** After a successful pull, analyzes the output and file system to detect if new symbol libraries (`.kicad_sym`), footprint libraries (`.pretty`), or templates (`templates/*/metadata.yaml`) were added.
-6.  **Reports & Optional Setup:** Summarizes the update results. If changes requiring configuration updates were detected, it recommends running `kilm setup` or runs it automatically if `--auto-setup` was specified.
+1.  **Installation Detection:** Automatically detects how KiLM was installed (pipx, pip, uv).
+2.  **Version Check:** Queries PyPI for the latest available version using cached requests.
+3.  **Update Execution:** For supported methods (pipx, pip, uv), automatically executes the update command.
+4.  **Unavailable Methods:** For conda and homebrew (not yet published), provides information about planned availability.
+
+## Supported Installation Methods
+
+| Method | Auto-Update | Update Command |
+|--------|-------------|----------------|
+| **pipx** ✅ | Yes | `pipx upgrade kilm` |
+| **pip** ✅ | Yes | `pip install --upgrade kilm` |
+| **pip (venv)** ✅ | Yes | `pip install --upgrade kilm` |
+| **uv** ✅ | Yes | `uv tool upgrade kilm` |
+| **conda** | Unavailable | N/A (planned for future) |
+| **homebrew** | Unavailable | N/A (planned for future) |
 
 ## Examples
 
-**Update all Git-based libraries:**
+**Check for updates:**
 
 ```bash
-kilm update
+kilm update --check
 ```
 
-**Preview which libraries would be updated:**
+**Update KiLM to latest version:**
 
 ```bash
-kilm update --dry-run
+kilm update
 ```
 
-**Update libraries with detailed output:**
+**Force reinstall current version:**
 
 ```bash
-kilm update --verbose
+kilm update --force
 ```
 
-**Update libraries and automatically run setup if needed:**
+## Configuration
+
+Update checking behavior can be configured using `kilm config`:
 
 ```bash
-kilm update --auto-setup
+# Disable update checking
+kilm config set update_check false
+
+# Set check frequency
+kilm config set update_check_frequency weekly  # daily, weekly, never
 ```
 
-**Note:** If `git pull` fails (e.g., due to local changes or merge conflicts), you will need to resolve the issues manually within the affected repository directory using standard Git commands before `kilm update` can succeed for that library.
+## Troubleshooting
+
+**Update fails with permission errors:**
+- For system pip: Try `pip install --user --upgrade kilm`
+- For pipx: Reinstall with `pipx uninstall kilm && pipx install kilm`
+
+**Cannot detect installation method:**
+- Install via pipx for best CLI tool experience: `pipx install kilm`
+
+**Network/PyPI connection issues:**
+- Check internet connection
+- Try again later (PyPI may be temporarily unavailable)
\ No newline at end of file
diff --git a/kicad_lib_manager/config.py b/kicad_lib_manager/config.py
index 9c0c62e..76123f5 100644
--- a/kicad_lib_manager/config.py
+++ b/kicad_lib_manager/config.py
@@ -2,6 +2,7 @@
 Configuration management
 """
 
+import time
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, TypedDict, Union, cast
 
@@ -29,6 +30,9 @@ class LibraryDict(TypedDict):
 DEFAULT_CONFIG: Dict[str, ConfigValue] = {
     "max_backups": DEFAULT_MAX_BACKUPS,
     "libraries": DEFAULT_LIBRARIES,
+    "update_check": True,
+    "update_check_frequency": "daily",  # daily, weekly, never
+    "auto_update": False,  # Never auto-update without permission
 }
 
 
@@ -319,6 +323,128 @@ def _get_normalized_libraries(self) -> List[LibraryDict]:
 
         return normalized_libraries
 
+    def should_check_updates(self) -> bool:
+        """
+        Determine if update check should run based on configuration.
+
+        Returns:
+            True if update check should be performed
+        """
+        if not self.get("update_check", True):
+            return False
+
+        frequency = self.get("update_check_frequency", "daily")
+        if frequency == "never":
+            return False
+
+        # Check if we've checked recently based on frequency
+        cache_dir = Path.home() / ".cache" / "kilm"
+        last_check_file = cache_dir / "last_update_check"
+
+        if not last_check_file.exists():
+            return True
+
+        try:
+            last_check = float(last_check_file.read_text().strip())
+            now = time.time()
+
+            if frequency == "daily":
+                return now - last_check > 86400  # 24 hours
+            elif frequency == "weekly":
+                return now - last_check > 604800  # 7 days
+        except (ValueError, OSError):
+            return True
+
+        return False
+
+    def mark_update_check_performed(self) -> None:
+        """Mark that an update check was performed."""
+
+        cache_dir = Path.home() / ".cache" / "kilm"
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        last_check_file = cache_dir / "last_update_check"
+        last_check_file.write_text(str(time.time()))
+
+    def get_update_preferences(self) -> Dict[str, Union[bool, str]]:
+        """
+        Get update-related preferences.
+
+        Returns:
+            Dictionary containing update preferences
+        """
+        return {
+            "update_check": bool(self.get("update_check", True)),
+            "update_check_frequency": str(self.get("update_check_frequency", "daily")),
+            "auto_update": bool(self.get("auto_update", False)),
+        }
+
+    def set_update_preference(self, key: str, value: Union[bool, str]) -> None:
+        """
+        Set an update preference with strict type validation and coercion.
+
+        Args:
+            key: Preference key ('update_check', 'update_check_frequency', 'auto_update')
+            value: Preference value (will be coerced to appropriate type)
+        """
+        valid_keys = {"update_check", "update_check_frequency", "auto_update"}
+        if key not in valid_keys:
+            raise ValueError(f"Invalid update preference key: {key}")
+
+        # Handle boolean keys with type coercion
+        if key in {"update_check", "auto_update"}:
+            coerced_value = self._coerce_to_bool(value)
+        # Handle frequency key with string validation
+        elif key == "update_check_frequency":
+            if not isinstance(value, str):
+                raise ValueError(
+                    f"update_check_frequency must be a string, got {type(value).__name__}"
+                )
+            valid_frequencies = {"daily", "weekly", "never"}
+            if value not in valid_frequencies:
+                raise ValueError(
+                    f"Invalid frequency: {value}. Must be one of: {valid_frequencies}"
+                )
+            coerced_value = value
+        else:
+            coerced_value = value
+
+        self.set(key, coerced_value)
+        self.save()
+
+    def _coerce_to_bool(self, value: Union[bool, str]) -> bool:
+        """
+        Coerce a value to boolean with strict validation.
+
+        Args:
+            value: Value to coerce (bool or string)
+
+        Returns:
+            Boolean value
+
+        Raises:
+            ValueError: If value cannot be coerced to boolean
+        """
+        if isinstance(value, bool):
+            return value
+
+        if isinstance(value, str):
+            value_lower = value.lower().strip()
+            if value_lower in {"true", "1", "yes"}:
+                return True
+            elif value_lower in {"false", "0", "no"}:
+                return False
+            else:
+                raise ValueError(
+                    f"Invalid boolean value: '{value}'. "
+                    f"Must be one of: true, false, 1, 0, yes, no (case-insensitive)"
+                )
+
+        # Should never happen
+        raise ValueError(
+            f"Cannot coerce {type(value).__name__} to boolean. "
+            f"Expected bool or string, got {type(value).__name__}"
+        )
+
 
 def _make_library_dict(name: str, path: str, type_: str) -> LibraryDict:
     """Typed constructor for `LibraryDict` to satisfy type checker."""
diff --git a/kicad_lib_manager/utils/git_utils.py b/kicad_lib_manager/utils/git_utils.py
index c56df59..25faea5 100644
--- a/kicad_lib_manager/utils/git_utils.py
+++ b/kicad_lib_manager/utils/git_utils.py
@@ -131,14 +131,14 @@ def create_kilm_hook_content() -> str:
         Formatted hook content string
     """
     return """# BEGIN KiLM-managed section
-# KiCad Library Manager auto-update hook
+# KiCad Library Manager auto-sync hook
 # Added by kilm add-hook command
 
-echo "Running KiCad Library Manager update..."
-kilm update
+echo "Running KiCad Library Manager sync..."
+kilm sync
 
 # Uncomment to set up libraries automatically (use with caution)
 # kilm setup
 
-echo "KiCad libraries update complete."
+echo "KiCad libraries sync complete."
 # END KiLM-managed section"""
diff --git a/pyproject.toml b/pyproject.toml
index 1a30e7a..606766f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kilm"
-version = "0.3.1"
+version = "0.4.0"
 description = "A command-line tool for managing KiCad libraries across projects and workstations"
 readme = "README.md"
 license = "MIT"
@@ -44,11 +44,13 @@ keywords = [
 requires-python = ">=3.8"
 dependencies = [
     "click>=8.0",
+    "packaging>=25.0",
     "pyyaml>=6.0",
     "pathlib>=1.0.1",
     "pathspec>=0.12.1",
     "jinja2>=3.1.6",
     "questionary>=1.10.0",
+    "requests>=2.32.4",
 ]
 
 [project.optional-dependencies]
diff --git a/tests/test_git_utils.py b/tests/test_git_utils.py
index fe949d1..05d123c 100644
--- a/tests/test_git_utils.py
+++ b/tests/test_git_utils.py
@@ -24,7 +24,7 @@ def test_create_kilm_hook_content(self):
 
         assert "BEGIN KiLM-managed section" in content
         assert "END KiLM-managed section" in content
-        assert "kilm update" in content
+        assert "kilm sync" in content
         assert "kilm setup" in content
         assert content.startswith("# BEGIN KiLM-managed section")
         assert content.endswith("# END KiLM-managed section")
@@ -77,7 +77,7 @@ def test_merge_hook_content_replace_existing(self):
         assert result.count("BEGIN KiLM-managed section") == 1
         assert result.count("END KiLM-managed section") == 1
         assert "old kilm content" not in result
-        assert "kilm update" in result
+        assert "kilm sync" in result
 
     @patch("subprocess.run")
     def test_get_git_hooks_directory_standard(self, mock_run, tmp_path):
diff --git a/tests/test_sync_command.py b/tests/test_sync_command.py
new file mode 100644
index 0000000..2cbaab8
--- /dev/null
+++ b/tests/test_sync_command.py
@@ -0,0 +1,265 @@
+"""
+Tests for KiCad Library Manager sync command (formerly update command).
+"""
+
+from pathlib import Path
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from kicad_lib_manager.cli import main
+from kicad_lib_manager.commands.sync.command import check_for_library_changes
+
+# Sample test libraries
+TEST_LIBRARIES = [
+    {"name": "test-lib", "path": "/path/to/test/library", "type": "github"}
+]
+
+
+@pytest.fixture
+def mock_config(monkeypatch):
+    """Mock configuration with test libraries."""
+    config_mock = MagicMock()
+    config_mock.get_libraries.return_value = TEST_LIBRARIES
+
+    monkeypatch.setattr(
+        "kicad_lib_manager.commands.sync.command.Config", lambda: config_mock
+    )
+    return config_mock
+
+
+@pytest.fixture
+def mock_subprocess_run(monkeypatch):
+    """Mock subprocess.run to simulate git pull and git diff results."""
+    run_mock = MagicMock()
+
+    # Create different results for different calls
+    def mock_run_side_effect(*args, **kwargs):
+        result = MagicMock()
+        result.returncode = 0
+
+        # Check if this is a git diff call
+        if args[0] == ["git", "diff", "--name-status", "HEAD~1", "HEAD"]:
+            result.stdout = "A\tsymbols/newlib.kicad_sym"
+        else:
+            # This is a git pull call
+            result.stdout = "Updating abcd123..efgh456\nsymbols/newlib.kicad_sym | 120 ++++++++++++\n1 file changed"
+
+        return result
+
+    run_mock.side_effect = mock_run_side_effect
+    monkeypatch.setattr("subprocess.run", run_mock)
+    return run_mock
+
+
+@pytest.fixture
+def mock_path_methods(monkeypatch):
+    """Mock Path methods to simulate filesystem."""
+
+    # Mock Path.exists to return True for all paths to avoid "Path does not exist" errors
+    def mock_exists(self):
+        return True
+
+    # Mock Path.is_dir to return True for directories
+    def mock_is_dir(self):
+        return True
+
+    # Mock Path / operator to properly build paths
+    def mock_truediv(self, other):
+        return Path(f"{self}/{other}")
+
+    # Mock glob to simulate finding library files
+    def mock_glob(self, pattern):
+        if "**/*.kicad_sym" in pattern:
+            mock_file = MagicMock()
+            mock_file.name = "test.kicad_sym"
+            return [mock_file]
+        elif "**/*.pretty" in pattern:
+            mock_dir = MagicMock()
+            mock_dir.name = "test.pretty"
+            mock_dir.is_dir.return_value = True
+            return [mock_dir]
+        elif "*" in pattern and "metadata.yaml" not in str(self):
+            mock_dir = MagicMock()
+            mock_dir.name = "template-dir"
+            mock_dir.__truediv__ = lambda self, other: Path(f"{self}/{other}")
+            mock_dir.exists = lambda: True
+            return [mock_dir]
+        return []
+
+    monkeypatch.setattr(Path, "exists", mock_exists)
+    monkeypatch.setattr(Path, "is_dir", mock_is_dir)
+    monkeypatch.setattr(Path, "__truediv__", mock_truediv)
+    monkeypatch.setattr(Path, "glob", mock_glob)
+
+
+def test_sync_command(mock_config, mock_subprocess_run, mock_path_methods):
+    """Test the basic sync command."""
+    runner = CliRunner()
+    result = runner.invoke(main, ["sync"])
+
+    assert result.exit_code == 0
+    assert "Syncing 1 KiCad GitHub libraries" in result.output
+    assert "Updated" in result.output
+    assert "1 libraries synced" in result.output
+
+    # Verify subprocess was called correctly
+    # Should be called twice: once for git pull, once for git diff
+    assert mock_subprocess_run.call_count == 2
+
+    # Check the first call (git pull)
+    first_call_args, first_call_kwargs = mock_subprocess_run.call_args_list[0]
+    assert first_call_args[0] == ["git", "pull"]
+    assert first_call_kwargs["check"] is False
+
+    # Check the second call (git diff)
+    second_call_args, second_call_kwargs = mock_subprocess_run.call_args_list[1]
+    assert second_call_args[0] == ["git", "diff", "--name-status", "HEAD~1", "HEAD"]
+    assert second_call_kwargs["check"] is False
+
+
+def test_sync_with_auto_setup(mock_config, mock_subprocess_run, mock_path_methods):
+    """Test sync with auto-setup option."""
+    # Mock the setup module import
+    setup_module_mock = Mock()
+    setup_command_mock = Mock(name="setup_command")
+    setup_command_mock.make_context = Mock(return_value=Mock())
+    setup_command_mock.invoke = Mock()
+    setup_module_mock.setup = setup_command_mock
+
+    # Mock the module import
+    with patch.dict(
+        "sys.modules", {"kicad_lib_manager.commands.setup": setup_module_mock}
+    ), patch("click.get_current_context", return_value=Mock()):
+        runner = CliRunner()
+        result = runner.invoke(main, ["sync", "--auto-setup"])
+
+        assert result.exit_code == 0
+        assert "Running 'kilm setup'" in result.output
+
+        # Verify that make_context and invoke were called
+        setup_command_mock.make_context.assert_called_once()
+        setup_command_mock.invoke.assert_called_once()
+
+
+def test_sync_with_already_up_to_date(mock_config, mock_path_methods):
+    """Test update when repositories are already up to date."""
+    # Create a mock that returns "Already up to date" for git pull
+    mock_run = MagicMock()
+    result = MagicMock()
+    result.returncode = 0
+    result.stdout = "Already up to date."
+    mock_run.return_value = result
+
+    with patch("subprocess.run", mock_run):
+        runner = CliRunner()
+        result = runner.invoke(main, ["sync"])
+
+        assert result.exit_code == 0
+        assert "Up to date" in result.output
+        assert "0 libraries synced" in result.output
+        assert "1 libraries up to date" in result.output
+
+
+def test_sync_with_verbose(mock_config, mock_subprocess_run, mock_path_methods):
+    """Test update with verbose option."""
+    runner = CliRunner()
+    result = runner.invoke(main, ["sync", "--verbose"])
+
+    assert result.exit_code == 0
+    assert "Success:" in result.output
+
+
+def test_sync_dry_run(mock_config, mock_subprocess_run, mock_path_methods):
+    """Test update with dry-run option."""
+    runner = CliRunner()
+    result = runner.invoke(main, ["sync", "--dry-run"])
+
+    assert result.exit_code == 0
+    assert "Dry run: would execute 'git pull'" in result.output
+
+    # Verify subprocess was not called for git pull
+    mock_subprocess_run.assert_not_called()
+
+
+def test_sync_no_libraries(monkeypatch):
+    """Test sync when no libraries are configured."""
+    config_mock = MagicMock()
+    config_mock.get_libraries.return_value = []
+    monkeypatch.setattr(
+        "kicad_lib_manager.commands.sync.command.Config", lambda: config_mock
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["sync"])
+
+    assert result.exit_code == 0
+    assert "No GitHub libraries configured" in result.output
+
+
+def test_check_for_library_changes():
+    """Test the library change detection function."""
+    # Create a temporary test directory
+    tmp_path = Path("/tmp/test_lib")
+
+    # Mock subprocess.run to simulate git diff output
+    with patch("subprocess.run") as mock_run:
+        # Mock successful git diff with symbol library changes
+        result = MagicMock()
+        result.returncode = 0
+        result.stdout = (
+            "A\tsymbols/newlib.kicad_sym\nM\tfootprints/existing.pretty/file.kicad_mod"
+        )
+        mock_run.return_value = result
+
+        # Test the function with new signature (only lib_path)
+        changes = check_for_library_changes(tmp_path)
+
+        # Should detect both symbols and footprints changes
+        assert "symbols" in changes
+        assert "footprints" in changes
+        assert "templates" not in changes
+
+        # Verify git diff was called correctly
+        mock_run.assert_called_once_with(
+            ["git", "diff", "--name-status", "HEAD~1", "HEAD"],
+            cwd=tmp_path,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+
+def test_check_for_library_changes_fallback():
+    """Test the library change detection function fallback when git diff fails."""
+    # Create a temporary test directory
+    tmp_path = Path("/tmp/test_lib")
+
+    # Mock subprocess.run to simulate git diff failure
+    with patch("subprocess.run") as mock_run:
+        # Mock failed git diff
+        result = MagicMock()
+        result.returncode = 1
+        result.stdout = ""
+        mock_run.return_value = result
+
+        # Mock file existence with a patch for fallback behavior
+        with patch.object(Path, "exists", return_value=True), patch.object(
+            Path, "is_dir", return_value=True
+        ), patch.object(Path, "glob") as mock_glob:
+            # Setup mock glob to return symbol files
+            def mock_glob_func(pattern):
+                if "**/*.kicad_sym" in pattern:
+                    mock_file = MagicMock()
+                    mock_file.name = "test.kicad_sym"
+                    return [mock_file]
+                return []
+
+            mock_glob.side_effect = mock_glob_func
+
+            # Test the function fallback behavior
+            changes = check_for_library_changes(tmp_path)
+            assert "symbols" in changes
+            assert "footprints" not in changes
+            assert "templates" not in changes
diff --git a/tests/test_update_command.py b/tests/test_update_command.py
deleted file mode 100644
index 3a3f055..0000000
--- a/tests/test_update_command.py
+++ /dev/null
@@ -1,213 +0,0 @@
-"""
-Tests for KiCad Library Manager update command.
-"""
-
-from pathlib import Path
-from unittest.mock import MagicMock, Mock, patch
-
-import pytest
-from click.testing import CliRunner
-
-from kicad_lib_manager.cli import main
-from kicad_lib_manager.commands.update import check_for_library_changes
-
-# Sample test libraries
-TEST_LIBRARIES = [
-    {"name": "test-lib", "path": "/path/to/test/library", "type": "github"}
-]
-
-
-@pytest.fixture
-def mock_config(monkeypatch):
-    """Mock configuration with test libraries."""
-    config_mock = MagicMock()
-    config_mock.get_libraries.return_value = TEST_LIBRARIES
-
-    monkeypatch.setattr(
-        "kicad_lib_manager.commands.update.command.Config", lambda: config_mock
-    )
-    return config_mock
-
-
-@pytest.fixture
-def mock_subprocess_run(monkeypatch):
-    """Mock subprocess.run to simulate git pull results."""
-    run_mock = MagicMock()
-    # Return successful git pull by default
-    result = MagicMock()
-    result.returncode = 0
-    result.stdout = "Updating abcd123..efgh456\nsymbols/newlib.kicad_sym | 120 ++++++++++++\n1 file changed"
-    run_mock.return_value = result
-
-    monkeypatch.setattr("subprocess.run", run_mock)
-    return run_mock
-
-
-@pytest.fixture
-def mock_path_methods(monkeypatch):
-    """Mock Path methods to simulate filesystem."""
-
-    # Mock Path.exists to return True for all paths to avoid "Path does not exist" errors
-    def mock_exists(self):
-        return True
-
-    # Mock Path.is_dir to return True for directories
-    def mock_is_dir(self):
-        return True
-
-    # Mock Path / operator to properly build paths
-    def mock_truediv(self, other):
-        return Path(f"{self}/{other}")
-
-    # Mock glob to simulate finding library files
-    def mock_glob(self, pattern):
-        if "**/*.kicad_sym" in pattern:
-            mock_file = MagicMock()
-            mock_file.name = "test.kicad_sym"
-            return [mock_file]
-        elif "**/*.pretty" in pattern:
-            mock_dir = MagicMock()
-            mock_dir.name = "test.pretty"
-            mock_dir.is_dir.return_value = True
-            return [mock_dir]
-        elif "*" in pattern and "metadata.yaml" not in str(self):
-            mock_dir = MagicMock()
-            mock_dir.name = "template-dir"
-            mock_dir.__truediv__ = lambda self, other: Path(f"{self}/{other}")
-            mock_dir.exists = lambda: True
-            return [mock_dir]
-        return []
-
-    monkeypatch.setattr(Path, "exists", mock_exists)
-    monkeypatch.setattr(Path, "is_dir", mock_is_dir)
-    monkeypatch.setattr(Path, "__truediv__", mock_truediv)
-    monkeypatch.setattr(Path, "glob", mock_glob)
-
-
-def test_update_command(mock_config, mock_subprocess_run, mock_path_methods):
-    """Test the basic update command."""
-    runner = CliRunner()
-    result = runner.invoke(main, ["update"])
-
-    assert result.exit_code == 0
-    assert "Updating 1 KiCad GitHub libraries" in result.output
-    assert "Updated" in result.output
-    assert "1 libraries updated" in result.output
-
-    # Verify subprocess was called correctly
-    mock_subprocess_run.assert_called_once()
-    args, kwargs = mock_subprocess_run.call_args
-    assert args[0] == ["git", "pull"]
-    assert kwargs["check"] is False
-
-
-def test_update_with_auto_setup(mock_config, mock_subprocess_run, mock_path_methods):
-    """Test update with auto-setup option."""
-    # Create a mock context to track invocation
-    context_mock = Mock()
-
-    # Mock the Context class constructor to return our mock
-    with patch("click.Context", return_value=context_mock):
-        # Mock the setup module import
-        setup_module_mock = Mock()
-        setup_module_mock.setup = Mock(name="setup_command")
-
-        # Mock the module import
-        with patch.dict(
-            "sys.modules", {"kicad_lib_manager.commands.setup": setup_module_mock}
-        ):
-            runner = CliRunner()
-            result = runner.invoke(main, ["update", "--auto-setup"])
-
-            assert result.exit_code == 0
-            assert "Running 'kilm setup'" in result.output
-
-            # Since we've mocked Context and the setup module is properly returned by
-            # the import, we can verify the test succeeded if the output contains the
-            # expected message about running setup
-
-
-def test_update_with_already_up_to_date(mock_config, mock_path_methods):
-    """Test update when repositories are already up to date."""
-    # Create a mock that returns "Already up to date" for git pull
-    mock_run = MagicMock()
-    result = MagicMock()
-    result.returncode = 0
-    result.stdout = "Already up to date."
-    mock_run.return_value = result
-
-    with patch("subprocess.run", mock_run):
-        runner = CliRunner()
-        result = runner.invoke(main, ["update"])
-
-        assert result.exit_code == 0
-        assert "Up to date" in result.output
-        assert "0 libraries updated" in result.output
-        assert "1 libraries up to date" in result.output
-
-
-def test_update_with_verbose(mock_config, mock_subprocess_run, mock_path_methods):
-    """Test update with verbose option."""
-    runner = CliRunner()
-    result = runner.invoke(main, ["update", "--verbose"])
-
-    assert result.exit_code == 0
-    assert "Success:" in result.output
-
-
-def test_update_dry_run(mock_config, mock_subprocess_run, mock_path_methods):
-    """Test update with dry-run option."""
-    runner = CliRunner()
-    result = runner.invoke(main, ["update", "--dry-run"])
-
-    assert result.exit_code == 0
-    assert "Dry run: would execute 'git pull'" in result.output
-
-    # Verify subprocess was not called for git pull
-    mock_subprocess_run.assert_not_called()
-
-
-def test_update_no_libraries(monkeypatch):
-    """Test update when no libraries are configured."""
-    config_mock = MagicMock()
-    config_mock.get_libraries.return_value = []
-    monkeypatch.setattr(
-        "kicad_lib_manager.commands.update.command.Config", lambda: config_mock
-    )
-
-    runner = CliRunner()
-    result = runner.invoke(main, ["update"])
-
-    assert result.exit_code == 0
-    assert "No GitHub libraries configured" in result.output
-
-
-def test_check_for_library_changes():
-    """Test the library change detection function."""
-    # Create a temporary test directory
-    tmp_path = Path("/tmp/test_lib")
-
-    # Test with git output indicating new symbol library
-    git_output = "symbols/newlib.kicad_sym | 120 ++++++++++"
-
-    # Mock file existence with a patch
-    with patch.object(Path, "exists", return_value=True), patch.object(
-        Path, "is_dir", return_value=True
-    ), patch.object(Path, "glob") as mock_glob:
-        # Setup mock glob to return different files based on pattern
-        def mock_glob_func(pattern):
-            if "**/*.kicad_sym" in pattern:
-                mock_file = MagicMock()
-                mock_file.name = "test.kicad_sym"
-                return [mock_file]
-            elif "**/*.pretty" in pattern or "*" in pattern:
-                return []
-            return []
-
-        mock_glob.side_effect = mock_glob_func
-
-        # Test the function
-        changes = check_for_library_changes(git_output, tmp_path)
-        assert "symbols" in changes
-        assert "footprints" not in changes
-        assert "templates" not in changes